java8新特性:Lambda表达式

简介: java8新特性:Lambda表达式

总结于尚硅谷学习视频

视频链接

https://www.bilibili.com/video/BV1Kb411W75N?p=668

正文

Lambda表达式的使用

1.举例:(o1,o2)->Integer.compare(o1,o2)

2.格式:


-> :Lambda操作符 或箭头操作符

->左边:lambda形参列表(其实就是接口中的抽象方法的形参列表)

->右边:lambda体(其实就是重写的抽象方法的方法体)

3.lambda表达式的使用(分为6种情况)


总结:


->左边:Lambda形参列表的类型可以省略;如果Lambda形参列表只有一个参数,其一对()也可以省略

->右边:lambda体应该使用一对{}包裹;如果Lambda只有一条执行语句(可能是return语句),省略一对{}和return关键字

4.Lambda表达式的本质:作为函数式接口的实例


5.如果一个接口中,值声明了一个抽象方法,则此接口就称为函数式接口。


我们可以才接口上加一个注解 @FunctionalInterface ,这样做可以检查它是否是一个函数式接口。

6.所以以前用匿名实现类表示的现在都可以用Lambda表达式来写

java 内置的4大核心函数式接口

  • 消费型接口 Consumer void accept(T t)
  • 供给型接口 Supplier T get()
  • 函数型接口 Function<T,R> R apply(T t)
  • 断定型接口 Predicate boolean test(T t)

代码

LambdaTest 类

package com.day0326_3;
import org.junit.jupiter.api.Test;
import java.util.Comparator;
/**
 * LambdaTest表达式的使用举例
 */
public class LambdaTest {
    @Test
    public void test1(){
        Runnable r1=new Runnable() {
            @Override
            public void run() {
                System.out.println("我爱北京天安门");
            }
        };
        r1.run();
        System.out.println("*************************");
        Runnable r2=() ->System.out.println("我爱北京故宫");
        r2.run();
    }
    @Test
    public void test2(){
        Comparator<Integer> com1= new Comparator<Integer>() {
            @Override
            public int compare(Integer o1,Integer o2) {
                return Integer.compare(o1,o2);
            };
        };
        int compare1 = com1.compare(12, 21);
        System.out.println(compare1);
        System.out.println("******************");
        //Lambda表达式的写法
        Comparator<Integer> com2= (o1,o2)->Integer.compare(o1,o2);
        int compare2 = com2.compare(32, 21);
        System.out.println(compare2);
        System.out.println("******************");
        //方法引用
        Comparator<Integer> com3= Integer::compare;
        int compare3 = com2.compare(32, 21);
        System.out.println(compare3);
    }
}

LambdaTest1 类

package com.day0326_3;
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.function.Consumer;
/**
 * Lambda表达式的使用
 *
 * 1.举例:(o1,o2)->Integer.compare(o1,o2)
 * 2.格式:
 *  -> :Lambda操作符  或箭头操作符
 *  ->左边:lambda形参列表(其实就是接口中的抽象方法的形参列表)
 *  ->右边:lambda体(其实就是重写的抽象方法的方法体)
 *
 * 3.lambda表达式的使用(分为6种情况)
 *
 *  总结:
 *  ->左边:Lambda形参列表的类型可以省略;如果Lambda形参列表只有一个参数,其一对()也可以省略
 *  ->右边:lambda体应该使用一对{}包裹;如果Lambda只有一条执行语句(可能是return语句),省略一对{}和return关键字
 * 4.Lambda表达式的本质:作为函数式接口的实例
 *
 * 5.如果一个接口中,值声明了一个抽象方法,则此接口就称为函数式接口。
 * 我们可以才接口上加一个注解 @FunctionalInterface ,这样做可以检查它是否是一个函数式接口。
 *
 * 6.所以以前用匿名实现类表示的现在都可以用Lambda表达式来写
 *
 */
