reduce()简介

  • Reduce 原意：减少，缩小
  • 根据指定的计算模型将Stream中的值计算得到一个最终结果
    解释：reduce 操作可以实现从Stream中生成一个值，其生成的值不是随意的，而是根据指定的计算模型。比如，之前提到count、min和max方法，因为常用而被纳入标准库中。事实上，这些方法都是reduce操作。

    reduce三个override的方法

reduce方法有三个override的方法：

Optional reduce(BinaryOperator accumulator);

T reduce(T identity, BinaryOperator accumulator);

U reduce(U identity,BiFunction accumulator,BinaryOperator combiner);

公共集合

测试代码中的所有集合，都是该集合。

  1.     List<Person> javaProgrammers = new ArrayList<Person>() {
  2.         {
  3.             add(new Person("Elsdon", "Jaycob", "Java programmer", "male", 2000, 18));
  4.             add(new Person("Tamsen", "Brittany", "Java programmer", "female", 2371, 55));
  5.             add(new Person("Floyd", "Donny", "Java programmer", "male", 3322, 25));
  6.             add(new Person("Sindy", "Jonie", "Java programmer", "female", 35020, 15));
  7.             add(new Person("Vere", "Hervey", "Java programmer", "male", 2272, 25));
  8.             add(new Person("Maude", "Jaimie", "Java programmer", "female", 2057, 87));
  9.             add(new Person("Shawn", "Randall", "Java programmer", "male", 3120, 99));
  10.             add(new Person("Jayden", "Corrina", "Java programmer", "female", 345, 25));
  11.             add(new Person("Palmer", "Dene", "Java programmer", "male", 3375, 14));
  12.             add(new Person("Addison", "Pam", "Java programmer", "female", 3426, 20));
  13.         }
  14.     };

方式一reduce(BinaryOperator accumulator)

  • Optional<T> reduce(BinaryOperator<T> accumulator);
    我们先看第一个变形，参数列表为一个函数接口BinaryOperator<T>,
    BinaryOperator源码：
  1. public interface BinaryOperator<T> extends BiFunction<T,T,T> {
  2.       public static <T> BinaryOperator<T> minBy(Comparator<? super T> comparator) {
  3.         Objects.requireNonNull(comparator);
  4.         return (a, b) -> comparator.compare(a, b) <= 0 ? a : b;
  5.     }
  6.     public static <T> BinaryOperator<T> maxBy(Comparator<? super T> comparator) {
  7.         Objects.requireNonNull(comparator);
  8.         return (a, b) -> comparator.compare(a, b) >= 0 ? a : b;
  9.     }
  10. }

看BinaryOperator接口源码，我们可以看到，它又继承了BiFunction<T,T,T>.
另外，在BinaryOperator接口中又定义了另个静态方法为minBy和maxBy,
上面我们提到BinaryOperator接口继承了BiFunction<T,T,T>，我们看一下BiFunction<T,T,T>源码：

  1. @FunctionalInterface
  2. public interface BiFunction<T, U, R> {
  3.     R apply(T t, U u);//接收两个参数 t 和 u, 返回 R
  4. }

Bifunction中有一个apply方法，接收两个参数，返回一个结果
小结： 不管是BinaryOperator类还是最终继承的BiFunction类，在类上都有@FunctionalInterface注解，因此reduce(BinaryOperator<T> accumulator)方法需要一个函数式接口参数，该函数式接口需要两个参数，返回一个结果(reduce中返回的结果会作为下次累加器计算的第一个参数)，也就是累加器,最终得到一个Optional对象

测试示例代码：

  1.     @Test
  2.     public void Test() {
  3.         int asInt = javaProgrammers.stream()
  4.                                     .mapToInt(Person::getSalary)//返回数值流，减少拆箱封箱操作，避免占用内存  IntStream
  5.                                     .reduce((x, y) -> x += y)// int
  6.                                     .getAsInt(); //return int
  7.         System.out.printf("方式一   reduce(BinaryOperator<T> accumulator)   求薪资测试结果："+asInt);
  9.         /*解析：
  10.              1. reduce(BinaryOperator<T> accumulator)    reduce方法接受一个函数，这个函数有两个参数
  11.              2. 第一个参数是上次函数执行的返回值（也称为中间结果），第二个参数是stream中的元素，这个函数把这两个值相加，得到的和会被赋值给下次执行这个函数的第一个参数
  12.          *注意：
  13.              1.第一次执行的时候第一个参数的值是Stream的第一个元素，第二个参数是Stream的第二个元素
  14.              2.方法返回值类型是Optional
  15.          */
  16.     }

方式二reduce(T identity, BinaryOperator accumulator)

  • T reduce(T identity, BinaryOperator<T> accumulator);
    与第一种变形相同的是都会接受一个BinaryOperator函数接口，不同的是其会接受一个identity参数，identity参数与Stream中数据同类型，相当于一个的初始值，通过累加器accumulator迭代计算Stream中的数据，得到一个跟Stream中数据相同类型的最终结果。
    测试示例代码：
  1.     @Test
  2.     public void test1(){
  3.         int reduce = javaProgrammers.stream().mapToInt(Person::getSalary).reduce(10000, (x, y) -> x += y);
  4.         System.out.printf("方式二  reduce(T identity, BinaryOperator<T> accumulator)   求薪资测试结果："+reduce);
  6.         /*注意：
  7.          *      1.与方式一相比设置了累加器的初始值，参数一（x）则不再是Stream中的第一个数据而是设置的初始值（10000）其他相同
  8.          */
  9.     }

