public class StreamReduceDemo {
    public static void main(String[] args) {
        List<Integer> list1 = Arrays.asList(1, 2, 3, 4, 5);
        List<String> list2 = list1.stream().reduce(new ArrayList<String>(), (a, b) -> {
            a.add("element-" + b);
            return a;
        }, (a, b) -> null);
        System.out.print(list2);
    }
}

• 第一个参数传入一个空的ArrayList()，即初始值就是这个，也指定了我要返回的list到底是什么类型；
• 第二个参数里，a代表往这个ArrayList()里add元素后的list，b代表stream里每个Integer类型的值，跟前面两种重载方法的参数意义是一样的；

• 第三个参数如果不是并行的stream，指定为(a, b) -> null即可，网上博客里说随便指定什么都行，但是当是并行的stream时这个参数代表将并行的stream合并的意思，这种情况我目前没遇到过，目前仅遇到了stream元素类型需要转换的场景。

  2.3.1.3 max/min

  统计流中的最大值和最小值。max/min方法根据指定的Comparator（可选），返回一个Optional，该Optional中的value值就是Stream中最大/最小元素。
  举例：统计数组里元素的最小值：

  public class IntermediateDemo {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 4, 5};
        System.out.println(Arrays.stream(nums).min().getAsInt());
    }
  }
  

  举例：统计student列表里age最大的student：

  public class StudentSortDemo {
    public static void main(String[] args) {
        List<Student> studentList = new ArrayList<>();
        studentList.add(new Student("Jerry", 27, 1));
        studentList.add(new Student("Jerry", 27, 2));
        studentList.add(new Student("Jerry", 28, 3));
        studentList.add(new Student("Cissie", 27, 4));
  
        System.out.println(studentList.stream().max(Comparator.comparing(Student::getAge)).get());
    }
  }
  

  2.3.1.4 count

  返回流中元素的个数。
  举例：

  Integer[] nums = {1, 2, 3, 4, 5};
  Stream<Integer> stream = Arrays.stream(nums);
  System.out.println(stream.count());
  

  2.3.2 短路操作

  2.3.2.1 allMatch anyMatch noneMatch

• allMatch：接收一个Predicate函数接口的lambda表达式，当流中每个元素都符合该断言时才返回true，否则返回false；

• anyMatch：接收一个Predicate函数接口的lambda表达式，只要流中有一个元素满足该断言则返回true，否则返回false；
• noneMatch：接收一个Predicate函数接口的lambda表达式，当流中每个元素都不符合该断言时才返回true，否则返回false。

举例：

public class terminalDemo {
    public static void main(String[] args) {
        Integer[] nums = {1, 2, 3, 4, 5};
        Stream<Integer> stream = Arrays.stream(nums);

        System.out.println("流中所有元素都大于0，返回true");
        System.out.println(stream.allMatch(num -> num > 0));

        System.out.println("流中所有元素至少有一个大于3，返回true");
        System.out.println(stream.anyMatch(num -> num > 3));

        System.out.println("流中所有元素均没有大于6，返回true");
        System.out.println(stream.noneMatch(num -> num > 6));
    }
}

注意上面例子里只能打开一个流，其他的流要注释掉。

2.3.2.2 findAny findFirst

• findAny：返回流中的任意元素；
• findFirst：返回流中第一个元素。

举例：

public class terminalDemo {
    public static void main(String[] args) {
        Integer[] nums = {1, 2, 3, 4, 5};
        Stream<Integer> stream = Arrays.stream(nums);

        System.out.println("返回流中的任意元素");
        System.out.println(stream.findAny().get());

        System.out.println("返回流中的第一个元素");
        System.out.println(stream.findFirst().get());
    }
}

3、Collectors工具库

在java stream中，我们通常需要将处理后的stream转换成集合类，这个时候就需要用到stream.collect方法，collect方法需要传入一个Collector类型的接口，java提供了简单的Collectors工具类来方便我们构建Collector。Collectors工具类有很多，下面仅介绍比较常用的几个。