public class LambdaTest1 {
    //语法格式一:无参、无返回值
    @Test
    public void test1(){
        Runnable r1=new Runnable() {
            @Override
            public void run() {
                System.out.println("我爱北京天安门");
            }
        };
        r1.run();
        System.out.println("******************");
        Runnable r2=()->{
            System.out.println("我爱北京故宫");
        };
        r2.run();
    }
    //语法格式二:Lambda 需要一个参数,但是没有返回值。
    @Test
    public void test2(){
        Consumer<String> con =new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con.accept("谎言和誓言的区别是什么?");
        System.out.println("******************");
        Consumer<String> con1=(String s)->{
            System.out.println(s);
        };
        con1.accept("一个是听的人当真了,一个是说的人当真了");
    }
    //语法格式三:数据类型可以省略,因为可由编译器推断的出,称为“类型推断”
    @Test
    public void test3(){
        Consumer<String> con1=(String s)->{
            System.out.println(s);
        };
        con1.accept("一个是听的人当真了,一个是说的人当真了");
        System.out.println("******************");
        Consumer<String> con2=( s )->{
            System.out.println(s);
        };
        con2.accept("一个是听的人当真了,一个是说的人当真了");
    }
    @Test
    public void test4(){
        ArrayList<String> list=new ArrayList<>();//类型推断
        int[] arr={1,2,3};//类型推断
    }
    //语法格式四:Lambda若只需要一个参数时,参数的小括号可以省略
    @Test
    public void test5(){
        Consumer<String> con1=( s )->{
            System.out.println(s);
        };
        con1.accept("一个是听的人当真了,一个是说的人当真了");
        System.out.println("******************");
        Consumer<String> con2= s ->{
            System.out.println(s);
        };
        con2.accept("一个是听的人当真了,一个是说的人当真了");
    }
    //语法格式五:Lambda需要两个或两个以上的参数,多条执行语句,并且可以有返回值
    @Test
    public void test6(){
        Comparator<Integer> com1=new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println(o1);
                System.out.println(o2);
                return o1.compareTo(o2);
            }
        };
        System.out.println(com1.compare(12, 21));
        System.out.println("******************");
        Comparator<Integer> com2=(o1, o2) -> {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        };
        System.out.println(com2.compare(12, 6));
    }
    //语法格式六:当Lambda体只有一条语句时,return与大括号若有,都可以省略
    @Test
    public void test7(){
        Comparator<Integer> com1=(o1, o2) -> {
            return o1.compareTo(o2);
        };
        System.out.println(com1.compare(12, 6));
        System.out.println("******************");
        Comparator<Integer> com2=(o1, o2) -> o1.compareTo(o2);
        System.out.println(com2.compare(12, 21));
    }
    @Test
    public void test8(){
        Consumer<String> con1= s ->{
            System.out.println(s);
        };
        con1.accept("一个是听的人当真了,一个是说的人当真了");
        System.out.println("******************");
        Consumer<String> con2= s -> System.out.println(s);
        con2.accept("一个是听的人当真了,一个是说的人当真了");
    }
}

LambdaTest2 类

package com.day0326_3;
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;
/**
 * java 内置的4大核心函数式接口
 *
 * 消费型接口 Consumer<T>   void accept(T t)
 * 供给型接口 Supplier<T>    T get()
 * 函数型接口 Function<T,R>  R apply(T t)
 * 断定型接口 Predicate<T>   boolean test(T t)
 *
 */
public class LambdaTest2 {
    @Test
    public void test1() {
        happyTime(500, new Consumer<Double>() {
            @Override
            public void accept(Double aDouble) {
                System.out.println("学习太累了,去去天上人间买了矿泉水,价格为:" + aDouble);
            }
        });
        System.out.println("*****************");
        happyTime(400, money -> System.out.println("学习太累了,去去天上人间喝了口水,价格为:" + money));
    }
    public void happyTime(double money, Consumer<Double> con){
        con.accept(money);
    }
    @Test
    public void test2(){
        List<String> list= Arrays.asList("北京","南京","天津","东京","普京");
        List<String> filterStrs = filterString(list, new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.contains("京");
            }
        });
        System.out.println(filterStrs);
        List<String> filterStrs1=filterString(list,s->s.contains("京"));
        System.out.println(filterStrs1);
    }
    //根据给定的规则,过滤集合中的字符串,此规则由Predicate的方法决定
    public List<String> filterString(List<String> list, Predicate<String> pre){
        ArrayList<String> filterList=new ArrayList<>();
        for (String s :
                list) {
            if (pre.test(s)) {
                filterList.add(s);
            }
        }
        return filterList;
    }
}

myInterface接口

package com.day0326_3;
@FunctionalInterface
public interface myInterface {
    void method1();
//    void method2();
}

图片







