【总结】Java Stream

Stream 简介

Stream 是 Java 8 的新特性，实现了对集合类的补充，其通过了函数式编程以管道的方式提供中间操作和最终操作。

Stream 的特点：

• 不存储数据：流是基于数据源的对象，其将数据源传递给一系列操作，本身对数据源不进行存储；
• 函数式编程：流的操作不会改变数据源；
• 延迟操作：流的中间处理过程仅对操作进行记录而不会立即执行，只有出现终止操作时才会进行实际的操作和运算；
• 单次访问：流的元素仅能访问一次，其操作一但开始便不能再访问之前的元素，若想从头重新进行访问则需要创建一个新的流；

应用场景

• 在不修改数据源的前提下，对某些数据进行一些列的操作
• 可以实现数据的筛选、排序、匹配、聚合或自定义的系列操作
• 适用于对列表或数组数据统一处理

常用方法

Stream 创建方法

方法	简介
Collection 的 stream()/parallelStream()	将集合转换成流
Arrays 工具类提供的 stream() 方法	将数组转换成流
使用 Stream 类的静态方法 of()/iterate()/generate()	创建流对象

Stream 中间操作

方法	简介
filter()	传入函数实现对流数据的过滤
distinct()	利用 hashcode() 和 equals() 实现流数据的去重
skip()	跳过前 x 个元素
limit()	限制元素个数，取前 x 个元素

Stream 映射和排序

方法	简介
map()	接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
flatMap()	接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
sort()	可以按照默认规则（流中的元素需实现 Comparable 接口）进行排序或按照自定义规则进行排序

Stream 终止操作

方法	简介
allMatch()	流中数据全部都符合条件时返回 true
noneMatch()	流中全部数据都不符合条件时返回 true
anyMatch()	流中任意数据符合条件时返回 true
findFirst()	返回流中第一个元素
findAny()	返回流中任意元素
count()	返回流中元素的总个数
max()	返回流中数据最大值（需要传入比较器）
min()	返回流中数据最大值（需要传入比较器）

StreamDemo

package JavaStream;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamDemo {

    public static void main(String[] args) {
        // ==================== 1. Stream 的创建 ====================
        // (1) 使用 Collection 的 stream()/parallelStream() 方法，将集合转换成流
        List<String> list = new ArrayList<>();
        Stream<String> stream1 = list.stream();
        Stream<String> stringStream = list.parallelStream();
        // (2) Arrays 工具类提供的 stream() 方法，将数组转换成流
        Integer[] nums = new Integer[10];
        Stream<Integer> stream2 = Arrays.stream(nums);
        // (3) 使用 Stream 类的静态方法 of()/iterate()/generate()
        Stream<Integer> stream3 = Stream.of(1, 2, 2, 3, 3, 3, 4, 5, 6, 7, 8);
        Stream<Integer> stream4 = Stream.iterate(0, (x) -> x + 2).limit(6);
        stream4.forEach(System.out::println);
        Stream<Double> stream5 = Stream.generate(Math::random).limit(2);
        stream5.forEach(System.out::println);

        // ==================== 2. Stream 中间操作 ====================
        // filter：传入函数实现对流数据的过滤
        // distinct：利用 hashcode() 和 equals() 实现流数据的去重
        // skip：跳过前 x 个元素
        // limit：限制元素个数，取前 x 个元素
        Stream<Integer> newStream1 = stream3.filter(s -> s <= 5)
                .distinct()
                .skip(1)
                .limit(3);
        newStream1.forEach(System.out::println);

        // ==================== 3. Stream 映射 ====================
        // map：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
        List<String> arrayList = Arrays.asList("a,b,c", "1,2,3");
        List<String> newArrayList1 = arrayList.stream().map(s -> s.replace(",", "-")).collect(Collectors.toList());
        newArrayList1.forEach(System.out::println);
        // flatMap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
        Stream<String> newArrayList2 = arrayList.stream().flatMap(s -> {
            String[] split = s.split(",");
            return Arrays.stream(split);
        });
        newArrayList2.forEach(System.out::println);

        // ==================== 4. Stream 排序 ====================
        // sort：可以按照默认规则（流中的元素需实现 Comparable 接口）进行排序
        //       或按照自定义规则进行排序
        Stream<Integer> stream6 = Stream.of(49, 48, 21, 47, 83, 17, 23, 14, 56, 87, 27);
        Stream<Integer> stream7 = Stream.of(49, 48, 21, 47, 83, 17, 23, 14, 56, 87, 27);
        Stream<Integer> sorted1 = stream6.sorted();
        Stream<Integer> sorted2 = stream7.sorted((o1, o2) -> {
            int i = o1 % 10;
            int j = o2 % 10;
            return i - j;
        });
        sorted1.forEach(System.out::println);
        sorted2.forEach(System.out::println);

        // ==================== 5. Stream 终止操作（匹配或聚合） ====================
        // allMatch：流中数据全部都符合条件时返回 true
        // noneMatch：流中全部数据都不符合条件时返回 true
        // anyMatch：流中任意数据符合条件时返回 true
        System.out.println(stream6.allMatch(s -> s >= 10));
        System.out.println(stream6.noneMatch(s -> s >= 10));
        System.out.println(stream6.anyMatch(s -> s >= 10));
        // findFirst：返回流中第一个元素
        // findAny：返回流中任意元素
        // count：返回流中元素的总个数
        // max：返回流中数据最大值（需要传入比较器）
        // min：返回流中数据最大值（需要传入比较器）
        System.out.println(stream6.findFirst());
        System.out.println(stream6.findAny());
        System.out.println(stream6.count());
        System.out.println(stream6.max(Integer::compareTo));
        System.out.println(stream6.min(Integer::compareTo));
    }

}