java8关于stream操作api总结:

一、先介绍几个名词:

1、中间操作：

中间操作会产生另一个流。因此中间操作可以用来创建执行一系列动作的管道。一个特别需要注意的点是:中间操作不是立即发生的。相反，当在中间操作创建的新流上执行完终端操作后，中间操作指定的操作才会发生

2、终止操作：

会消费流，这种操作会产生一个结果的，如果一个流被消费过了，那它就不能被重用的。

3、"中间操作"的状态：

（1）无状态操作：在处理流中的每个元素时，与其他元素无关

（2）有状态操作：在处理流中的每个元素时，依赖其他元素（eg：min，max之类的）

4、缩减操作：

把一个流经过一个操作，输出一个值。eg：min、max，或者典型的reduce操作

5、for&forEach：

我们在访问一个数组元素的时候，最快的方式肯定是通过索引去访问的吧，而for循环遍历的时候就是通过下标进行的，所以效率那是相当的高，但是当我们的数据结构不是数组的时候，比如是链表的时候，可想而知，for循环的效率是有多低，但是forEach底层采用的是迭代器的方式，他对数据结构是没有要求的，不管上层的数据结构是什么，他都能保证高效地执行！因此我的最终答案:如果数据结构是ArrayList这种数据结构，那你可以采用for，但是你的数据结构如果是LinkList那你千万别再用for,应该果断采用forEach。

6、并行流：

调用parallel()就可以获取到一个并行流了，帮助我们多线程操作，提高效。需要注意的是，服务器需要多核支持

for循环,stream操作,并行stream操作的性能对比：

并行stream > for > stream : 数据量不大或者核数不够多的情况下，for比并行stream效率高

二、各种api:

1、中间操作——筛选

2、中间操作——映射

3、中间操作——排序

4、终止操作——查找与匹配

5、终止操作——归约

@Test
public  void reduceParallel() {
    List<Integer> lists = new ArrayList<>();
    lists.add(1);
    lists.add(2);
    lists.add(3);

    //每个元素都放大两倍后，再求积
    Integer product = lists.parallelStream().reduce(1, (a, b) -> a *  (b * 2),
                                                    (a, b) -> a * b);
    System.out.println("product:" + product);//48

    Integer product2 = lists.parallelStream().reduce(1, (a, b) -> {
        System.out.println("第一个参数：" + Thread.currentThread().getName() +",a="+a+",b="+b);
        return a *  (b * 2);},
                                                     (a, b) -> {
                                                         System.out.println("第二个参数：" + Thread.currentThread().getName()+",c="+a+",d="+b);
                                                         return  a * b;
                                                     });
    System.out.println("product2:" + product);//48
}

6、终止操作——收集，注意这里返回的都是一个收集器Collector

三、关于各种收集器：

1、均值——averaging

@Test
public void testAveraging() {
    List<Integer> lists = new ArrayList<>();
    lists.add(1);
    lists.add(2);
    lists.add(3);
    Double average = lists.stream().collect(Collectors.averagingInt(item -> item));
    System.out.println(average);
}

2、统计——元素个数：counting

@Test
public void testCounting() {
    List<Integer> lists = new ArrayList<>();
    lists.add(1);
    lists.add(2);
    lists.add(3);
    Long count = lists.stream().collect(Collectors.counting());
    System.out.println(count);
}

3、最值——maxBy、minBy

@Test
public void testMax() {
    List<Integer> lists = new ArrayList<>();
    lists.add(1);
    lists.add(2);
    lists.add(3);
    Optional<Integer> max = lists.stream().collect(Collectors.maxBy(Integer::compare));
    if (max.isPresent()){
        System.out.println(max.get());
    }
}

4、求和——summing、summarizing

@Test
public void testSummary() {
    List<Integer> lists = new ArrayList<>();
    lists.add(1);
    lists.add(2);
    lists.add(3);
    Integer sum = lists.stream().collect(Collectors.summingInt((item) -> item));
    System.out.println(sum);

    IntSummaryStatistics summary = lists.stream().collect(Collectors.summarizingInt((item) -> item));
    System.out.println(summary.getSum());
    System.out.println(summary.getAverage());
    System.out.println(summary.getCount());
    System.out.println(summary.getMax());
    System.out.println(summary.getMin());
}

