Java 1.8 新特性——Stream 流中 Reduce 操作

方式一

• Optional reduce(BinaryOperator accumulator);
• 对Stream中的数据通过累加器accumulator迭代计算，最终得到一个Optional对象

  函数式接口BinaryOperator，继承于BiFunction，Bifunction中有一个apply方法，接收两个参数，返回一个结果

  package cn_lemon;
  import java.util.function.BiFunction;
  @FunctionalInterface
  public interface BinaryOperator extends BiFunction {
  }
  12345678
  

  package cn_lemon;
  @FunctionalInterface
  public interface BiFunction {
      R apply(T t, U u);//接收两个参数 t 和 u, 返回 R
  }
  123456
  

  也就是说，reduce(BinaryOperator accumulator)方法需要一个函数式接口参数，该函数式接口需要两个参数，返回一个结果(reduce中返回的结果会作为下次累加器计算的第一个参数)，也就是累加器

  package cn_lemon;
  import org.junit.Test;
  import java.util.Optional;
  import java.util.stream.Stream;
  public class ReduceDemo {
      @Test
      public void reduceTest() {
          Optional accResult = Stream.of(1, 2, 3, 4).reduce((acc, item) -> {
              System.out.println("acc : " + acc);
              acc += item;
              System.out.println("item: " + item);
              System.out.println("acc+ : " + acc);
              System.out.println("--------");
              return acc;
          });
          System.out.println(accResult);
      }
  }
  123456789101112131415161718192021
  

  运行显示：

  

  方式二

  • T reduce(T identity, BinaryOperator accumulator);
  • 提供一个跟Stream中数据同类型的初始值identity，通过累加器accumulator迭代计算Stream中的数据，得到一个跟Stream中数据相同类型的最终结果

    package cn_lemon;
    import org.junit.Test;
    import java.util.Optional;
    import java.util.stream.Stream;
    public class ReduceDemo {
        @Test
        public void reduceTest() {
            int accResult = Stream.of(1, 2, 3, 4)
                    .reduce(100, (acc, item) -> {
                        System.out.println("acc : " + acc);
                        acc += item;
                        System.out.println("item: " + item);
                        System.out.println("acc+ : " + acc);
                        System.out.println("--------");
                        return acc;
                    });
            System.out.println(accResult);
        }
    }
    12345678910111213141516171819202122
    

    运行显示：

    

    方式三

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

    首先看一下BiFunction的三个泛型类型分别是U、 ? super T、U，参考BiFunction函数式接口apply方法定义可以知道，累加器累加器通过类型为U和? super T的两个输入值计算得到一个U类型的结果返回。也就是说这种reduce方法，提供一个不同于Stream中数据类型的初始值，通过累加器规则迭代计算Stream中的数据，最终得到一个同初始值同类型的结果

    package cn_lemon;
    import org.junit.Test;
    import java.util.ArrayList;
    import java.util.stream.Stream;
    public class ReduceDemo {
        @Test
        public void reduceTest() {
            ArrayList newList = new ArrayList();
            ArrayList accResult_ = Stream.of(2, 3, 4)
                    .reduce(newList,
                            (acc, item) -> {
                                acc.add(item);
                                System.out.println("item: " + item);
                                System.out.println("acc+ : " + acc);
                                System.out.println("BiFunction");
                                return acc;
                            }, (acc, item) -> null);
            System.out.println("accResult_: " + accResult_);
        }
    }
    123456789101112131415161718192021222324
    

    运行显示：

    

    通过运行结果可以看出，第三个参数定义的规则并没有执行。这是因为reduce的第三个参数是在使用parallelStream的reduce操作时，合并各个流结果的，本例中使用的是stream，所以第三个参数是不起作用的。上述示例，提供一个只有一个元素1的arrayList，通过累加器迭代，将stream中的数据添加到arrayList中