Java8函数式接口, 方法引用, 构造器引用, 数组引用

函数式(Functional)接口

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

如何理解函数式接口

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

Java内置四大核心函数式接口以及使用

1. // Consumer
2. public void happyTime(double money, Consumer<Double> con){
3.     con.accept(money);
4. }
6. @Test
7. public void test1(){
8.     happyTime(200, money -> {
9.         System.out.println("happy: " + money);
10.     });
11. }

复制代码

1. // Predicate
2. public List<String> filterString(List<String> list, Predicate<String> pred){
3.     List<String> res = new ArrayList<>();
4.     for(String s : list) {
5.         if(pred.test(s)){
6.             res.add(s);
7.         }
8.     }
9.     return res;
10. }
12. @Test
13. public void test2(){
14.     List<String> list = Arrays.asList("北京","南京","西京","广东","东京");
15.     List<String> res = filterString(list, str -> !str.contains("京"));
16.     System.out.println(res);
17. }

复制代码

方法引用

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

• 对象 :: 实例方法名(非静态方法)
  
• 类 :: 静态方法名
  
• 类 :: 实例方法名(非静态方法)
  

对象调用静态方法实际上相当于类调用静态方法.
使用情景

当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！

1. // 对象 :: 实例方法
2. @Test
3. public void test1(){
4.     // Consumer中的void accept(T t)
5.     // PrintStream中的void println(T t)
6.     // 两种都是泛型T, 可以用
7.     Consumer<String> con1 = str -> System.out.println("str");
8.     Consumer<String> con2 = System.out::println;
9.     PrintStream out = System.out;
10.     Consumer<String> con3 = out::println;
11.     con3.accept("con3");
12. }
14. @Test
15. public void test2(){
16.     // Supplier中的T get()
17.     // Employee中的String getName()
18.     // 可以做类型推断
19.     Employee emp = new Employee(1001, "tom", 23, 5600);
20.     Supplier<String> sup1 = () -> emp.getName();
21.     Supplier<String> sup2 = emp::getName;
22.     System.out.println(sup2.get());
23. }

复制代码

1. // 类 :: 静态方法
2. @Test
3. public void test3(){
4.     // Comparator中的int compare(T t1, T t2)
5.     // Integer中的int compare(T t1, T t2)
6.     Comparator<Integer> com1 = (t1, t2) -> Integer.compare(t1, t2);
7.     Comparator<Integer> com2 = Integer::compare;
8.     System.out.println(com2.compare(3, 4));
9. }
11. @Test
12. public void test4(){
13.     // Function<T, R>
14.     // Function中的R apply(T t),
15.     // Math中的Long round(Double d)
16.     // 注意参数类型要对上
17.     Function<Double, Long> f = new Function<Double, Long>() {
18.         @Override
19.         public Long apply(Double aDouble) {
20.             return null;
21.         }
22.     };
23.     Function<Double, Long> f2 = Math::round;
24.     Function<Double, Long> f3 = d -> Math.round(d);
25.     System.out.println(f2.apply(4.0));
26. }

复制代码

1. // 类 :: 实例方法名(非静态方法)
2. // 注意调用者是谁, 比如t1.comparaTo(t2)
3. @Test
4. public void test5(){
5.     // Comparator中的 int compare(T t1, T t2)
6.     // String中的 int t1.compareTo(t2)
7.     Comparator<String> com1 = (s1, s2) -> s1.compareTo(s2);
8.     Comparator<String> com2 = String :: compareTo;
9.     System.out.println(com2.compare("a", "e"));
10. }
12. @Test
13. public void test6(){
14.     //BiPredicate中的boolean test(T t1, T t2);
15.     //String中的boolean t1.equals(t2)
16.     BiPredicate<String, String> bp1 = (t1, t2) -> t1.equals(t2);
17.     BiPredicate<String, String> bp2 = String :: equals;
18.     System.out.println(bp2.test("a", "a"));
19. }
21. @Test
22. public void test7(){
23.     // Function中的 R apply(T t)
24.     // Employee中的String getName()
25.     Function<Employee, String> f = Employee::getName;
26.     Employee emp = new Employee(1234,"tmo", 12, 2314.23);
27.     System.out.println(f.apply(emp));
28. }

复制代码

构造器引用

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

1. @Test
2. public void test1(){
3.     // Supplier的T get()
4.     // Employee的空参构造器, 返回Employee对象
5.     Supplier<Employee> sup1 = Employee :: new;
6.     System.out.println(sup1.get());
7. }
9. @Test
10. public void test2(){
11.     // Function中的 R apply(T t)
12.     Function<Integer, Employee> f = Employee :: new;
13.     System.out.println(f.apply(1234));
14. }
16. @Test
17. public void test3(){
18.     // BiFunction中的 R apply(T t, U u)
19.     BiFunction<Integer, String, Employee> bf = (id, name) -> new Employee(id, name);
20.     BiFunction<Integer, String, Employee> bf1 = Employee::new;
21.     System.out.println(bf1.apply(1234, "joey"));
22. }

复制代码

数组引用

把数组看成一种类的类型, 就跟构造器引用没有太大区别了.

1. @Test
2. public void test4(){
3.     Function<Integer, String[]> f = length -> new String[length];
4.     Function<Integer, String[]> f1 = String[] :: new;
5.     System.out.println(f1.apply(5).length);
6. }

复制代码

附录

1. public class Employee {
2.     private int id;
3.     private String name;
4.     private int age;
5.     private double salary;
6.     // ... getter, setter, toString, constructor
7. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！