Java8新特性：函数式接口，方法与构造器引用

前言

★ 这里是小冷的博客
优质技术好文见专栏
个人公众号，分享一些技术上的文章，以及遇到的坑
当前系列：Java8 新特性 系列
源代码 git 仓库 代码Git 仓库地址

Java8 新特性

函数式接口（Functional）

通过上面的 Lambda表达式的学习，我们认识了 新的语法，支持这种语法的接口

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

Lambda的表达式本质其实就是函数式接口的实例

什么是函数式接口呢？

Runnable接口就是一个很典型的函数式接口

1. @FunctionalInterface
2. public interface Runnable {
3. public abstract void run();
4. }

复制代码

这里我们自己定一个

1. @FunctionalInterface
2. public interface MyinterFace {
3. void method1();
4. }

复制代码

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

函数式接口	参数类型	返回类型	用途
Consumer 消费型接口	T	void	对类型为t的对象应用操作，包含方法void accept（T，t）
Supperlier供给型接口	无	T	返回类型为T的对象，包含方法 T get()
Function	T	R	对类型为T的对象应用操作，并返回结果，结果是R类型的对象，包含方法 R apply（T t）
Predicate	T	boolean	确定类型为T的对象是否满足某个约束，并返回boolean值，包含方法 boolean test（T t）

理论+实践

我们以 Consumer 与 Predicate举例子

1. /**
2. * @author : <h2>冷环渊</h2>
3. * @date : 2021/12/11
4. * @context: <h4>
5. * 消费型接口 Consumer<T> Accept(T t)
6. * 供给型接口 Supplier<T> T get()
7. * 函数式接口 Function<T> R apply(T t)
8. * 断定型接口 Predicate<T> boolean test(T t)
9. * </h4>
10. */
11. public class LambdaTest2 {
14. /**
15. * @author 冷环渊 Doomwatcher
16. * @context: Consumer<T> 使用
17. * @date: 2021/12/11 14:37
18. * @param
19. * @return: void
20. */
21. @Test
22. public void Test1() {
23. happyTime(500, new Consumer<Double>() {
24. @Override
25. public void accept(Double aDouble) {
26. System.out.println("天上人间的水今天很贵：" + aDouble);
27. }
28. });
29. System.out.println("****************************");
30. happyTime(400, money -> System.out.println("学习太累了，去天上人间买了瓶矿泉水，价格为：" + money));
31. }
33. /**
34. * @author: 冷环渊 Doomwatcher
35. * @context:
36. * @date: 2021/12/11 14:33
37. * @param money
38. * @param con
39. * @return void
40. */
41. public void happyTime(double money, Consumer<Double> con) {
43. con.accept(money);
44. }
46. /**
47. * @author 冷环渊 Doomwatcher
48. * @context: 断言 Predicate 的使用
49. * @date: 2021/12/11 14:39
50. * @param
51. * @return: void
52. */
53. @Test
54. public void Test2() {
55. //传统写法
56. List<String> filterList = Arrays.asList("北京", "天津", "南京", "东京", "江南");
57. List<String> filterStr = filterString(filterList, new Predicate<String>() {
58. @Override
59. public boolean test(String s) {
60. return s.contains("京");
61. }
62. });
63. System.out.println(filterStr);
64. System.out.println("*******************************");
65. // Lambda表达式 写法
66. List<String> filterList1 = Arrays.asList("北京", "天津", "南京", "东京", "江南");
67. List<String> filterStr1 = filterString(filterList1, s -> s.contains("京"));
68. System.out.println(filterStr1);
69. }
71. /**
72. * @author 冷环渊 Doomwatcher
73. * @context:
74. * @date: 2021/12/11 14:49
75. * @param list
76. * @param pre
77. * @return: java.util.List<java.lang.String>
78. */
79. public List<String> filterString(List<String> list, Predicate<String> pre) {
80. ArrayList<String> filterlist = new ArrayList<>();
81. for (String s : list) {
82. if (pre.test(s)) {
83. filterlist.add(s);
84. }
85. }
86. return filterlist;
87. }
88. }

复制代码

方法引用与构造器引用

方法引用

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

coding

准备两个类 一个是list集合，一个是对象

Employee get/set 和 tostring 为防止无用篇幅过长，这里我们简写只看一下对象属性即可

