java8函数式编程实例

迈不过友情╰ 2021-12-15 11:33 384阅读 0赞

### 什么是函数式编程 ###

函数式编程是java8的一大特色，也就是将函数作为一个参数传递给指定方法。别人传的要么是基本数据类型，要么就是地址引用 ，我们要穿一个“动作”。

### Stream ###

说到函数式编程，就不得不提及Stream，Stream跟我们熟知的io流可不是同一个东西，泛指可以顺序执行或者并行执行的元素序列，主要是针对集合，可以将多个函数通过“.”串起来执行，其特点如下：

*  stream不会存储数据，只是将集合流化，比如说 声明一个stream之后，往集合里面扔东西，stream可以取到新扔到集合里面的数据，你可以理解为操作时stream会实时从堆中的集合对象提取数据。
 *  stream不会改变原集合，我的理解是stream 是一堆元素顺序或者并行执行我们串起来的函数，改变后并不会对集合中的元素造成影响。
 *  steam是延迟执行的，也就是说在聚合操作之前 的其他操作，都会阻塞，直到执行聚合函数，其他的函数才开始一并执行。

### 解析相关接口 ###

我们看看跟函数式编程相关的接口

java.long.FunctionalInterface是一个注解接口，函数接口都会实现它，看看它有什么特别的

![70][]

从这里我们可以看出来一个函数接口只有一个抽象方法，但是如果要加一切其他的功能怎么办呢？接口中添加功能的话相当麻烦，接口相关实现类都需要修改，接下来“default”就登场了

![70 1][]

default方法只能在接口出现，它不是抽象方法，可以通过methodInstance.isDefault()辨认，咦，弄啥勒，接口还能有普通方法？是的你没看错，添加default方法是为了方便修改接口，不至于每次修改过后都要将他的“儿子，孙子”等实现一一修改；如果在接口中default修饰的方法不加body会怎么样呢？   没错， 会编译失败！贴图：

![70 2][]

接口中的default方法不用强制在实现类中 出现，当然业务需要的话，也可以重写来进行多态；

下面是java.util.function中的函数接口描述

## ##