5、分组——groupingBy,groupingByConcurrent

@Data
@Builder
static class Student{
    private Long id;
    private String name;
    private Long classId;
    private Integer age;
}

@Test
public void testGroup() {
    List<Student> list = new ArrayList<>();
    Student zhangSan = Student.builder().id(1L).name("张三").classId(1L).age(20).build();
    Student liSi = Student.builder().id(2L).name("李四").classId(1L).age(21).build();
    Student wangWu = Student.builder().id(3L).name("王五").classId(2L).age(21).build();
    Student zhaoLiu = Student.builder().id(4L).name("赵六").classId(1L).age(21).build();
    list.add(liSi);
    list.add(zhangSan);
    list.add(wangWu);
    list.add(zhaoLiu);

    //根据classId分组
    Map<Long, List<Student>> map1 = list.stream().collect(Collectors.groupingBy(Student::getClassId));
    System.out.println("map1:\n" + map1);
    //统计各个classId的人数
    Map<Long, Long> map2 = list.stream().collect(Collectors.groupingBy(Student::getClassId,
                                                                       Collectors.counting()));
    System.out.println("map2:\n" + map2);
    //统计各个classId的人数
    Map<Long, Long> map3 = list.stream().collect(Collectors.groupingBy(Student::getClassId,
                                                                       HashMap::new,
                                                                       Collectors.counting()));
    System.out.println("map3:\n" + map3);
}

6、分区——partitioningBy

@Test
public void testPartitioning() {
    List<Student> list = new ArrayList<>();
    Student zhangSan = Student.builder().id(1L).name("张三").classId(1L).age(20).build();
    Student liSi = Student.builder().id(2L).name("李四").classId(1L).age(21).build();
    Student wangWu = Student.builder().id(3L).name("王五").classId(2L).age(21).build();
    Student zhaoLiu = Student.builder().id(4L).name("赵六").classId(1L).age(21).build();
    list.add(liSi);
    list.add(zhangSan);
    list.add(wangWu);
    list.add(zhaoLiu);

    Map<Boolean, List<Student>> map = list.stream().collect(Collectors.partitioningBy((item -> item.getAge() > 20)));
    System.out.println("map:\n" + map);

    Map<Boolean, Long> map1 = list.stream().collect(Collectors.partitioningBy((item -> item.getAge() > 20), 
                                                                              Collectors.counting()));
    System.out.println("map1:\n" + map1);//{false=1, true=3}
}

7、Collector之后再操作——collectingAndThen

@Test
public void testCollectingAndThen() {
    List<Integer> list = new ArrayList<>();
    list.add(1);
    list.add(2);
    list.add(3);
    String result = list.stream().collect(Collectors.collectingAndThen(Collectors.counting(),
                                                                       (ret) -> "统计结果为=" + ret));
    System.out.println(result);
}

8、拼接——joining

@Test
public void testCollectingAndThen() {
    List<String> list = new ArrayList<>();
    list.add("a");
    list.add("b");
    list.add("c");
    String result = list.stream().collect(Collectors.joining());
    System.out.println(result);//abc
    String result2 = list.stream().collect(Collectors.joining("-"));
    System.out.println(result2);//a-b-c
    String result3 = list.stream().collect(Collectors.joining(",", "[", "]"));
    System.out.println(result3);//[a,b,c]
}

9、mapping

@Test
public void testMapping() {
    List<Student> list = new ArrayList<>();
    Student zhangSan = Student.builder().id(1L).name("张三").classId(1L).age(20).build();
    Student liSi = Student.builder().id(2L).name("李四").classId(1L).age(21).build();
    Student wangWu = Student.builder().id(3L).name("王五").classId(2L).age(21).build();
    Student zhaoLiu = Student.builder().id(4L).name("赵六").classId(1L).age(21).build();
    list.add(liSi);
    list.add(zhangSan);
    list.add(wangWu);
    list.add(zhaoLiu);
    String result = list.stream().collect(Collectors.mapping(Student::getName, Collectors.joining(",", "[", "]")));
    System.out.println(result);//[李四,张三,王五,赵六]
}

