一、Lambda 表达式

  Lambda 是一个匿名函数,我们可以把 Lambda 表达式理解为是一段可以传递的代码。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格,使 Java 的语言表达能力得到了提升。Lambda 表达式的本质是作为函数式接口的实例,简化了内部类作为实例的代码。

语法格式一

  无参,无返回值。

匿名内部类

1    public static void anonymousInnerClass(){
2        Runnable r1=new Runnable() {
3            @Override
4            public void run() {
5                System.out.println("Yi-Xing");
6            }
7        };
8        r1.run();
9    }

Lambda 表达式

1    public static void lambda(){
2        Runnable r1=() -> System.out.println("Yi-Xing");
3        r1.run();
4    }

语法格式二

  Lambda 需要一个参数,但是没有返回值。

匿名内部类

1    public static void anonymousInnerClass(){
2        Consumer<String> consumer=new Consumer<String>() {
3            @Override
4            public void accept(String s) {
5                System.out.println(s);
6            }
7        };
8        consumer.accept("Yi-Xing");
9    }

Lambda 表达式

1    public static void lambda(){
2       Consumer<String> consumer= (String s)-> {
3           System.out.println(s);
4       };
5       consumer.accept("Yi-Xing");
6    }

语法格式三

  数据类型可以可以省略,因为可由编译器推断得出,称为“类型推断”。

Lambda 表达式

1    public static void lambda() {
2        Consumer<String> consumer = (s) -> {
3            System.out.println(s);
4        };
5        consumer.accept("Yi-Xing");
6    }

语法格式四

  Lambda 若只需要一个参数时,参数的小括号可以省略。

Lambda 表达式

1    public static void lambda() {
2        Consumer<String> consumer = s -> {
3            System.out.println(s);
4        };
5        consumer.accept("Yi-Xing");
6    }

语法格式五

  当 Lambda 体只有一条语句时,return 与大括号若有,都可以省略。

Lambda 表达式

1    public static void lambda() {
2        Comparator<Integer> comparator=(o1,o2)->{
3            return o1.compareTo(o2);
4        };
5    }

简化后

1    public static void lambda() {
2        Comparator<Integer> comparator = (o1, o2) -> o1.compareTo(o2);
3    }

语法格式六

  Lambda 可以有两个或两个以上的参数,多条执行语句,并且可以有返回值。

匿名内部类

 1    public static void anonymousInnerClass() {
 2        Comparator<Integer> comparator=new Comparator<Integer>() {
 3            @Override
 4            public int compare(Integer o1, Integer o2) {
 5                System.out.println(o1);
 6                System.out.println(o2);
 7                return o1.compareTo(o2);
 8            }
 9        };
10    }

Lambda 表达式

1    public static void lambda() {
2        Comparator<Integer> comparator=(o1,o2)->{
3            System.out.println(o1);
4            System.out.println(o2);
5            return o1.compareTo(o2);
6        };
7    }

二、函数式接口

  所谓函数式接口就是只包含一个抽象方法的接口,你可以通过 Lambda 表达式来创建该接口的对象。我们可以在一个接口上使用 @FunctionalInterface 注解,这样做可以检查它是否是一个函数式接口。在 java.util.function 包下定义了 Java 8 的丰富的函数式接口。

四大核心函数式接口

方法 解释
Consumer void accept(T t); 对类型为 T 的对象应用操作
Supplier T get(); 返回类型为 T 的对象
Function <T,R> R apply(T t); 对类型为 T 的对象应用操作,并返回结果。结果是 R 类型的对象
Predicate boolean test(T t); 确定类型为 T 的对象是否满足某种约束,并返回 boolean

  例子:

1    public static void main(String[] args) {
2        happyTime(500,(m -> System.out.println("原价:"+m)));
3        happyTime(300,(m -> System.out.println("现价:"+m)));
4    }
5
6    public static void happyTime(double money,Consumer<Double> consumer){
7        consumer.accept(money);
8    }