<table> 
 <tbody> 
 <tr> 
 <th>序号</th> 
 <th>接口 &amp; 描述</th> 
 </tr> 
 <tr> 
 <td>1</td> 
 <td>BiConsumer&lt;T,U&gt; 代表了一个接受两个输入参数的操作，并且不返回任何结果 </td> 
 </tr> 
 <tr> 
 <td>2</td> 
 <td>BiFunction&lt;T,U,R&gt; 代表了一个接受两个输入参数的方法，并且返回一个结果 </td> 
 </tr> 
 <tr> 
 <td>3</td> 
 <td>BinaryOperator&lt;T&gt; 代表了一个作用于于两个同类型操作符的操作，并且返回了操作符同类型的结果 </td> 
 </tr> 
 <tr> 
 <td>4</td> 
 <td>BiPredicate&lt;T,U&gt; 代表了一个两个参数的boolean值方法 </td> 
 </tr> 
 <tr> 
 <td>5</td> 
 <td>BooleanSupplier 代表了boolean值结果的提供方 </td> 
 </tr> 
 <tr> 
 <td>6</td> 
 <td>Consumer&lt;T&gt; 代表了接受一个输入参数并且无返回的操作 </td> 
 </tr> 
 <tr> 
 <td>7</td> 
 <td>DoubleBinaryOperator 代表了作用于两个double值操作符的操作，并且返回了一个double值的结果。 </td> 
 </tr> 
 <tr> 
 <td>8</td> 
 <td>DoubleConsumer 代表一个接受double值参数的操作，并且不返回结果。 </td> 
 </tr> 
 <tr> 
 <td>9</td> 
 <td>DoubleFunction&lt;R&gt; 代表接受一个double值参数的方法，并且返回结果 </td> 
 </tr> 
 <tr> 
 <td>10</td> 
 <td>DoublePredicate 代表一个拥有double值参数的boolean值方法 </td> 
 </tr> 
 <tr> 
 <td>11</td> 
 <td>DoubleSupplier 代表一个double值结构的提供方 </td> 
 </tr> 
 <tr> 
 <td>12</td> 
 <td>DoubleToIntFunction 接受一个double类型输入，返回一个int类型结果。 </td> 
 </tr> 
 <tr> 
 <td>13</td> 
 <td>DoubleToLongFunction 接受一个double类型输入，返回一个long类型结果 </td> 
 </tr> 
 <tr> 
 <td>14</td> 
 <td>DoubleUnaryOperator 接受一个参数同为类型double,返回值类型也为double 。 </td> 
 </tr> 
 <tr> 
 <td>15</td> 
 <td>Function&lt;T,R&gt; 接受一个输入参数，返回一个结果。 </td> 
 </tr> 
 <tr> 
 <td>16</td> 
 <td>IntBinaryOperator 接受两个参数同为类型int,返回值类型也为int 。 </td> 
 </tr> 
 <tr> 
 <td>17</td> 
 <td>IntConsumer 接受一个int类型的输入参数，无返回值 。 </td> 
 </tr> 
 <tr> 
 <td>18</td> 
 <td>IntFunction&lt;R&gt; 接受一个int类型输入参数，返回一个结果 。 </td> 
 </tr> 
 <tr> 
 <td>19</td> 
 <td>IntPredicate ：接受一个int输入参数，返回一个布尔值的结果。 </td> 
 </tr> 
 <tr> 
 <td>20</td> 
 <td>IntSupplier 无参数，返回一个int类型结果。 </td> 
 </tr> 
 <tr> 
 <td>21</td> 
 <td>IntToDoubleFunction 接受一个int类型输入，返回一个double类型结果 。 </td> 
 </tr> 
 <tr> 
 <td>22</td> 
 <td>IntToLongFunction 接受一个int类型输入，返回一个long类型结果。 </td> 
 </tr> 
 <tr> 
 <td>23</td> 
 <td>IntUnaryOperator 接受一个参数同为类型int,返回值类型也为int 。 </td> 
 </tr> 
 <tr> 
 <td>24</td> 
 <td>LongBinaryOperator 接受两个参数同为类型long,返回值类型也为long。 </td> 
 </tr> 
 <tr> 
 <td>25</td> 
 <td>LongConsumer 接受一个long类型的输入参数，无返回值。 </td> 
 </tr> 
 <tr> 
 <td>26</td> 
 <td>LongFunction&lt;R&gt; 接受一个long类型输入参数，返回一个结果。 </td> 
 </tr> 
 <tr> 
 <td>27</td> 
 <td>LongPredicate R接受一个long输入参数，返回一个布尔值类型结果。 </td> 
 </tr> 
 <tr> 
 <td>28</td> 
 <td>LongSupplier 无参数，返回一个结果long类型的值。 </td> 
 </tr> 
 <tr> 
 <td>29</td> 
 <td>LongToDoubleFunction 接受一个long类型输入，返回一个double类型结果。 </td> 
 </tr> 
 <tr> 
 <td>30</td> 
 <td>LongToIntFunction 接受一个long类型输入，返回一个int类型结果。 </td> 
 </tr> 
 <tr> 
 <td>31</td> 
 <td>LongUnaryOperator 接受一个参数同为类型long,返回值类型也为long。 </td> 
 </tr> 
 <tr> 
 <td>32</td> 
 <td>ObjDoubleConsumer&lt;T&gt; 接受一个object类型和一个double类型的输入参数，无返回值。 </td> 
 </tr> 
 <tr> 
 <td>33</td> 
 <td>ObjIntConsumer&lt;T&gt; 接受一个object类型和一个int类型的输入参数，无返回值。 </td> 
 </tr> 
 <tr> 
 <td>34</td> 
 <td>ObjLongConsumer&lt;T&gt; 接受一个object类型和一个long类型的输入参数，无返回值。 </td> 
 </tr> 
 <tr> 
 <td>35</td> 
 <td>Predicate&lt;T&gt; 接受一个输入参数，返回一个布尔值结果。 </td> 
 </tr> 
 <tr> 
 <td>36</td> 
 <td>Supplier&lt;T&gt; 无参数，返回一个结果。 </td> 
 </tr> 
 <tr> 
 <td>37</td> 
 <td>ToDoubleBiFunction&lt;T,U&gt; 接受两个输入参数，返回一个double类型结果 </td> 
 </tr> 
 <tr> 
 <td>38</td> 
 <td>ToDoubleFunction&lt;T&gt; 接受一个输入参数，返回一个double类型结果 </td> 
 </tr> 
 <tr> 
 <td>39</td> 
 <td>ToIntBiFunction&lt;T,U&gt; 接受两个输入参数，返回一个int类型结果。 </td> 
 </tr> 
 <tr> 
 <td>40</td> 
 <td>ToIntFunction&lt;T&gt; 接受一个输入参数，返回一个int类型结果。 </td> 
 </tr> 
 <tr> 
 <td>41</td> 
 <td>ToLongBiFunction&lt;T,U&gt; 接受两个输入参数，返回一个long类型结果。 </td> 
 </tr> 
 <tr> 
 <td>42</td> 
 <td>ToLongFunction&lt;T&gt; 接受一个输入参数，返回一个long类型结果。 </td> 
 </tr> 
 <tr> 
 <td>43</td> 
 <td>UnaryOperator&lt;T&gt; 接受一个参数为类型T,返回值类型也为T。 </td> 
 </tr> 
 </tbody> 
