文章目录

• 一、为什么使用 Lambda 表达式
• 二、Lambda 表达式
• • 1.语法及应用
  • 2.类型推断
  • 3.小结
• 三、函数式(Functional)接口
• • 1.函数式(Functional)接口
  • 2.如何理解函数式接口
  • 3.Java 内置四大核心函数式接口
  • 4.其他接口
• 四、方法引用与构造器引用
• • 1.方法引用
  • 2.构造器引用
  • 3.数组引用

一、为什么使用 Lambda 表达式

Lambda 是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。

从匿名类到 Lambda 的转换举例1:

从匿名类到 Lambda 的转换举例2:

二、Lambda 表达式

1.语法及应用

Lambda 表达式： 在Java 8 语言中引入的一种新的语法元素和操作符。这个操作符为 “ -> ” ， 该操作符被称为 Lambda 操作符 或 箭头操作符 。它将 Lambda 分为两个部分：
左侧： 指定了 Lambda 表达式需要的 参数列表
右侧： 指定了 Lambda 体 ， 是抽象方法的实现逻辑，也即Lambda 表达式要执行的功能。

代码如下（示例）：

public class LambdaTest1 {    // 语法格式一： 无参，无返回值    @Test    public void test1() { Runnable ri = new Runnable() {     @Override     public void run() {  System.out.println(123456);     } }; ri.run(); System.out.println("============================="); // Lambda表达式的写法 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("java8新特性"); System.out.println("=============================="); Consumer<String> con1 = (String s) -> {     System.out.println(s); }; con1.accept("java8新特性");    }    // 语法格式三： 数据类型可以省略，因为可由编译器推断得出，称为“类型推断”    @Test    public void test3() { Consumer<String> con1 = (String s) -> {     System.out.println(s); }; con1.accept("java8新特性"); System.out.println("=============================="); Consumer<String> con2 = (s) -> {     System.out.println(s); }; con2.accept("java8新特性");    }    @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("java8新特性"); System.out.println("=============================="); Consumer<String> con2 = s -> {     System.out.println(s); }; con2.accept("java8新特性");    }    // 语法格式五： 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, 23)); 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, 6));    }    @Test    public void test8() { Consumer<String> con1 = s -> {     System.out.println(s); }; con1.accept("java8新特性"); System.out.println("=============================="); Consumer<String> con2 = s -> System.out.println(s); con2.accept("java8新特性");    }}

2.类型推断

上述 Lambda 表达式中的参数类型都是由编译器推断得出的。 Lambda表达式中无需指定类型，程序依然可以编译，这是因为 javac 根据程序的上下文，在后台推断出了参数的类型。 Lambda 表达式的类型依赖于上下文环境，是由编译器推断出来的。这就是所谓的 “类型推断” 。

3.小结

🍎 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表达式来写

三、函数式(Functional)接口

1.函数式(Functional)接口

🍎 只包含一个抽象方法的接口，称为函数式接口。
🍎 你可以通过 Lambda 表达式来创建该接口的对象。（若 Lambda 表达式抛出一个受检异常(即：非运行时异常)，那么该异常需要在目标接口的抽象方法上进行声明）。
🍎 我们可以在一个接口上使用 @FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口。同时javadoc 也会包含一条声明，说明这个接口是一个函数式接口。
🍎 在java.util.function包下定义了Java 8 的丰富的函数式接口。

2.如何理解函数式接口

🍎 Java从诞生日起就是一直倡导“一切皆对象”， 在Java里面面向对象 (OOP) 编程是一切。但是随着python、 scala等语言的兴起和新技术的挑战， Java不得不做出调整以便支持更加广泛的技术要求，也即 java不但可以支持OOP还可以支持OOF（面向函数编程）。
🍎 在函数式编程语言当中，函数被当做一等公民对待。在将函数作为一等公民的编程语言中， Lambda表达式的类型是函数。但是在Java8中，有所不同。在Java8中， Lambda表达式是对象，而不是函数，它们必须依附于一类特别的对象类型—— 函数式接口。
🍎 简单的说，在Java8中， Lambda表达式就是一个函数式接口的实例。 这就是Lambda表达式和函数式接口的关系。也就是说，只要一个对象是函数式接口的实例，那么该对象就可以用Lambda表达式来表示。
🍎 所以以前用匿名实现类表示的现在都可以用Lambda表达式来写。

/** * 自定义函数式接口 */@FunctionalInterfacepublic interface MyInterface {    void method1();}

3.Java 内置四大核心函数式接口

代码如下（示例）：

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> lists1 = filterString(list, new Predicate<String>() {     @Override     public boolean test(String s) {  return s.contains("京");     } }); System.out.println(lists1); System.out.println("==============================="); List<String> lists2 = filterString(list, s -> s.contains("京")); System.out.println(lists2);    }    // 根据给定的规则，过滤集合中的字符串。此规则由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;    }}