打印结果：

  1. 方式一   reduce(BinaryOperator<T> accumulator)   求薪资测试结果：57308
  2. 方式二  reduce(T identity, BinaryOperator<T> accumulator) 求薪资测试结果：67308 //初始值10000

方式三 reduce(U identity,BiFunction accumulator,BinaryOperator combiner)

  • <U> U reduce(U identity,BiFunction<U, ? super T, U> accumulator,BinaryOperator<U> combiner);
    我们先观察分析再次被改变的参数列表：

Reduce方法 - 图1 1. 第一个参数：返回实例u，传递你要返回的U类型对象的初始化实例u
Reduce方法 - 图2 2. 第二个参数：累加器accumulator，可以使用lambda表达式，声明你在u上累加你的数据来源t的逻辑，例如(u,t)->u.sum(t),此时lambda表达式的行参列表是返回实例u和遍历的集合元素t，函数体是在u上累加t
Reduce方法 - 图3 3. 第三个参数：参数组合器combiner，接受lambda表达式。

根据参数我们一步一步分析代码示例：

  1.     @Test
  2.     public void test2() {
  3.         ArrayList<Integer> accResult_ = Stream.of(1, 2, 3, 4)
  4.                 //第一个参数，初始值为ArrayList
  5.                 .reduce(new ArrayList<Integer>(),
  6.                         //第二个参数，实现了BiFunction函数式接口中apply方法，并且打印BiFunction
  7.                         new BiFunction<ArrayList<Integer>, Integer, ArrayList<Integer>>() {
  8.                             @Override
  9.                             public ArrayList<Integer> apply(ArrayList<Integer> acc, Integer item) {
  11.                                 acc.add(item);
  12.                                 System.out.println("item: " + item);
  13.                                 System.out.println("acc+ : " + acc);
  14.                                 System.out.println("BiFunction");
  15.                                 return acc;
  16.                             }
  17.                             //第三个参数---参数的数据类型必须为返回数据类型，改参数主要用于合并多个线程的result值
  18.                             // （Stream是支持并发操作的，为了避免竞争，对于reduce线程都会有独立的result）
  19.                         }, new BinaryOperator<ArrayList<Integer>>() {
  20.                             @Override
  21.                             public ArrayList<Integer> apply(ArrayList<Integer> acc, ArrayList<Integer> item) {
  22.                                 System.out.println("BinaryOperator");
  23.                                 acc.addAll(item);
  24.                                 System.out.println("item: " + item);
  25.                                 System.out.println("acc+ : " + acc);
  26.                                 System.out.println("--------");
  27.                                 return acc;
  28.                             }
  29.                         });
  30.         System.out.println("accResult_: " + accResult_);
  32.         System.out.println("------------------lambda优化代码-----------------");
  34.         ArrayList<Integer> newList = new ArrayList<>();
  36.         ArrayList<Integer> accResult_s = Stream.of(1,2,3,4)
  37.                 .reduce(newList,
  38.                         (acc, item) -> {
  39.                             acc.add(item);
  40.                             System.out.println("item: " + item);
  41.                             System.out.println("acc+ : " + acc);
  42.                             System.out.println("BiFunction");
  43.                             return acc;
  44.                         }, (acc, item) -> null);
  45.         System.out.println("accResult_s: " + accResult_s);
  47.         /**
  48.          *注意：
  49.          *  1. 方式三:第三个参数用来处理并发操作，如何处理数据的重复性，应多做考虑，否则会出现重复数据！
  50.          *
  51.          */
  53.     }

Reduce方法 - 图4示例代码中，第一个参数是ArrayList,在第二个函数参数中打印了“BiFunction”，而在第三个参数接口中打印了函数接口中打印了”BinaryOperator“.看下面的打印结果，只打印了“BiFunction”，而没有打印”BinaryOperator“，也就是说第三个函数参数并没有执行。分析参数时我们知道了该变形可以返回任意类型的数据。
Reduce方法 - 图5对于第三个函数参数，为什么没有执行，而且其参数必须为返回的数据类型？这是因为Stream是支持并发操作的，为了避免竞争，对于reduce线程都会有独立的result，combiner的作用在于合并每个线程的result得到最终结果。这也说明了了第三个函数参数的数据类型必须为返回数据类型了。 java8 reduce方法中的第三个参数combiner有什么作用？
打印结果：

  1. item: 1
  2. acc+ : [1]
  3. BiFunction
  4. item: 2
  5. acc+ : [1, 2]
  6. BiFunction
  7. item: 3
  8. acc+ : [1, 2, 3]
  9. BiFunction
  10. item: 4
  11. acc+ : [1, 2, 3, 4]
  12. BiFunction

另外需要注意：因为第三个参数用来处理并发操作，如何处理数据的重复性，应多做考虑，否则会出现重复数据！

结束语

路漫漫其修远行，吾将上下而求索