</table>

## ##

除了上面列出的，还有个别函数接口没列出来，例如Comparator(), 但总归是个函数接口都会基于FunctionalInterface注解

### 总结 ###

这些函数主要还是分为几个主要函数，其余都是以其为基础的分化；

* **Supplier<T> **无参数，返回一个结果。
 * **Consumer<T> **代表了接受一个输入参数并且无返回的操作。
 * **Function<T,R> **接受一个输入参数，返回一个结果，返回的结果跟参数的类型无关。
 * **Predicate<T> **接受一个输入参数，返回一个布尔值结果。
 * **BinaryOperator<T> **代表了一个作用于于两个同类型操作符的操作，并且返回了操作符同类型的结果，xxxOperator 函数都是接受类型跟返回值类型相同。

而且，从上面五个主要函数接口命名也可以看出其作用，"Bi"作为前缀的都是属于二元操作，接受两个参数。

*T1***to***T2*是从接受T1类型参数，返回T2类型结果，比如**IntToLong**Function 接受一个int类型参数，返回long类型结果。

## ##

### 实战1 ###

下面我写了一个功能，拳击手有分组跟体重两个属性，然后给一组拳击手集合，根据小组或者体重级排序，用到的是Comparator()，也是一个函数接口

上码：

1. `/**`
2. `* Created by zhanghe`
3. `* 拳击手`
4. `*/`
5.  
6. `public class Boxer {`
7. `//分组`
8. `private String group;`
9. `//重量级`
10. `private Integer weight;`
11.  
12. `public Boxer(String group, Integer weight) {`
13. `this.group = group;`
14. `this.weight = weight;`
15. `}`
16.  
17. `public static <T> List<List<T>> divider(List<T> datas, Comparator<T> c) {`
18. `//声明一个列表来接收各个分组`
19. `List<List<T>> list = new ArrayList<>();`
20. `for (T t : datas) {`
21. `//通过isSameGroup 标识来判断分组是否已创建`
22. `boolean isSameGroup = false;`
23. `for (int i = 0; i < list.size(); i++) {`
24. `//compare函数返回值为int，正数说明param1>param2,0说明param1=param2,负数说明param1<param2`
25. `//这里用到的原理是将List列表datas中的各项与分组列表list中的元素比较（比较的规则由外面作为参数传递，这就是函数式编程），`
26. `// 值为0表示规则相符即为同一组`
27. `if (c.compare(t, list.get(i).get(0)) == 0) {`
28. `isSameGroup = true;`
29. `list.get(i).add(t);`
30. `break;`
31. `}`
32. `}`
33. `//比较完了发现没有规则相符的，即自成一系`
34. `if (!isSameGroup) {`
35. `List<T> e = new ArrayList<>();`
36. `e.add(t);`
37. `list.add(e);`
38. `}`
39. `}`
40. `return list;`
41. `}`
42.  
43. `public static void main(String[] args) {`
44. `List<Boxer> boxers = Arrays.asList(`
45. `new Boxer("红队", 120),`
46. `new Boxer("绿队", 180),`
47. `new Boxer("蓝队", 200),`
48. `new Boxer("绿队", 220),`
49. `new Boxer("蓝队", 120),`
50. `new Boxer("红队", 80),`
51. `new Boxer("红队", 90),`
52. `new Boxer("绿队", 240)`
53. `);`
54. `List<List<Boxer>> dividByGroup = divider(boxers, new Comparator<Boxer>() {`
55. `@Override`
56. `public int compare(Boxer o1, Boxer o2) {`
57. `//分组一样 即认为 相同`
58. `return o1.group.equals(o2.group) == true ? 0 : 1;`
59. `}`
60. `});`
61. `System.out.println("根据小组区分:");`
62. `dividByGroup.stream().forEach(e->{`
63. `System.out.println(e);`
64. `});`
65.  
66. `List<List<Boxer>> dividByWeight = divider(boxers, new Comparator<Boxer>() {`
67. `@Override`
68. `public int compare(Boxer o1, Boxer o2) {`
69. `//体重/100 即体重百分位相同 即认为 相同`
70. `return (o1.weight / 100 - o2.weight / 100) == 0 ? 0 : 1;`
71. `}`
72. `});`
73. `System.out.println("根据体重区分:");`
74. `dividByWeight.stream().forEach(e->{`
75. `System.out.println(e);`
76. `});`
77. `}`
78.  
79. `@Override`
80. `public String toString() {`
81. `return "Boxer{" +`
82. `"小组='" + group + '\'' +`
83. `", 体重=" + weight +`
84. `'}';`
85. `}`
86. `}`