3.1 Collectors.toList()

将stream转化为ArrayList，注意仅支持ArrayList，如果是LinkedList则不行。这个方法也是使用最多的Collectors工具库。
举例：

public class CollectorsDemo {
    public static void main(String[] args) {
        Integer[] arrays = new Integer[]{1, 2, 3, 4, 5};
        List<Integer> list = Arrays.stream(arrays).collect(Collectors.toList());
        System.out.print(list);
    }
}

3.2 Collectors.toSet()

将stream转化成Set，注意这里转换后的set是HashSet，如果需要特别指定set，那么需要使用toCollection方法。
举例：

public class CollectorsDemo {
    public static void main(String[] args) {
        Integer[] arrays = new Integer[]{1, 2, 2, 4, 4};
        Set<Integer> set = Arrays.stream(arrays).collect(Collectors.toSet());
        System.out.print(set);
    }
}

3.3 Collectors.toMap()

Collectors.toMap 有三个重载方法：

toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper);

toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper,
        BinaryOperator<U> mergeFunction);

toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper,
        BinaryOperator<U> mergeFunction, Supplier<M> mapSupplier);

参数含义分别是：

• keyMapper：Key 的映射函数；
• valueMapper：Value 的映射函数；
• mergeFunction：当 Key 冲突时，调用的合并方法；
• mapSupplier：Map 构造器，在需要返回特定的 Map 时使用。

Collectors.toMap的一个典型的应用场景是list转换成map。

3.3.1 2个参数的重载方法

举例：
POJO类如下：

@Data
@AllArgsConstructor
public class Employee {
    private String name;
    private String department;
}

需求是：将Employee实例组成的list转换成如下的map：

Develop -> Jerry
Test -> Cissie
Product -> Jason

代码：

public class CollectorToMapDemo {
    public static void main(String[] args) {
        List<Employee> employeeList = new ArrayList<>();
        employeeList.add(new Employee("Jerry", "Develop"));
        employeeList.add(new Employee("Cissie", "Test"));
        employeeList.add(new Employee("Jason", "Product"));

        Map<String, String> map = employeeList.stream().collect(Collectors.toMap(Employee::getDepartment,
                Employee::getName));
        System.out.println(map);
    }
}

结果：

{Develop=Jerry, Test=Cissie, Product=Jason}

注意：2个参数的Collectors.toMap方法的前提是生成的map的key不能重复，否则会抛异常，即例子里的部门属性值是唯一的。

3.3.2 3个参数的重载方法

接上面的例子，当map的key有重复怎么处理？第三个参数mergeFunction就是指定key冲突时的处理方法，比如上面例子中，当部门属性冲突时，value指定重复的属性对应的name值字符串拼接：

public class CollectorToMapDemo {
    public static void main(String[] args) {
        List<Employee> employeeList = new ArrayList<>();
        employeeList.add(new Employee("Jerry", "Develop"));
        employeeList.add(new Employee("Cissie", "Test"));
        employeeList.add(new Employee("Tom", "Test"));
        employeeList.add(new Employee("Jack", "Develop"));
        employeeList.add(new Employee("Jason", "Product"));

        Map<String, String> map = employeeList.stream().collect(Collectors.toMap(Employee::getDepartment,
                Employee::getName, (e1, e2) -> (e1 + "&" + e2)));
        System.out.println(map);
    }
}

结果：

{Develop=Jerry&Jack, Test=Cissie&Tom, Product=Jason}

注意：第三个参数里的lambda表达式里的(e1, e2)对应的生成的map里的value，即name。

3.3.3 4个参数的重载方法

第四个参数（mapSupplier）用于自定义返回 Map 类型，比如我们希望返回的 Map 是根据 Key 排序的，可以使用如下写法：