10、缩减——reducing

@Test
public void testReducing() {
    List<Integer> list = new ArrayList<>();
    list.add(1);
    list.add(2);
    list.add(3);
    //求和,返回Optional
    Optional<Integer> result = list.stream().collect(Collectors.reducing((a, b) -> a + b));
    if (result.isPresent()){
        System.out.println(result.get());//6
    }
    //求和,返回Integer
    Integer result2 = list.stream().collect(Collectors.reducing(0, (a, b) -> a + b));
    System.out.println(result2);//6
    //每个元素先平方,再求和
    Integer result3 = list.stream().collect(Collectors.reducing(0, item -> item * item, (a, b) -> a + b));
    System.out.println(result3);//14
}

11、集合转化——toCollection、toList与toSet

@Test
public void testToCollection() {
    List<Student> list = new ArrayList<>();
    Student zhangSan = Student.builder().id(1L).name("张三").classId(1L).age(20).build();
    Student liSi = Student.builder().id(2L).name("李四").classId(1L).age(21).build();
    Student wangWu = Student.builder().id(3L).name("王五").classId(2L).age(21).build();
    Student zhaoLiu = Student.builder().id(4L).name("赵六").classId(1L).age(21).build();
    list.add(liSi);
    list.add(zhangSan);
    list.add(wangWu);
    list.add(zhaoLiu);
    List<Student> toList = list.stream().filter(item -> item.getClassId().equals(1L)).collect(Collectors.toList());
    Set<Student> toSet = list.stream().filter(item -> item.getClassId().equals(1L)).collect(Collectors.toSet());
    ArrayList<Student> toCollection = list.stream().filter(item -> item.getClassId().equals(1L)).collect(Collectors.toCollection(ArrayList::new));
}

12、Map转化——toMap与toConcurrentMap

@Test
public void testToMap() {
    List<Student> list = new ArrayList<>();
    Student zhangSan = Student.builder().id(1L).name("张三").classId(1L).age(20).build();
    Student liSi = Student.builder().id(2L).name("李四").classId(1L).age(21).build();
    Student wangWu = Student.builder().id(3L).name("王五").classId(2L).age(21).build();
    Student zhaoLiu = Student.builder().id(4L).name("赵六").classId(1L).age(21).build();
    list.add(liSi);
    list.add(zhangSan);
    list.add(wangWu);
    list.add(zhaoLiu);

    //转为map,存在相同的key的话会抛异常
    Map<Long, String> map = list.stream().collect(Collectors.toMap(item -> item.getId(), 
                                                                   item -> item.getName()));
    System.out.println(map);//{1=张三, 2=李四, 3=王五, 4=赵六}

    //转化为map,若key相等,取后一个
    Student zhaoLiu2 = Student.builder().id(4L).name("赵六2").classId(1L).age(21).build();
    list.add(zhaoLiu2);
    Map<Long, String> map1 = list.stream().collect(Collectors.toMap(item -> item.getId(), 
                                                                    item -> item.getName(), 
                                                                    (a, b) -> b));
    System.out.println(map1);//{1=张三, 2=李四, 3=王五, 4=赵六2}

    //指定返回的map类型为TreeMap
    TreeMap<Long, String> map3 = list.stream().collect(Collectors.toMap(item -> item.getId(), 
                                                                        item -> item.getName(), 
                                                                        (a, b) -> b, 
                                                                        TreeMap::new));
    System.out.println(map3);//{1=张三, 2=李四, 3=王五, 4=赵六2}

}

参考文章:https://www.jianshu.com/p/ac2bcf2f9d48
参考文章:https://blog.csdn.net/xiliunian/article/details/88773718
参考文章:https://blog.csdn.net/weixin_44187730/article/details/93737517