1. package Lambda.MethodReferences;
3. /**
4. *
5. * @author : <h2>冷环渊</h2>
6. * @date : 2021/12/11
7. * @context:<h4>提供用于测试的对象</h4>
8. */
9. public class Employee {
11. private int id;
12. private String name;
13. private int age;
14. private double salary;
15. \
16. }

复制代码

EmployeeData

1. package Lambda.MethodReferences;
3. import java.util.ArrayList;
4. import java.util.List;
6. /**
7. *
8. * @author : <h2>冷环渊</h2>
9. * @date : 2021/12/11
10. * @context:<h4>提供用于测试的数据</h4>
11. */
12. public class EmployeeData {
14. public static List<Employee> getEmployees() {
15. List<Employee> list = new ArrayList<>();
17. list.add(new Employee(1001, "马化腾", 34, 6000.38));
18. list.add(new Employee(1002, "马云", 12, 9876.12));
19. list.add(new Employee(1003, "刘强东", 33, 3000.82));
20. list.add(new Employee(1004, "雷军", 26, 7657.37));
21. list.add(new Employee(1005, "李彦宏", 65, 5555.32));
22. list.add(new Employee(1006, "比尔盖茨", 42, 9500.43));
23. list.add(new Employee(1007, "任正非", 26, 4333.32));
24. list.add(new Employee(1008, "扎克伯格", 35, 2500.32));
26. return list;
27. }
29. }

复制代码

方法引用 test

1. /**
2. * @author : <h2>冷环渊</h2>
3. * @date : 2021/12/11
4. * @context:<h4>
5. * 方法引用的使用
6. *
7. * 1.使用情境：当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！
8. * 2.方法引用，本质上就是Lambda表达式，而Lambda表达式作为函数式接口的实例。所以
9. * 方法引用，也是函数式接口的实例。
10. * 3. 使用格式： 类(或对象) :: 方法名
11. * 4. 具体分为如下的三种情况：
12. * 情况1 对象 :: 非静态方法
13. * 情况2 类 :: 静态方法
14. * 情况3 类 :: 非静态方法
15. * 5. 方法引用使用的要求：要求接口中的抽象方法的形参列表和返回值类型与方法引用的方法的
16. * 形参列表和返回值类型相同！（针对于情况1和情况2）
17. *
18. * </h4>
19. *
20. */
21. public class MethodRefTest {
23. // 情况一：对象 :: 实例方法
24. //Consumer中的void accept(T t)
25. //PrintStream中的void println(T t)
26. @Test
27. public void test1() {
28. Consumer<String> con1 = str -> System.out.println(str);
29. con1.accept("北京");
31. System.out.println("*******************");
32. PrintStream ps = System.out;
33. Consumer<String> con2 = ps::println;
34. con2.accept("beijing");
35. }
37. //Supplier中的T get()
38. //Employee中的String getName()
39. @Test
40. public void test2() {
41. Employee emp = new Employee(1001, "Tom", 23, 5600);
43. Supplier<String> sup1 = () -> emp.getName();
44. System.out.println(sup1.get());
46. System.out.println("*******************");
47. Supplier<String> sup2 = emp::getName;
48. System.out.println(sup2.get());
50. }
52. // 情况二：类 :: 静态方法
53. //Comparator中的int compare(T t1,T t2)
54. //Integer中的int compare(T t1,T t2)
55. @Test
56. public void test3() {
57. Comparator<Integer> com1 = (t1, t2) -> Integer.compare(t1, t2);
58. System.out.println(com1.compare(12, 21));
60. System.out.println("*******************");
62. Comparator<Integer> com2 = Integer::compare;
63. System.out.println(com2.compare(12, 3));
65. }
67. //Function中的R apply(T t)
68. //Math中的Long round(Double d)
69. @Test
70. public void test4() {
71. Function<Double, Long> func = new Function<Double, Long>() {
72. @Override
73. public Long apply(Double d) {
74. return Math.round(d);
75. }
76. };
78. System.out.println("*******************");
80. Function<Double, Long> fuc1 = d -> Math.round(d);
81. System.out.println(func1.apply(12.3));
83. System.out.println("*******************");
85. Function<Double, Long> func2 = Math::round;
86. System.out.println(func2.apply(12.6));
87. }
89. // 情况三：类 :: 实例方法 (有难度)
90. // Comparator中的int comapre(T t1,T t2)
91. // String中的int t1.compareTo(t2)
92. @Test
93. public void test5() {
94. Comparator<String> com1 = (s1, s2) -> s1.compareTo(s2);
95. System.out.println(com1.compare("abc", "abd"));
97. System.out.println("*******************");
99. Comparator<String> com2 = String::compareTo;
100. System.out.println(com2.compare("abd", "abm"));
101. }
103. //BiPredicate中的boolean test(T t1, T t2);
104. //String中的boolean t1.equals(t2)
105. @Test
106. public void test6() {
107. BiPredicate<String, String> pre1 = (s1, s2) -> s1.equals(s2);
108. System.out.println(pre1.test("abc", "abc"));
110. System.out.println("*******************");
111. BiPredicate<String, String> pre2 = String::equals;
112. System.out.println(pre2.test("abc", "abd"));
113. }
115. // Function中的R apply(T t)
116. // Employee中的String getName();
117. @Test
118. public void test7() {
119. Employee employee = new Employee(1001, "Jerry", 23, 6000);
122. Function<Employee, String> func1 = e -> e.getName();
123. System.out.println(func1.apply(employee));
125. System.out.println("*******************");
128. Function<Employee, String> func2 = Employee::getName;
129. System.out.println(func2.apply(employee));
130. }
132. }