public static void main(String[] args) {
        List<Employee> employeeList = new ArrayList<>();
        employeeList.add(new Employee("Jerry", "Develop"));
        employeeList.add(new Employee("Cissie", "Test"));
        employeeList.add(new Employee("Tom", "Test"));
        employeeList.add(new Employee("Jack", "Develop"));
        employeeList.add(new Employee("Jason", "Product"));

        Map<String, String> map = employeeList.stream().collect(Collectors.toMap(Employee::getDepartment,
                Employee::getName, (e1, e2) ->e1, TreeMap::new));
        System.out.println(map);
    }

结果：

{Develop=Jerry, Product=Jason, Test=Cissie}

第三个参数(e1, e2) -> e1，即当key冲突时，保留之前的value。

3.4 Collectors.groupingBy()

Collectors.groupingBy有3种重载函数，如下：

Collector<T, ?, Map<K, List<T>>>
    groupingBy(Function<? super T, ? extends K> classifier);

Collector<T, ?, Map<K, D>> groupingBy(Function<? super T, ? extends K> classifier,
                                          Collector<? super T, A, D> downstream);

Collector<T, ?, M> groupingBy(Function<? super T, ? extends K> classifier,
                                  Supplier<M> mapFactory,
                                  Collector<? super T, A, D> downstream);

得到的map是可以自定义的，即指定map的key和value是如何生成的，参考6.1的案例体会一下。

3.4.1 1个参数的重载方法

举例：
按照Employee的department属性分类，最后得到一个map，map的key是department，value是这个department对应的Employee实例：

public static void main(String[] args) {
        List<Employee> employeeList = new ArrayList<>();
        employeeList.add(new Employee("Jerry", "Develop", 1));
        employeeList.add(new Employee("Cissie", "Test", 2));
        employeeList.add(new Employee("Tom", "Test", 3));
        employeeList.add(new Employee("Jack", "Develop", 4));
        employeeList.add(new Employee("Jason", "Product", 5));

        Map<String, List<Employee>> groupByMap =
                employeeList.stream().collect(Collectors.groupingBy(Employee::getDepartment));
        System.out.println(groupByMap);
    }

结果:

{Develop=[Employee(name=Jerry, department=Develop, id=1), Employee(name=Jack, department=Develop, id=4)], Test=[Employee(name=Cissie, department=Test, id=2), Employee(name=Tom, department=Test, id=3)], Product=[Employee(name=Jason, department=Product, id=5)]}

3.4.2 2个参数的重载方法

举例：
按照Employee的department属性分类，最后得到一个map，map的key是department，value是这个department对应的Employee实例的个数：

public static void main(String[] args) {
        List<Employee> employeeList = new ArrayList<>();
        employeeList.add(new Employee("Jerry", "Develop", 1));
        employeeList.add(new Employee("Cissie", "Test", 2));
        employeeList.add(new Employee("Tom", "Test", 3));
        employeeList.add(new Employee("Jack", "Develop", 4));
        employeeList.add(new Employee("Jason", "Product", 5));

        Map<String, Long> groupByMap =
                employeeList.stream().collect(Collectors.groupingBy(Employee::getDepartment, Collectors.counting()));
        System.out.println(groupByMap);
    }

结果:

{Develop=2, Test=2, Product=1}

3.5 Collectors.partitioningBy()

partitioningBy是一个特别的groupingBy，partitioningBy返回的是一个Map，这个Map是以boolean值为key，从而将stream分成两部分，key为true的value是匹配partitioningBy条件的list，key为false的value是不匹配partitioningBy条件的list。
举例：将employeeList分成两组，一组是id属性大于3的，一组是id属性小于等于3的：

public static void main(String[] args) {
        List<Employee> employeeList = new ArrayList<>();
        employeeList.add(new Employee("Jerry", "Develop", 1));
        employeeList.add(new Employee("Cissie", "Test", 2));
        employeeList.add(new Employee("Tom", "Test", 3));
        employeeList.add(new Employee("Jack", "Develop", 4));
        employeeList.add(new Employee("Jason", "Product", 5));

        Map<Boolean, List<Employee>> map =
                employeeList.stream().collect(Collectors.partitioningBy(employee -> employee.getId() > 3));
        System.out.println(map);
    }