这个是结果

![70 3][]

### 实战2 ###

我用Predicate 写了个具有匹配功能的方法，当然 匹配的规则还是作为一个函数参数传递，撸码不是很优雅，只看功能就好~

闲话不多说，上码：

1. `List<Object> list = Arrays.asList(1, 2,"",100,"3", 'c');`
2. `List<Object> matchList = match(list, a -> {`
3. `return a instanceof Integer && (Integer) a > 10;`
4. `});`
5. `System.out.println(matchList);//100`
6.  
7. `Set set = new HashSet<>();`
8. `set.add("haha");`
9. `set.add(1);`
10. `set.add(100);`
11.  
12. `Set matchSet = match(set, a -> a instanceof Integer);`
13. `System.out.println(matchSet);//[1, 100]`
14.  
15. `String matchString = match("java", a -> {`
16. `return a instanceof String && ((String) a).startsWith("j");`
17. `});`
18. `System.out.println(matchString);//java`
19. `Integer noMatch = match(100, a -> {`
20. `return a instanceof String && ((String) a).startsWith("j");`
21. `});`
22. `System.out.println(noMatch);//null`
23. `}`
24.  
25. `/**`
26. `*`
27. `* @param t 入参 需要匹配规则的参数`
28. `* @param p 函数接口 匹配的动作`
29. `* @param <T>`
30. `* @return 验证成功 是集合 则只留匹配元素，是String，Integer ..匹配成功返回本身，反之返回null`
31. `*/`
32. `public static <T> T match(T t, Predicate p) {`
33. `if (t instanceof Collection) {`
34. `if (t instanceof List) {`
35. `t = (T) ((List) t).stream().filter(a -> p.test(a)).collect(Collectors.toList());`
36. `}`
37. `if (t instanceof Set) {`
38. `t = (T) ((Set) t).stream().filter(a -> p.test(a)).collect(Collectors.toSet());`
39. `}`
40. `} else {`
41. `if (!p.test(t)) {`
42. `return null;`
43. `}`
44. `}`
45. `return t;`
46.

转载于:https://www.cnblogs.com/liuys635/p/11012723.html

[70]: /images/20211214/c777e7f02749463cba4f7209c1b83443.png
[70 1]: /images/20211214/f2793854df904f11b838df301bdc5012.png
[70 2]: /images/20211214/21e2e60ab1994d1e9a5dcd25025b9ed4.png
[70 3]: /images/20211214/52a8a9c8671348b393720ad82cb35d66.png