复制代码

构造方法引用

通过 简化 的方式，来调用不同的构造器

一、构造器引用

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

二、数组引用

• 大家可以把数组看做是一个特殊的类，则写法与构造器引用一致。

1. /**
2. *
3. * @author : <h2>冷环渊</h2>
4. * @date : 2021/12/11
5. * @context:<h4>
6. *
7. * 一、构造器引用
8. * 和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致。
9. * 抽象方法的返回值类型即为构造器所属的类的类型
10. *
11. * 二、数组引用
12. * 大家可以把数组看做是一个特殊的类，则写法与构造器引用一致。
13. * </h4>
14. */
15. public class ConstructorRefTest {
16. //构造器引用
17. //Supplier中的T get()
18. //Employee的空参构造器：Employee()
19. @Test
20. public void test1() {
22. Supplier<Employee> sup = new Supplier<Employee>() {
23. @Override
24. public Employee get() {
25. return new Employee();
26. }
27. };
28. System.out.println("*******************");
30. Supplier<Employee> sup1 = () -> new Employee();
31. System.out.println(sup1.get());
33. System.out.println("*******************");
35. Supplier<Employee> sup2 = Employee::new;
36. System.out.println(sup2.get());
37. }
39. //Function中的R apply(T t)
40. @Test
41. public void test2() {
42. Function<Integer, Employee> func1 = id -> new Employee(id);
43. Employee employee = func1.apply(1001);
44. System.out.println(employee);
46. System.out.println("*******************");
48. Function<Integer, Employee> func2 = Employee::new;
49. Employee employee1 = func2.apply(1002);
50. System.out.println(employee1);
52. }
54. //BiFunction中的R apply(T t,U u)
55. @Test
56. public void test3() {
57. BiFunction<Integer, String, Employee> func1 = (id, name) -> new Employee(id, name);
58. System.out.println(func1.apply(1001, "Tom"));
60. System.out.println("*******************");
62. BiFunction<Integer, String, Employee> func2 = Employee::new;
63. System.out.println(func2.apply(1002, "Tom"));
65. }
67. //数组引用
68. //Function中的R apply(T t)
69. @Test
70. public void test4() {
71. Function<Integer, String[]> func1 = length -> new String[length];
72. String[] arr1 = func1.apply(5);
73. System.out.println(Arrays.toString(arr1));
75. System.out.println("*******************");
77. Function<Integer, String[]> func2 = String[]::new;
78. String[] arr2 = func2.apply(10);
79. System.out.println(Arrays.toString(arr2));
81. }
82. }

复制代码

总结

• 全新的语法带来了很多的便捷，理解起来可能相对麻烦
• 这里在改变语法为Lambda的时候，可以自己找找可以省去，那一些部分
• 思考，为什么构造器引用可以根据数量和类型去找到对应的构造器

来源：https://blog.csdn.net/doomwatcher/article/details/121877131
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！