结果：

{false=[Employee(name=Jerry, department=Develop, id=1), Employee(name=Cissie, department=Test, id=2), Employee(name=Tom, department=Test, id=3)], true=[Employee(name=Jack, department=Develop, id=4), Employee(name=Jason, department=Product, id=5)]}

4、Parallel Stream

parallelStream不需要添加其他多线程代码就可以实现流的并行处理，其底层使用Fork/Join框架实现。
举例：

public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
        numbers.parallelStream().forEach(number -> System.out.print(number + " "));
    }

结果：

6 5 8 9 7 4 1 2 3

结果并没有按顺序一次输出1-9，原因是有多个工作线程在打印这些数字，做如下处理可以显示处理：

public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
        numbers.parallelStream().forEach(number -> System.out.println(Thread.currentThread().getName() + "-" + number));
    }

结果：

main-6
main-5
ForkJoinPool.commonPool-worker-11-4
ForkJoinPool.commonPool-worker-11-1
main-2
ForkJoinPool.commonPool-worker-11-9
ForkJoinPool.commonPool-worker-2-8
ForkJoinPool.commonPool-worker-4-7
ForkJoinPool.commonPool-worker-9-3

可见，由main线程和worker线程分别打印数字，整个打印过程时并行的。

什么时候使用stream，什么时候使用parallelStream呢？
我们可以从以下几个角度考虑使用场景：

1. 是否需要并行？
2. 任务之间是否是独立的？是否会引起任何竞态条件？
3. 结果是否取决于任务的调用顺序？

思考结论：

1. 对于问题1，当数据量不大时，顺序执行往往比并行执行更快，毕竟准备线程池和其它相关资源也是需要时间的；但是当任务涉及到I/O操作并且任务之间不互相依赖时，那么并行化就是一个不错的选择，通常而言，将这类程序并行化之后，执行速度会提升好几个等级；
2. 对于问题2，如果任务之间是独立的，并且代码中不涉及到对同一个对象的某个属性或者某个变量的更新操作，那么代码是可以被并行化的；
3. 对于问题3，由于在并行环境中任务的执行顺序是不确定的，因此对于依赖于顺序的任务而言，并行化也许不能给出正确的结果。

   5、Stream性能分析

   具体过程可以阅读参考文献中的这篇文章：Java Stream API性能测试，这里直接上测试结果：

• 对于简单操作，比如最简单的遍历，Stream串行API性能明显差于for循环迭代，但并行的Stream API能够发挥多核特性；
• 对于复杂操作，Stream串行API性能可以和for循环迭代的效果匹敌，在并行执行时Stream API效果远超手动实现。

因此在实际使用时，选择stream还是普通的for循环，给出几点建议：

• 对于简单操作推荐使用外部for循环手动实现，
• 对于复杂操作，推荐使用Stream API；
• 在多核情况下，推荐使用并行Stream API来发挥多核优势；
• 单核情况下不建议使用并行Stream API。

如果出于代码简洁性考虑，使用Stream API能够写出更短的代码。即使是从性能方面说，尽可能的使用Stream API也有另外一个优势，那就是只要Java Stream类库做了升级优化，代码不用做任何修改就能享受到升级带来的好处。

6、实战Demo

这里总结一些工作中遇到的需要借助stream api处理的场景。

6.1 合并多个相同属性的对象集合

场景描述：从数据库读取若干条云主机的账单记录到内存，需要将regionId、ordId（组织id）和cpu（cpu核数）都相同的DTO的expense（计费）相加，并将累加结果转换成返回给前端的VO，即根据这三个维度去聚合账单并set一些其他属性字段拼成最终的VO。
云主机账单DTO如下：

package stream;

import lombok.AllArgsConstructor;
import lombok.Data;

import java.math.BigDecimal;

@Data
@AllArgsConstructor
public class ECSBillDTO {
    private String regionId;
    private String ordId;
    private int cpu;
    private BigDecimal expense;
}