其他函数式接口

方法
BiFunction <T,U,R> R apply(T t, U u);
UnaryOperator T apply(T t);
BinaryOperator T apply(T t, T u);
BiConsumer <T,U> void accept(T t, U u);
BiPredicate <T,U> boolean test(T t, U u);
ToIntFunction int applyAsInt(T value);
IntFunction R apply(int value);

三、方法引用与构造器引用

方法引用

  当要传递给 Lambda 体的操作,已经有实现的方法了,可以使用方法引用。要求:实现接口的抽象方法的参数列表和返回值类型,必须与方法引用的放的参数列表和返回值类型保持一致,使用操作符 :: 将类(或对象)与方法名分割开来,有三种使用情况。

对象::实例方法名

Lambda 表达式

1    public static void lambda() {
2        Consumer<String> consumer=str -> System.out.println(str);
3        consumer.accept("Yi-Xing");
4    }

方法引用

1    public static void methodReference() {
2        Consumer<String> consumer=System.out::println;
3        consumer.accept("Yi-Xing");
4    }
类::静态方法名

Lambda 表达式

1    public static void lambda() {
2        Comparator<Integer> comparator=(t1,t2)->Integer.compare(t1,t2);
3        System.out.println(comparator.compare(12,21));
4    }

方法引用

1    public static void methodReference() {
2        Comparator<Integer> comparator=Integer::compare;
3        System.out.println(comparator.compare(12,21));
4    }
类::实例方法名

  Comparator 中的 int compare(T t1,T t2),String 中的 int t1.compareTo(t2)

Lambda 表达式

1    public static void lambda() {
2        Comparator<String> comparator=(s1,s2)->s1.compareTo(s2);
3        System.out.println(comparator.compare("abc","cba"));
4    }

方法引用

1    public static void methodReference() {
2        Comparator<String> comparator=String::compareTo;
3        System.out.println(comparator.compare("abc","cba"));
4    }

  Function 中的 R apply(T t),String 中的 int length()

Lambda 表达式

1    public static void lambda() {
2        Function<String ,Integer> function=e-> e.length();
3        System.out.println(function.apply("Yi-Xing"));
4    }

方法引用

1    public static void methodReference() {
2        Function<String ,Integer> function=String::length;
3        System.out.println(function.apply("Yi-Xing"));
4    }

构造器引用

  构造器引用和方法引用类似,函数式接口的抽象方法的形参列表和构造器的形参列表一致。抽象方法的返回值类型即位构造器所属类的类型。

实例 1:

匿名内部类

1    public static void anonymousInnerClass(){
2        Supplier<User> supplier=new Supplier<User>() {
3            @Override
4            public User get() {
5                return new User();
6            }
7        };
8    }

Lambda 表达式

1    public static void lambda() {
2        Supplier<User> supplier=() -> new User();
3    }

构造器引用

1    public static void constructionMethodReference() {
2        Supplier<User> supplier=User::new;
3    }
实例 2:

Lambda 表达式

1    public static void lambda() {
2        Function<Integer, User> function = id -> new User(id);
3        User user = function.apply(1);
4    }

构造器引用

1    public static void constructionMethodReference() {
2        Function<Integer, User> function = User::new;
3        User user = function.apply(1);
4    }

数组引用

  我们可以把数组看做是一个特殊的类,则写法与构造器引用一致。

Lambda 表达式

1    public static void lambda() {
2        Function<Integer, String[]> function = length -> new String[length];
3        String[] array = function.apply(6);
4    }

数组引用

1    public static void constructionMethodReference() {
2        Function<Integer, String[]> function = String[]::new;
3        String[] array = function.apply(6);
4    }

标题:Lambda 表达式、函数式接口、方法引用与构造器引用
作者:Yi-Xing
地址:http://zyxwmj.top/articles/2021/04/03/1617457598694.html
博客中若有不恰当的地方,请您一定要告诉我。前路崎岖,望我们可以互相帮助,并肩前行!