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

1、方法引用的使用情况1

  1. public class Employee {
  3.     private int id;
  4.     private String name;
  5.     private int age;
  6.     private double salary;
  8.     public int getId() {
  9.         return id;
  10.     }
  12.     public void setId(int id) {
  13.         this.id = id;
  14.     }
  16.     public String getName() {
  17.         return name;
  18.     }
  20.     public void setName(String name) {
  21.         this.name = name;
  22.     }
  24.     public int getAge() {
  25.         return age;
  26.     }
  28.     public void setAge(int age) {
  29.         this.age = age;
  30.     }
  32.     public double getSalary() {
  33.         return salary;
  34.     }
  36.     public void setSalary(double salary) {
  37.         this.salary = salary;
  38.     }
  40.     public Employee() {
  41.         System.out.println("Employee().....");
  42.     }
  44.     public Employee(int id) {
  45.         this.id = id;
  46.         System.out.println("Employee(int id).....");
  47.     }
  49.     public Employee(int id, String name) {
  50.         this.id = id;
  51.         this.name = name;
  52.     }
  54.     public Employee(int id, String name, int age, double salary) {
  56.         this.id = id;
  57.         this.name = name;
  58.         this.age = age;
  59.         this.salary = salary;
  60.     }
  62.     @Override
  63.     public String toString() {
  64.         return "Employee{" + "id=" + id + ", name='" + name + '\'' + ", age=" + age + ", salary=" + salary + '}';
  65.     }
  67.     @Override
  68.     public boolean equals(Object o) {
  69.         if (this == o)
  70.             return true;
  71.         if (o == null || getClass() != o.getClass())
  72.             return false;
  74.         Employee employee = (Employee) o;
  76.         if (id != employee.id)
  77.             return false;
  78.         if (age != employee.age)
  79.             return false;
  80.         if (Double.compare(employee.salary, salary) != 0)
  81.             return false;
  82.         return name != null ? name.equals(employee.name) : employee.name == null;
  83.     }
  85.     @Override
  86.     public int hashCode() {
  87.         int result;
  88.         long temp;
  89.         result = id;
  90.         result = 31 * result + (name != null ? name.hashCode() : 0);
  91.         result = 31 * result + age;
  92.         temp = Double.doubleToLongBits(salary);
  93.         result = 31 * result + (int) (temp ^ (temp >>> 32));
  94.         return result;
  95.     }
  96. }
  1. import org.junit.Test;
  3. import java.io.PrintStream;
  4. import java.util.Comparator;
  5. import java.util.function.BiPredicate;
  6. import java.util.function.Consumer;
  7. import java.util.function.Function;
  8. import java.util.function.Supplier;
  10. /**
  11.  * 方法引用的使用
  12.  *
  13.  * 1.使用情境：当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！
  14.  *
  15.  * 2.方法引用，本质上就是Lambda表达式，而Lambda表达式作为函数式接口的实例。所以
  16.  *   方法引用，也是函数式接口的实例。
  17.  *
  18.  * 3. 使用格式：  类(或对象) :: 方法名
  19.  *
  20.  * 4. 具体分为如下的三种情况：
  21.  *    情况1     对象 :: 非静态方法
  22.  *    情况2     类 :: 静态方法
  23.  *
  24.  *    情况3     类 :: 非静态方法
  25.  *
  26.  * 5. 方法引用使用的要求：要求接口中的抽象方法的形参列表和返回值类型与方法引用的方法的
  27.  *    形参列表和返回值类型相同！（针对于情况1和情况2）
  28.  */
  29. public class MethodRefTest {
  31.     // 情况一：对象 :: 实例方法
  32.     //Consumer中的void accept(T t)
  33.     //PrintStream中的void println(T t)
  34.     @Test
  35.     public void test() {
  36.         Consumer<String> c1 = str -> System.out.println(str);
  37.         c1.accept("兖州");
  39.         System.out.println("+++++++++++++");
  40.         PrintStream ps = System.out;
  41.         Consumer<String> c2 = ps::println;
  42.         c2.accept("xian");
  43.     }
  45.     //Supplier中的T get()
  46.     //Employee中的String getName()
  47.     @Test
  48.     public void test2() {
  49.         Employee emp = new Employee(004,"Nice",19,4200);
  51.         Supplier<String> sk1 = () -> emp.getName();
  52.         System.out.println(sk1.get());
  54.         System.out.println("*******************");
  55.         Supplier<String> sk2 = emp::getName;
  56.         System.out.println(sk2.get());
  57.     }
  58. }

2、方法引用的使用情况2

  1. import org.junit.Test;
  2. import java.util.Comparator;
  3. import java.util.function.Function;
  5. public class MethodRefTest {
  7.     // 情况二：类 :: 静态方法
  8.     //Comparator中的int compare(T t1,T t2)
  9.     //Integer中的int compare(T t1,T t2)
  10.     @Test
  11.     public void test3() {
  12.         Comparator<Integer> com1 = (t1, t2) -> Integer.compare(t1,t2);
  13.         System.out.println(com1.compare(21,20));
  15.         System.out.println("+++++++++++++++");
  17.         Comparator<Integer> com2 = Integer::compare;
  18.         System.out.println(com2.compare(15,7));
  19.     }
  21.     //Function中的R apply(T t)
  22.     //Math中的Long round(Double d)
  23.     @Test
  24.     public void test4() {
  25.         Function<Double,Long> func = new Function<Double, Long>() {
  26.             @Override
  27.             public Long apply(Double d) {
  28.                 return Math.round(d);
  29.             }
  30.         };
  32.         System.out.println("++++++++++++++++++");
  34.         Function<Double,Long> func1 = d -> Math.round(d);
  35.         System.out.println(func1.apply(14.1));
  37.         System.out.println("++++++++++++++++++");
  39.         Function<Double,Long> func2 = Math::round;
  40.         System.out.println(func2.apply(17.4));
  41.     }
  42. }