返回给前端的账单VO如下：

package stream;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.math.BigDecimal;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class ECSBillVO {
    private String regionId;
    private String ordId;
    private int cpu;
    private BigDecimal expense;

    // 相比DTO多加的属性字段
    private String createTime;
}

main：

public class streamMain {
    public static void main(String[] args) {
        // 生成数据
        List<ECSBillDTO> ecsBillList = new ArrayList<>();
        ecsBillList.add(new ECSBillDTO("region01", "org01", 1, new BigDecimal("100")));
        ecsBillList.add(new ECSBillDTO("region01", "org01", 2, new BigDecimal("200")));
        ecsBillList.add(new ECSBillDTO("region01", "org01", 4, new BigDecimal("400")));
        ecsBillList.add(new ECSBillDTO("region01", "org02", 4, new BigDecimal("400")));
        ecsBillList.add(new ECSBillDTO("region01", "org02", 4, new BigDecimal("400")));
        ecsBillList.add(new ECSBillDTO("region02", "org01", 2, new BigDecimal("200")));
        ecsBillList.add(new ECSBillDTO("region02", "org02", 4, new BigDecimal("400")));

        // 调用函数处理
        List<ECSBillVO> results = getBillList(ecsBillList);
        System.out.println(results);
    }

    private static List<ECSBillVO> getBillList(List<ECSBillDTO> ecsBillList)
    {
        List<ECSBillVO> resultList = new ArrayList<>();

        ecsBillList.stream().collect(Collectors.groupingBy(ecsBillDTO ->
                ecsBillDTO.getCpu() + ecsBillDTO.getOrdId() + ecsBillDTO.getRegionId(), Collectors.toList()))
                .forEach((k, v) -> v.stream().reduce((a, b) ->
                        new ECSBillDTO(a.getRegionId(), a.getOrdId(), a.getCpu(), a.getExpense().add(b.getExpense()))
                ).map(ecsBillDTO -> {
                    ECSBillVO ecsBillVO = new ECSBillVO();
                    try {
                        BeanUtils.copyProperties(ecsBillVO, ecsBillDTO);
                    } catch (IllegalAccessException | InvocationTargetException e) {
                        e.printStackTrace();
                    }
                    ecsBillVO.setCreateTime(new Date().toString());
                    return ecsBillVO;
                }).ifPresent(resultList::add));

        return resultList;
    }
}

结果：

[ECSBillVO(regionId=region02, ordId=org01, cpu=2, expense=200, createTime=Mon Jan 18 00:40:40 CST 2021), ECSBillVO(regionId=region02, ordId=org02, cpu=4, expense=400, createTime=Mon Jan 18 00:40:40 CST 2021), ECSBillVO(regionId=region01, ordId=org01, cpu=2, expense=200, createTime=Mon Jan 18 00:40:40 CST 2021), ECSBillVO(regionId=region01, ordId=org01, cpu=1, expense=100, createTime=Mon Jan 18 00:40:40 CST 2021), ECSBillVO(regionId=region01, ordId=org01, cpu=4, expense=400, createTime=Mon Jan 18 00:40:40 CST 2021), ECSBillVO(regionId=region01, ordId=org02, cpu=4, expense=800, createTime=Mon Jan 18 00:40:40 CST 2021)]

alibaba Java编程规范里禁止使用BeanUtils方法进行属性拷贝了，原因是性能低下，推荐使用Spring的BeanUtils。

参考：

Java 8 stream的详细用法
Java8中Stream详细用法大全
Java 8系列之Stream的基本语法详解
java stream中Collectors的用法
Java 8 中的 Streams API 详解
java stream api中的reduce方法使用 大侠陈 关注 赞赏支持
java 8 stream reduce详解和误区
Java8 中 List 转 Map(Collectors.toMap) 使用技巧
深入浅出parallelStream
Java Stream API性能测试
Java8中用Lambda表达式合并多个相同属性的对象集合
Java-Stream重用流