• 方法引用与构造器引用（Method References）第三版

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

    方法引用的使用场景

    • 当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！
    • 方法引用，本质上就是Lambda表达式，而Lambda表达式作为函数式接口的实例。所以方法引用，也是函数式接口的实例

    方法引用使用的要求

    • 要求接口中的   抽象方法的形参列表和返回值类型   与   方法引用的方法的形参列表和返回值类型相同！

    1、对象：：实例方法

    1.1、Consumer

    •  Consumer     中 的 void accept （T t）

    •  PrintStream  中 的 void println  （T t）

    1.2、Supplier

    • Supplier 中的  T  get（）
    • Employee 中的 String getName（）
    1.   package com.methodreference;
    2.  
    3. import org.junit.Test;
    4.  
    5. import java.io.PrintStream;
    6. import java.util.function.Consumer;
    7. import java.util.function.Supplier;
    8.  
    9. public class MethodRefTest {
    10.  
    11.     // 情况一：对象：：实例方法
    12.     // Consumer    中的 void accept（T t）
    13.     // PrintStream 中的 void println（T t）
    14.     @Test
    15.     public void test1() {
    16.         Consumer con1 = str -> System.out.println(str);
    17.  
    18.         con1.accept("方法的引用");//方法的引用
    19.  
    20.         System.out.println("=============");
    21.  
    22.         PrintStream ps = System.out;
    23.         Consumer con2 = ps::println;
    24.         con2.accept("方法的引用");//方法的引用
    25.  
    26.         Consumer con3 = System.out::println;
    27.  
    28.         con3.accept("方法的引用");//方法的引用
    29.     }
    30.  
    31.     //Supplier中的 T get（）
    32.     //Employee中的 String getName（）
    33.     @Test
    34.     public void test2() {
    35.         Employee emp = new Employee(1001, "Tom", 23, 5600);
    36.         Supplier sup1 = () -> emp.getName();
    37.         System.out.println(sup1.get());//Tom
    38.  
    39.         System.out.println("=================");
    40.         //方法引用
    41.         Supplier sup2 = emp::getName;
    42.         System.out.println(sup2.get());//Tom
    43.         
    44.     }
    45.  
    46.     class Employee {
    47.         private Integer id;
    48.         private String name;
    49.         private Integer age;
    50.         private Integer salary;
    51.  
    52.         public Employee() {
    53.         }
    54.  
    55.         public Employee(Integer id, String name, Integer age, Integer salary) {
    56.             this.id = id;
    57.             this.name = name;
    58.             this.age = age;
    59.             this.salary = salary;
    60.         }
    61.  
    62.         public Integer getId() {
    63.             return id;
    64.         }
    65.  
    66.         public void setId(Integer id) {
    67.             this.id = id;
    68.         }
    69.  
    70.         public String getName() {
    71.             return name;
    72.         }
    73.  
    74.         public void setName(String name) {
    75.             this.name = name;
    76.         }
    77.  
    78.         public Integer getSalary() {
    79.             return salary;
    80.         }
    81.  
    82.         public void setSalary(Integer salary) {
    83.             this.salary = salary;
    84.         }
    85.  
    86.     }
    87. }

    2、类：：静态方法

    2.1、Comparator

    • Comparator 中的 int compare（T t1，T t2）
    • Integer 中 的int  compare（T t1，T t2）

    2.2、Function

    • Function 中的  R  apply（T  t）
    • Math 中的  Long round （Double d）
    1.     //情况二：类：：静态方法
    2.     //Comparator中的int compare(T t1,T t2)
    3.     //Integer中的int  compare(T t1,T t2)
    4.     @Test
    5.     public void test3() {
    6.         Comparator com1 = (t1, t2) -> Integer.compare(t1, t2);
    7.         System.out.println(com1.compare(12, 21));//-1
    8.  
    9.         System.out.println("=============");
    10.         Comparator com2 = Integer::compare;
    11.         System.out.println(com2.compare(12, 21));//-1
    12.     }
    13.  
    14.     //Function 中的 R apply(T t)
    15.     //Math中的Long round(Double d)
    16.     @Test
    17.     public void test4() {
    18.         Function func1 = d -> Math.round(d);
    19.         System.out.println(func1.apply(23.23));//23
    20.  
    21.         System.out.println("==========");
    22.         Function func2 = Math::round;
    23.         System.out.println(func2.apply(-45.78));//-46
    24.  
    25.     }

    3、类：：实体方法（有难度） 

    3.1、Comparator

    • Comparator 中的 int compare（T t1，T  t2）
    • String  中的 int  t1.compareTo（t2）

    3.2、BiPredicate

    • BiPredicate 中的 boolean  test（T t1，T t2）
    • String 中的  boolean  t1.equals（t2）

    3.3、Function

    • Function  中的   R   apply（T  t）
    • Employee  中的  String  getName（）
    1.     //情况三：类：：实例方法（有难度）
    2.     //Comparator 中的 int compare（T t1，T t2）
    3.     //String 中的 int t1.compareTo（t2）
    4.     @Test
    5.     public void test5() {
    6.         Comparator com1 = (t1, t2) -> t1.compareTo(t2);
    7.         System.out.println(com1.compare("23", "34"));//-1
    8.  
    9.         System.out.println("===============");
    10.         Comparator com2 = String::compareTo;
    11.         System.out.println(com2.compare("abd", "abm"));//-9
    12.     }
    13.  
    14.     //BiPredicate 中的boolean  test（T t1，T t2）
    15.     //String 中的boolean t1.equals（t2）
    16.     @Test
    17.     public void test6() {
    18.         BiPredicate pre1 = (s1, s2) -> s1.equals(s2);
    19.         System.out.println(pre1.test("abc", "abc"));//true
    20.  
    21.         System.out.println("=====================");
    22.         BiPredicate pre2 = String::equals;
    23.         System.out.println(pre1.test("97", "a"));//false
    24.     }
    25.  
    26.     //Function 中的 R apply（T t）
    27.     //Employee 中的String getName（）
    28.     @Test
    29.     public void test7() {
    30.  
    31.         Employee employee = new Employee(1001, "jerry", 23, 2900);
    32.  
    33.         Function func1 = e -> e.getName();
    34.         System.out.println(func1.apply(employee));//jerry
    35.  
    36.         System.out.println("====================");
    37.         Function func2 = Employee::getName;
    38.         System.out.println(func2.apply(employee));//jerry
    39.     }

    一、构造器引用

    • 和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致。抽象方法的返回值类型即为构造器所属的类的类型。
    1. package com.methodreference;
    2. import org.junit.Test;
    3. import java.util.function.BiFunction;
    4. import java.util.function.Function;
    5. import java.util.function.Supplier;
    6. public class ConstructRefTest {
    7.  
    8.     class Employee {
    9.         private Integer id;
    10.         private String name;
    11.         private Integer age;
    12.         private Integer salary;
    13.  
    14.         public Employee() {
    15.             System.out.println("方法的引用构造器引用");
    16.         }
    17.  
    18.         public Employee(Integer id) {
    19.             this.id = id;
    20.         }
    21.  
    22.         public Employee(Integer id, String name) {
    23.             this.id = id;
    24.             this.name = name;
    25.         }
    26.  
    27.         public Employee(Integer id, String name, Integer age, Integer salary) {
    28.             this.id = id;
    29.             this.name = name;
    30.             this.age = age;
    31.             this.salary = salary;
    32.         }
    33.  
    34.         public Integer getId() {
    35.             return id;
    36.         }
    37.  
    38.         public void setId(Integer id) {
    39.             this.id = id;
    40.         }
    41.  
    42.         public String getName() {
    43.             return name;
    44.         }
    45.  
    46.         public void setName(String name) {
    47.             this.name = name;
    48.         }
    49.  
    50.         public Integer getAge() {
    51.             return age;
    52.         }
    53.  
    54.         public void setAge(Integer age) {
    55.             this.age = age;
    56.         }
    57.  
    58.         public Integer getSalary() {
    59.             return salary;
    60.         }
    61.  
    62.         public void setSalary(Integer salary) {
    63.             this.salary = salary;
    64.         }
    65.  
    66.         @Override
    67.         public String toString() {
    68.             return "Employee{" +
    69.                     "id=" + id +
    70.                     ", name='" + name + '\'' +
    71.                     ", age=" + age +
    72.                     ", salary=" + salary +
    73.                     '}';
    74.         }
    75.     }
    76.  
    77.     //构造器引用
    78.     //Supplier 中的 T  get（）
    79.     //Employee的空参构造器：Employee（）
    80.     @Test
    81.     public void test1() {
    82.         Supplier sup = new Supplier() {
    83.             @Override
    84.             public Employee get() {
    85.                 return new Employee();
    86.             }
    87.         };
    88.  
    89.         Supplier sup1 = () -> new Employee();
    90.         System.out.println(sup1.get());//方法的引用构造器引用
    91. //        Employee{id=null, name='null', age=null, salary=null}
    92.     }
    93.  
    94.     //Function中的 R apply（T t）
    95.     @Test
    96.     public void test2() {
    97.  
    98.         Function func1 = id -> new Employee(id);
    99.         System.out.println(func1.apply(100));//Employee{id=100, name='null', age=null, salary=null}
    100.  
    101.         Function func2 = Employee::new;
    102.         System.out.println(func2.apply(200));//Employee{id=200, name='null', age=null, salary=null}
    103.     }
    104.  
    105.     //BiFunction 中的 R apply（T t，U u）
    106.     @Test
    107.     public void test3() {
    108.         BiFunction func1 = (id, name) -> new Employee(id, name);
    109.         System.out.println(func1.apply(1222, "小明"));//Employee{id=1222, name='小明', age=null, salary=null}
    110.  
    111.         System.out.println("=============");
    112.  
    113.         BiFunction func2 = Employee::new;
    114.         System.out.println(func2.apply(1000, "小兰"));//Employee{id=1000, name='小兰', age=null, salary=null}
    115.     }
    116. }
    117.

     二、数组引用

    • 大家可以把数组看做是一个特殊的类，则写法与构造器引用一致。
    1.     //数组引用
    2.     //Function 中的 R apply（T t）
    3.     @Test
    4.     public void test4() {
    5.         Function func1 = length -> new String[length];
    6.         System.out.println(Arrays.toString(func1.apply(4)));//[null, null, null, null]
    7.  
    8.         System.out.println("================");
    9.         Function func2 = String[]::new;
    10.         System.out.println(Arrays.toString(func2.apply(4)));//[null, null, null, null]
    11.     }

  • 相关阅读:
    Qt——多线程
    基于STM32CUBEMX驱动TOF模块VL53l0x(2)----修改设备地址
    ISO质量认证范围和审核范围的简要解说
    分享一个自用的Win11护眼主题（无需下载）
    Mac 错误zsh: command not found: brew解决方法
    Python实现飞翔的小鸟
    Swift宏
    房屋租赁管理系统
    12.3 实现模拟鼠标录制回放
    Flutter状态管理-FlyingRedux
  • 原文地址：https://blog.csdn.net/m0_65152767/article/details/132659314