完全搞懂Java8中reduce

让天下没有难学的java

点赞、关注、收藏

一、前言

• reduce是什么？简单来说我认为的reduce就是一个归一化的迭代操做。接受一个stream，经过重复应用操做将他们组合成一个简单结果。

• 若是要与collect做对比的话，一般状况下collect返回的是List<T>，Set<T>，Map<T>...，而reduce一般只返回T（可是T是泛型，实际上你能够返回包括List在类的任意类型）。

• 本文主要介绍三个参数的reduce（），并行、非线程安全、及combiner。

Optional<T> reduce(BinaryOperator<T> accumulator);

T reduce(T identity,BinaryOperator<T> accumulator);

<U> U reduce(U identity,BiFunction<U,? super T,U> accumulator,BinaryOperator<U> combiner);

复制代码

二、小试牛刀

• 一个参数的reduce
• 其中sum、min、max等底层都是reduce实现的。

/*** * @param: accumulator * @return: Optional */
Optional<T> reduce(BinaryOperator<T> accumulator);
复制代码

• 其中BinaryOperator<T>能够看作是BiFunction<T,T,T>的特例。

public class Main {

  public static void main(String[] args) {
  
  
  List<Integer> list = Lists.newArrayList(1,2,3,4,5);
  
  list.stream().reduce( 
        new BinaryOperator<Integer>() {
          @Override
          public Integer apply(Integer integer, Integer integer2) {
            return integer + integer2;
          }
        }));
  
    //=====等价于=====
    System.out.println(IntStream.range(1, 100).reduce((v1, v2) -> v1 + v2).orElse(0));
  //=====等价于=====
    System.out.println(IntStream.range(1, 100).reduce(Integer::sum).orElse(0));
  }
}

integer=1===integer2=2
integer=3===integer2=3
integer=6===integer2=4
integer=10===integer2=5
复制代码

三、大展身手

• 二个参数的reduce，其实就是比一个参数多一个初始值。即指定了reduce初次迭代时候第一个参数。

public class Main {

  public static void main(String[] args) {

    List<Integer> list = Lists.newArrayList(1,2,3,4,5);
    
    //初始值100
    list.stream().reduce(
        100,
        new BinaryOperator<Integer>() {
          @Override
          public Integer apply(Integer integer, Integer integer2) {
            System.out.println("integer="+integer+"===integer2="+integer2);
            return integer + integer2;
          }
        }));
  }
}
//初始值是100，不是1。比没有初始值的reduce多迭代1次。
integer=100===integer2=1
integer=101===integer2=2
integer=103===integer2=3
integer=106===integer2=4
integer=110===integer2=5
复制代码

四、展翅翱翔

• 前2个都是喽啰，三个参数的reduce才是大BOSS。
• 先说一个结论，非并行流下第三个参数没用。流中元素只有1个的状况下，即便指定parallel也不会走并行。
• 使用三个参数的reduce，务必注意线程安全。

<U> U reduce(U identity,BiFunction<U,? super T,U> accumulator,BinaryOperator<U> combiner);

复制代码

• 简单了解下BiFunction，第一个参数T，第二个参数U，返回值是R

=====> (T t,U u)-> (R)r  
复制代码

@FunctionalInterface
public interface BiFunction<T, U, R> {

    R apply(T t, U u);

    default <V> BiFunction<T, U, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t, U u) -> after.apply(apply(t, u));
    }
}
复制代码

• 下面看个demo（建议花几分钟思考下，也许完全就明白了）

public static void main(String[] args) {
    ArrayList<Integer> accResult = Stream.of(1, 3, 5, 7)
        .reduce(new ArrayList<>(),
            new BiFunction<ArrayList<Integer>, Integer, ArrayList<Integer>>() {
              @Override
              public ArrayList<Integer> apply(ArrayList<Integer> integers, Integer item) {
                System.out.println("before add: " + integers);
                System.out.println("item= " + item);
                integers.add(item);
                System.out.println("after add : " + integers);
                System.out.println("In BiFunction");
                return integers;
              }
            }, new BinaryOperator<ArrayList<Integer>>() {
              @Override
              public ArrayList<Integer> apply(ArrayList<Integer> integers, ArrayList<Integer> integers2) {
                integers.addAll(integers2);
                System.out.println("integers: " + integers);
                System.out.println("integers2: " + integers2);
                System.out.println("In BinaryOperator");
                return integers;
              }
            });
    System.out.println("accResult: " + accResult);
  }
复制代码

• 第三个参数内容压根没打印？那要第三个参数干吗，别急

public static void main(String[] args) {
    ArrayList<Integer> accResult = Stream.of(1, 3, 5, 7).parallel()
        .reduce(new ArrayList<>(),
            new BiFunction<ArrayList<Integer>, Integer, ArrayList<Integer>>() {
              @Override
              public ArrayList<Integer> apply(ArrayList<Integer> integers, Integer item) {
                integers.add(item);
                return integers;
              }
            }, new BinaryOperator<ArrayList<Integer>>() {
              @Override
              public ArrayList<Integer> apply(ArrayList<Integer> integers, ArrayList<Integer> integers2) {
                integers.addAll(integers2);
                System.out.println("thread name="+Thread.currentThread().getName()+" ==== integers=" + integers);
                System.out.println("integers2: " + integers2);
                System.out.println("In BinaryOperator");
                return integers;
              }
            });
    //打印结果几乎每次都不一样
    System.out.println("accResult: " + accResult);
  }
复制代码

• 多了个parallel，打印结果几乎每次不一样，还有一堆null。数据也不全，个人1，3，5，7都出现不全。还有时候会报异常。

五、并行流下的reduce

• 并行流下会出现线程安全问题。如咱们上述中的ArrayList，就是一个非线程安全类，不少操做会致使意想不到的结果。

5.一、 基本数据类型下的并行reduce

public static void main(String[] args) {
    System.out.println(
        Stream.of(1, 2, 3, 4).parallel().reduce(5, new BiFunction<Integer, Integer, Integer>() {
              @Override
              public Integer apply(Integer integer, Integer integer2) {
                return integer + integer2;
              }
            }
            , new BinaryOperator<Integer>() {
              @Override
              public Integer apply(Integer integer, Integer integer2) {
                return integer + integer2;
              }
            }));
  }
复制代码

• 示意图以下：（其中accumulator的个数=stream，combiner个数比accumulator少1个）

  

5.二、若是第一个参数是ArrayList等对象而非基本数据类型或String，那么结果跟咱们想的可能很不同。

• 打印结果、线程名极可能不会不一致，ArrayList非线程安全。（若是Collections.synchronizedList(a)包装下元素却是不会少）。

• 着重看System.out.println(acc==item);。每次accumulator的第二个参数与第一个参数中ArrayList同样。

• 若是将List<Integer> a 转成Collections.synchronizedList(a)，那么顺序不必定一致，可是元素必定是全的。

//大概示意图

六、小结

• 简单介绍了reduce的三个重载函数，着重说了三个参数的reduce。
• 非并行流下accumulator（第三个参数）没有用，并行流下accumulator个数与stream元素个数一致，combiner个数比stream元素少一个。
• 并行流下的线程安全、combiner中第一个参数是ArrayList等对象类型和基本类型下的差别化进行了说明。