java8函数式编程实例

什么是函数式编程

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

Stream

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

 

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

解析相关接口

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

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

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

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

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

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

 

序号接口 & 描述
1 BiConsumer<T,U>

代表了一个接受两个输入参数的操作，并且不返回任何结果
2 BiFunction<T,U,R>

代表了一个接受两个输入参数的方法，并且返回一个结果
3 BinaryOperator<T>

代表了一个作用于于两个同类型操作符的操作，并且返回了操作符同类型的结果
4 BiPredicate<T,U>

代表了一个两个参数的boolean值方法
5 BooleanSupplier

代表了boolean值结果的提供方
6 Consumer<T>

代表了接受一个输入参数并且无返回的操作
7 DoubleBinaryOperator

代表了作用于两个double值操作符的操作，并且返回了一个double值的结果。
8 DoubleConsumer

代表一个接受double值参数的操作，并且不返回结果。
9 DoubleFunction<R>

代表接受一个double值参数的方法，并且返回结果
10 DoublePredicate

代表一个拥有double值参数的boolean值方法
11 DoubleSupplier

代表一个double值结构的提供方
12 DoubleToIntFunction

接受一个double类型输入，返回一个int类型结果。
13 DoubleToLongFunction

接受一个double类型输入，返回一个long类型结果
14 DoubleUnaryOperator

接受一个参数同为类型double,返回值类型也为double 。
15 Function<T,R>

接受一个输入参数，返回一个结果。
16 IntBinaryOperator

接受两个参数同为类型int,返回值类型也为int 。
17 IntConsumer

接受一个int类型的输入参数，无返回值 。
18 IntFunction<R>

接受一个int类型输入参数，返回一个结果 。
19 IntPredicate

：接受一个int输入参数，返回一个布尔值的结果。
20 IntSupplier

无参数，返回一个int类型结果。
21 IntToDoubleFunction

接受一个int类型输入，返回一个double类型结果 。
22 IntToLongFunction

接受一个int类型输入，返回一个long类型结果。
23 IntUnaryOperator

接受一个参数同为类型int,返回值类型也为int 。
24 LongBinaryOperator

接受两个参数同为类型long,返回值类型也为long。
25 LongConsumer

接受一个long类型的输入参数，无返回值。
26 LongFunction<R>

接受一个long类型输入参数，返回一个结果。
27 LongPredicate

R接受一个long输入参数，返回一个布尔值类型结果。
28 LongSupplier

无参数，返回一个结果long类型的值。
29 LongToDoubleFunction

接受一个long类型输入，返回一个double类型结果。
30 LongToIntFunction

接受一个long类型输入，返回一个int类型结果。
31 LongUnaryOperator

接受一个参数同为类型long,返回值类型也为long。
32 ObjDoubleConsumer<T>

接受一个object类型和一个double类型的输入参数，无返回值。
33 ObjIntConsumer<T>

接受一个object类型和一个int类型的输入参数，无返回值。
34 ObjLongConsumer<T>

接受一个object类型和一个long类型的输入参数，无返回值。
35 Predicate<T>

接受一个输入参数，返回一个布尔值结果。
36 Supplier<T>

无参数，返回一个结果。
37 ToDoubleBiFunction<T,U>

接受两个输入参数，返回一个double类型结果
38 ToDoubleFunction<T>

接受一个输入参数，返回一个double类型结果
39 ToIntBiFunction<T,U>

接受两个输入参数，返回一个int类型结果。
40 ToIntFunction<T>

接受一个输入参数，返回一个int类型结果。
41 ToLongBiFunction<T,U>

接受两个输入参数，返回一个long类型结果。
42 ToLongFunction<T>

接受一个输入参数，返回一个long类型结果。
43 UnaryOperator<T>

接受一个参数为类型T,返回值类型也为T。

 

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

 

总结

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

 

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

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

T1toT2是从接受T1类型参数，返回T2类型结果，比如IntToLongFunction 接受一个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. }

 

这个是结果

 

实战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.  
posted @ 2019-06-12 21:04  技术研究与问题解决  阅读(203)  评论(0)    收藏  举报