4.其他接口

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

1.方法引用

🍎 当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！
🍎 方法引用可以看做是Lambda表达式深层次的表达。换句话说，方法引用就是Lambda表达式，也就是函数式接口的一个实例，通过方法的名字来指向一个方法，可以认为是Lambda表达式的一个语法糖。
使用格式： 类(或对象) :: 方法名
🍎 要求： 实现接口的抽象方法的参数列表和返回值类型，必须与方法引用的方法的参数列表和返回值类型保持一致！
🍎 格式： 使用操作符 “ :: ” 将类(或对象) 与 方法名分隔开来。
🍎 如下三种主要使用情况：

• ⭐️ 情况一：对象 :: 实例方法名
• ⭐️ 情况二：类 :: 静态方法名
• ⭐️ 情况三：类 :: 实例方法名

方法引用使用的要求：要求接口中抽象方法的形参列表和返回值类型 与 方法引用的方法的形参列表和返回值类型相同！（针对于情况一和情况二）

注意： 当函数式接口方法的第一个参数是需要引用方法的调用者，并且第二个参数是需要引用方法的参数(或无参数)时： ClassName :: methodName

public class Employee {private int id;private String name;private int age;private double salary;public int getId() {return id;}public void setId(int id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public double getSalary() {return salary;}public void setSalary(double salary) {this.salary = salary;}public Employee() {System.out.println("Employee().....");}public Employee(int id) {System.out.println("Employee(int id).....");this.id = id;}public Employee(int id, String name) {this.id = id;this.name = name;System.out.println("Employee(int id, String name).....");}public Employee(int id, String name, int age, double salary) {this.id = id;this.name = name;this.age = age;this.salary = salary;}@Overridepublic String toString() {return "Employee{" + "id=" + id + ", name='" + name + '\'' + ", age=" + age + ", salary=" + salary + '}';}@Overridepublic boolean equals(Object o) {if (this == o)return true;if (o == null || getClass() != o.getClass())return false;Employee employee = (Employee) o;if (id != employee.id)return false;if (age != employee.age)return false;if (Double.compare(employee.salary, salary) != 0)return false;return name != null ? name.equals(employee.name) : employee.name == null;}@Overridepublic int hashCode() {int result;long temp;result = id;result = 31 * result + (name != null ? name.hashCode() : 0);result = 31 * result + age;temp = Double.doubleToLongBits(salary);result = 31 * result + (int) (temp ^ (temp >>> 32));return result;}}

public class MethodRefTest {// 情况一：对象 :: 实例方法//Consumer中的void accept(T t)//PrintStream中的void println(T t)@Testpublic void test1() {Consumer<String> con1 = str -> System.out.println(str);con1.accept("北京");System.out.println("===================");PrintStream ps = System.out;Consumer<String> con2 = ps :: println;con2.accept("西安");}//Supplier中的T get()//Employee中的String getName()@Testpublic void test2() {Employee emp = new Employee(1001, "Tom", 23, 15000);Supplier<String> sup1 = () -> emp.getName();System.out.println(sup1.get());System.out.println("========================");Supplier<String> sup2 = emp :: getName;System.out.println(sup2.get());}// 情况二：类 :: 静态方法//Comparator中的int compare(T t1,T t2)//Integer中的int compare(T t1,T t2)@Testpublic void test3() {Comparator<Integer> com1 = (t1, t2) -> Integer.compare(t1, t2);System.out.println(com1.compare(12, 23));System.out.println("========================");Comparator<Integer> com2 = Integer :: compare;System.out.println(com2.compare(12, 6));}//Function中的R apply(T t)//Math中的Long round(Double d)@Testpublic void test4() {Function<Double, Long> func = new Function<Double, Long>() {@Overridepublic Long apply(Double d) {return Math.round(d);}};System.out.println("========================");Function<Double, Long> func1 = d -> Math.round(d);System.out.println(func1.apply(12.3));System.out.println("========================");Function<Double, Long> func2 = Math :: round;System.out.println(func2.apply(12.6));}// 情况三：类 :: 实例方法 // Comparator中的int comapre(T t1,T t2)// String中的int t1.compareTo(t2)@Testpublic void test5() {Comparator<String> com = new Comparator<String>() {@Overridepublic int compare(String o1, String o2) {return o1.compareTo(o2);}};System.out.println(com.compare("abc", "abd"));System.out.println("========================");Comparator<String> com1 = (s1, s2) -> s1.compareTo(s2);System.out.println(com1.compare("abc", "abd"));System.out.println("========================");Comparator<String> com2 = String :: compareTo;System.out.println(com2.compare("abc", "abc"));}//BiPredicate中的boolean test(T t1, T t2);//String中的boolean t1.equals(t2)@Testpublic void test6() {BiPredicate<String, String> pre = new BiPredicate<String, String>() {@Overridepublic boolean test(String s1, String s2) {return s1.equals(s2);}};System.out.println(pre.test("abc", "abc"));System.out.println("========================");BiPredicate<String, String> pre1 = (s1, s2) -> s1.equals(s2);System.out.println(pre1.test("abb", "aab"));System.out.println("========================");BiPredicate<String, String> pre2 = String :: equals;System.out.println(pre2.test("acc", "acv"));}// Function中的R apply(T t)// Employee中的String getName();@Testpublic void test7() {Employee emp = new Employee(1001, "Jzx", 24, 18000);Function<Employee, String> func = new Function<Employee, String>() {@Overridepublic String apply(Employee employee) {return employee.getName();}};System.out.println(func.apply(emp));System.out.println("========================");Function<Employee, String> func1 = e -> e.getName();System.out.println(func1.apply(emp));System.out.println("========================");Function<Employee, String> func2 = Employee :: getName;System.out.println(func2.apply(emp));}}

2.构造器引用

🍎 格式： ClassName :: new
与函数式接口相结合，自动与函数式接口中方法兼容。
可以把构造器引用赋值给定义的方法， 要求构造器参数列表要与接口中抽象方法的参数列表一致！且方法的返回值即为构造器对应类的对象。

/** * 构造器引用： *      和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致。 *      抽象方法的返回值类型即为构造器所属的类的类型。 */public class ConstructorRefTest {//构造器引用    //Supplier中的T get()    // Employee 的空参构造器 Employee()    @Test    public void test1(){ Supplier<Employee> sup = new Supplier<Employee>() {     @Override     public Employee get() {  return new Employee();     } }; System.out.println("====================="); Supplier<Employee> sup1 = () -> new Employee(); Employee employee = sup1.get(); System.out.println(employee); System.out.println("====================="); Supplier<Employee> sup2 = Employee::new; Employee employee1 = sup2.get(); System.out.println(employee1);    }//Function中的R apply(T t)    @Test    public void test2(){ Function<Integer, Employee> func = new Function<Integer, Employee>() {     @Override     public Employee apply(Integer id) {  return new Employee(id);     } }; System.out.println("====================="); Function<Integer, Employee> func1 = id -> new Employee(id); Employee emp1 = func1.apply(1001); System.out.println(emp1); System.out.println("====================="); Function<Integer, Employee> func2 = Employee::new; Employee emp2 = func2.apply(1002); System.out.println(emp2);    }//BiFunction中的R apply(T t,U u)    @Test    public void test3(){ BiFunction<Integer, String, Employee> func = new BiFunction<Integer, String, Employee>() {     @Override     public Employee apply(Integer id, String name) {  return new Employee(1001, "Tom");     } }; System.out.println("====================="); BiFunction<Integer, String, Employee> func1 = (id, name) -> new Employee(id, name); Employee e1 = func1.apply(1001, "Tom"); System.out.println(e1); System.out.println("====================="); BiFunction<Integer, String, Employee> func2 = Employee::new; Employee e2 = func2.apply(1002, "Terry"); System.out.println(e2);    }}

3.数组引用

🍎 格式： type[] :: new

/** * 数组引用：可以把数组看做是一个特殊的类，则写法就与构造器引用一致了。 */public class ConstructorRefTest {//数组引用    //Function中的R apply(T t)    @Test    public void test4(){ Function<Integer, String[]> func = new Function<Integer, String[]>() {     @Override     public String[] apply(Integer length) {  return new String[length];     } }; System.out.println("====================="); Function<Integer, String[]> func1 = length -> new String[length]; String[] arr1 = func1.apply(5); System.out.println(Arrays.toString(arr1)); System.out.println("====================="); Function<Integer, String[]> func2 = String[] :: new; String[] arr2 = func2.apply(10); System.out.println(Arrays.toString(arr2));    }}

创作打卡挑战赛 赢取流量/现金/CSDN周边激励大奖