3、方法引用的使用情况3

  1. import org.junit.Test;
  3. import java.util.Comparator;
  4. import java.util.function.BiPredicate;
  5. import java.util.function.Function;
  7. public class MethodRefTest {
  9.     // 情况三：类 :: 实例方法  (有难度)
  10.     // Comparator中的int comapre(T t1,T t2)
  11.     // String中的int t1.compareTo(t2)
  12.     @Test
  13.     public void test5() {
  14.         Comparator<String> com1 = (s1,s2) -> s1.compareTo(s2);
  15.         System.out.println(com1.compare("abc","abd"));
  17.         System.out.println("++++++++++++++++");
  19.         Comparator<String> com2 = String :: compareTo;
  20.         System.out.println(com2.compare("abd","abm"));
  21.     }
  23.     //BiPredicate中的boolean test(T t1, T t2);
  24.     //String中的boolean t1.equals(t2)
  25.     @Test
  26.     public void test6() {
  27.         BiPredicate<String,String> pre1 = (s1, s2) -> s1.equals(s2);
  28.         System.out.println(pre1.test("MON","MON"));
  30.         System.out.println("++++++++++++++++++++");
  32.         BiPredicate<String,String> pre2 = String :: equals;
  33.         System.out.println(pre2.test("MON","MON"));
  34.     }
  36.     // Function中的R apply(T t)
  37.     // Employee中的String getName();
  38.     @Test
  39.     public void test7() {
  40.         Employee employee = new Employee(007, "Ton", 21, 8000);
  42.         Function<Employee,String> func1 = e -> e.getName();
  43.         System.out.println(func1.apply(employee));
  45.         System.out.println("++++++++++++++++++++++++");
  47.         Function<Employee,String> f2 = Employee::getName;
  48.         System.out.println(f2.apply(employee));
  49.     }
  50. }

4、构造器引用与数组引用的使用

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

  1. import org.junit.Test;
  3. import java.util.Arrays;
  4. import java.util.function.BiFunction;
  5. import java.util.function.Function;
  6. import java.util.function.Supplier;
  8. /**
  9.  * 一、构造器引用
  10.  *      和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致。
  11.  *      抽象方法的返回值类型即为构造器所属的类的类型
  12.  *
  13.  * 二、数组引用
  14.  *     可以把数组看做是一个特殊的类，则写法与构造器引用一致。 
  15.  */
  16. public class MethodRefTest {
  18.     //构造器引用
  19.     //Supplier中的T get()
  20.     //Employee的空参构造器：Employee()
  21.     @Test
  22.     public void test() {
  23.         Supplier<Employee> sup = new Supplier<Employee>() {
  24.             @Override
  25.             public Employee get() {
  26.                 return new Employee();
  27.             }
  28.         };
  29.         System.out.println("+++++++++++++++++++");
  31.         Supplier<Employee> sk1 = () -> new Employee();
  32.         System.out.println(sk1.get());
  34.         System.out.println("+++++++++++++++++++");
  36.         Supplier<Employee> sk2 = Employee::new;
  37.         System.out.println(sk2.get());
  38.     }
  40.     //Function中的R apply(T t)
  41.     @Test
  42.     public void test2() {
  43.         Function<Integer, Employee> f1 = id -> new Employee(id);
  44.         Employee employee = f1.apply(7793);
  45.         System.out.println(employee);
  47.         System.out.println("+++++++++++++++++++");
  49.         Function<Integer, Employee> f2 = Employee::new;
  50.         Employee employee1 = f2.apply(4545);
  51.         System.out.println(employee1);
  52.     }
  54.     //BiFunction中的R apply(T t,U u)
  55.     @Test
  56.     public void test3() {
  57.         BiFunction<Integer, String, Employee> f1 = (id, name) -> new Employee(id, name);
  58.         System.out.println(f1.apply(2513, "Fruk"));
  60.         System.out.println("*******************");
  62.         BiFunction<Integer, String, Employee> f2 = Employee::new;
  63.         System.out.println(f2.apply(9526, "Bon"));
  64.     }
  66.     //数组引用
  67.     //Function中的R apply(T t)
  68.     @Test
  69.     public void test4() {
  70.         Function<Integer, String[]> f1 = length -> new String[length];
  71.         String[] arr1 = f1.apply(7);
  72.         System.out.println(Arrays.toString(arr1));
  74.         System.out.println("+++++++++++++++++++");
  76.         Function<Integer, String[]> f2 = String[]::new;
  77.         String[] arr2 = f2.apply(9);
  78.         System.out.println(Arrays.toString(arr2));
  79.     }
  80. }