相关文章
|
5天前
|
存储 Java
深入探讨了Java集合框架中的HashSet和TreeSet,解析了两者在元素存储上的无序与有序特性。
【10月更文挑战第16天】本文深入探讨了Java集合框架中的HashSet和TreeSet,解析了两者在元素存储上的无序与有序特性。HashSet基于哈希表实现,添加元素时根据哈希值分布,遍历时顺序不可预测;而TreeSet利用红黑树结构,按自然顺序或自定义顺序存储元素,确保遍历时有序输出。文章还提供了示例代码,帮助读者更好地理解这两种集合类型的使用场景和内部机制。
20 3
|
5天前
|
存储 Java 数据处理
Java Set接口凭借其独特的“不重复”特性,在集合框架中占据重要地位
【10月更文挑战第16天】Java Set接口凭借其独特的“不重复”特性,在集合框架中占据重要地位。本文通过快速去重和高效查找两个案例,展示了Set如何简化数据处理流程,提升代码效率。使用HashSet可轻松实现数据去重,而contains方法则提供了快速查找的功能,彰显了Set在处理大量数据时的优势。
15 2
|
7天前
|
存储 算法 Java
Java Set因其“无重复”特性在集合框架中独树一帜
【10月更文挑战第14天】Java Set因其“无重复”特性在集合框架中独树一帜。本文深入解析Set接口及其主要实现类(如HashSet、TreeSet)如何通过特定的数据结构(哈希表、红黑树)确保元素唯一性,并提供最佳实践建议,包括选择合适的Set实现类和正确实现自定义对象的`hashCode()`与`equals()`方法。
19 3
|
4天前
|
Java 测试技术 开发者
🌟Java零基础-Lambda运算符详解 🌟
【10月更文挑战第12天】本文收录于「滚雪球学Java」专栏,专业攻坚指数级提升,希望能够助你一臂之力,帮你早日登顶实现财富自由🚀;同时,欢迎大家关注&&收藏&&订阅!持续更新中,up!up!up!!
14 1
|
5天前
|
Java 开发者
在Java集合世界中,Set以其独特的特性脱颖而出,专门应对重复元素
在Java集合世界中,Set以其独特的特性脱颖而出,专门应对重复元素。通过哈希表和红黑树两种模式,Set能够高效地识别并拒绝重复元素的入侵,确保集合的纯净。无论是HashSet还是TreeSet,都能在不同的场景下发挥出色的表现,成为开发者手中的利器。
18 2
|
5天前
|
Java
Java Set以其“不重复”的特性,为我们提供了一个高效、简洁的处理唯一性约束数据的方式。
【10月更文挑战第16天】在Java编程中,Set接口确保集合中没有重复元素,每个元素都是独一无二的。HashSet基于哈希表实现,提供高效的添加、删除和查找操作;TreeSet则基于红黑树实现,不仅去重还能自动排序。通过这两个实现类,我们可以轻松处理需要唯一性约束的数据,提升代码质量和效率。
17 2
|
2月前
|
Java 程序员 API
Java 8新特性之Lambda表达式与Stream API的探索
【9月更文挑战第24天】本文将深入浅出地介绍Java 8中的重要新特性——Lambda表达式和Stream API,通过实例解析其语法、用法及背后的设计哲学。我们将一探究竟,看看这些新特性如何让Java代码变得更加简洁、易读且富有表现力,同时提升程序的性能和开发效率。
|
3月前
|
Java API
Java 8新特性:Lambda表达式与Stream API的深度解析
【7月更文挑战第61天】本文将深入探讨Java 8中的两个重要特性:Lambda表达式和Stream API。我们将首先介绍Lambda表达式的基本概念和语法,然后详细解析Stream API的使用和优势。最后,我们将通过实例代码演示如何结合使用Lambda表达式和Stream API,以提高Java编程的效率和可读性。
|
3月前
|
存储 算法 Oracle
19 Java8概述(Java8概述+lambda表达式+函数式接口+方法引用+Stream+新时间API)
19 Java8概述(Java8概述+lambda表达式+函数式接口+方法引用+Stream+新时间API)
63 8
|
3月前
|
Java API
Java8 Lambda 设计和实现问题之在Java 8的Stream API中,parallel=false时collect方法是如何实现的
Java8 Lambda 设计和实现问题之在Java 8的Stream API中,parallel=false时collect方法是如何实现的