Java8新特性-方法引用

方法引用的使用场景

　　我们用Lambda表达式来实现匿名方法。但有些情况下，我们用Lambda表达式仅仅是调用一些已经存在的方法，除了调用动作外，没有其他任何多余的动作，在这种情况下，我们倾向于通过方法名来调用它，而Lambda表达式可以帮助我们实现这一要求，它使得Lambda在调用那些已经拥有方法名的方法的代码更简洁、更容易理解。方法引用可以理解为Lambda表达式的另外一种表现形式。

方法引用的分类

类型 语法 对应的Lambda表达式
对象：实例方法引用 inst::instMethod (args) -> inst.instMethod(args)
类名：实例方法引用 类名::instMethod (inst,args) -> 类名.instMethod(args)
类名：静态方法引用 类名::staticMethod (args) -> 类名.staticMethod(args)
类名：构建方法引用 类名::new (args) -> new 类名(args)

1.对象：实例方法引用

实例方法引用，顾名思义就是调用已经存在的实例的方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// 获取对象属性的值:有返回值
@Test
public void test2(){
    // lombda表达式方式
    Employee emp = new Employee(101, "张三", 18, 9999.99);
    Supplier<String> sup = () -> emp.getName();
    System.out.println(sup.get());

    System.out.println("----------------------------------");

    // 方法表达式
    Supplier<String> sup2 = emp::getName;
    System.out.println(sup2.get());
}
// 输出字符串：无返回值
@Test
public void test1(){
    // lombda表达式方式
    PrintStream ps = System.out;
    Consumer<String> con = (str) -> ps.println(str);
    con.accept("Hello World！");

    System.out.println("--------------------------------");

    // 方法表达式
    Consumer<String> con2 = ps::println;
    con2.accept("Hello Java8！");
    Consumer<String> con3 = System.out::println;
}

2.类：实例方法引用

这种方式需要注意的是，若Lambda 的参数列表的第一个参数，是实例方法的调用者，第二个参数(或无参)是实例方法的参数时，则可以使用格式： ClassName::MethodName

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
//类名 :: 实例方法名
@Test
public void test2(){
    // x是exquals实例方法的调用者，y是实例方法的参数
    BiPredicate<String, String> bp = (x, y) -> x.equals(y);
    System.out.println(bp.test("abcde", "abcde"));

    System.out.println("-----------------------------------------");

    BiPredicate<String, String> bp2 = String::equals;
    System.out.println(bp2.test("abc", "abc"));

    System.out.println("-----------------------------------------");

    // e是show实例方法的调用者，y是实例方法的参数
    Function<Employee, String> fun = (e) -> e.show();
    System.out.println(fun.apply(new Employee()));

    System.out.println("-----------------------------------------");

    Function<Employee, String> fun2 = Employee::show;
    System.out.println(fun2.apply(new Employee()));

}

public class Employee {
    public Employee() {
	}
    public String show() {
		return "测试方法引用！";
	}
}

3.类：静态方法引用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@Test
public void test3(){
    Comparator<Integer> com = (x, y) -> Integer.compare(x, y);

    System.out.println("-------------------------------------");

    Comparator<Integer> com2 = Integer::compare;
}

@Test
public void test4(){
    BiFunction<Double, Double, Double> fun = (x, y) -> Math.max(x, y);
    System.out.println(fun.apply(1.5, 22.2));

    System.out.println("--------------------------------------------------");

    BiFunction<Double, Double, Double> fun2 = Math::max;
    System.out.println(fun2.apply(1.2, 1.5));
}

4.类名：构建方法引用

构造器的参数列表，需要与函数式接口中参数列表保持一致

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
@Test
public void test6(){
    Supplier<Employee> sup = () -> new Employee();
    System.out.println(sup.get());

    System.out.println("------------------------------------");

    Supplier<Employee> sup2 = Employee::new;
    System.out.println(sup2.get());
}

@Test
public void test7(){
    Function<String, Employee> fun = Employee::new;

    BiFunction<String, Integer, Employee> fun2 = Employee::new;
}
// 同样也适用于数组
@Test
public void test8(){
    Function<Integer, String[]> fun = (args) -> new String[args];
    String[] strs = fun.apply(10);
    System.out.println(strs.length);

    System.out.println("--------------------------");

    Function<Integer, Employee[]> fun2 = Employee[] :: new;
    Employee[] emps = fun2.apply(20);
    System.out.println(emps.length);
}