【Java】Java8的Stream流入门使用

Java 8 引入了 Stream API，使得对集合（如 List、Set 等） 的操作变得更加简洁、灵活，并能够利用函数式编程的特性。Stream 提供了很多非常强大的功能，帮助我们以声明性和链式方式处理数据。

什么是 `Stream`？

Stream 是 Java 8 中引入的一个新抽象，它表示一个源（如集合、数组）上的元素序列，可以进行 聚合操作 （例如：过滤、映射、排序等），并支持通过流式操作来进行数据处理。Stream 本身是一个 惰性求值 的接口，即操作仅在需要的时候才会执行，支持并行操作。

Stream的主要特性

不存储数据 ：Stream 本身并不存储数据，它只是数据的载体，操作是通过对源数据进行转换来实现的。
惰性求值 ：流的操作通常是惰性计算的，只有在终止操作被调用时，流才会被消费并执行。
链式操作 ：Stream 提供了多种可以链式调用的中间操作和终止操作。

Stream的创建

通过集合创建

通过数组创建

通过Stream.of()创建Stream

通过Stream.iterate()创建Stream（无限流）

通过Stream.generate()创建Stream（无限流）

Stream的常用API

中间操作（惰性操作）

中间操作用于转换流的数据，执行这些操作不会马上执行，而是返回一个新的 Stream。这些操作是惰性求值的。

filter() - 过滤

map() - 映射

flatMap() - 扁平化

distinct() - 去重

sorted() - 排序

java 复制代码

public class StreamApiTest {
    public static void main(String[] args) {
        filter();
        map();
        flatMap();
        distinct();
        sorted();
    }

    /**
     * 过滤，返回一个流，方法参数是Predicate接口，返回true则保留，false则过滤掉。
     */
    public static void filter(){
        List<String> list = Arrays.asList("ab", "abb", "a", "d", "abcde");
        List<String> collect = list.stream()
                .filter(s -> s.length() > 1)
                .collect(Collectors.toList());
        System.out.println(collect);
    }

    /**
     * 映射，返回一个流，方法参数是Function接口，对每个元素进行转换。
     */
    public static void map(){
        List<String> list = Arrays.asList("a", "b", "c", "d", "e");
        List<String> collect = list.stream()
                .map(String::toUpperCase)
                .collect(Collectors.toList());
        System.out.println(collect);
    }

    /**
     * 扁平化，用于将多个子流合并成一个流，常用于将嵌套集合的元素展开铺平
     */
    public static void flatMap(){
        List<List<Integer>> listOfLists = Arrays.asList(
                Arrays.asList(1, 2),
                Arrays.asList(3, 4),
                Arrays.asList(5, 6)
        );
        List<Integer> collect = listOfLists.stream()
                .flatMap(list -> list.stream())
                .collect(Collectors.toList());
        System.out.println(collect);
    }

    /**
     * 去重，返回一个流，去除流中重复的元素。
     */
    public static void distinct(){
        List<String> list = Arrays.asList("a", "b", "c", "a", "a", "c");
        List<String> collect = list.stream()
                .distinct()
                .collect(Collectors.toList());
        System.out.println(collect);
    }

    /**
     * 排序，返回一个流，按照元素的自然顺序排序。
     */
    public static void sorted(){
        List<String> list = Arrays.asList("abcd", "ab", "aab", "abb");
        List<String> collect = list.stream()
                .sorted()
                .collect(Collectors.toList());
        System.out.println(collect);

        // 还可以自定义排序规则，根据长度进行排序
        List<String> collect1 = list.stream()
                .sorted((s1, s2) -> s1.length() - s2.length())
                .collect(Collectors.toList());
        System.out.println(collect1);
    }
}

终止操作（急切操作）

终止操作会触发流的处理，并且只会执行一次，执行后流会被消耗，不能再次使用。

collect() - 收集

forEach() - 遍历

reduce() - 归约

anyMatch() | allMatch() | noneMatch() - 匹配

java 复制代码

public class StreamApiTest {
    public static void main(String[] args) {
        collect();
        forEach();
        reduce();
    }

    /**
     * 收集，将流的元素收集到一个集合中
     */
    public static void collect(){
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        List<Integer> collect = list.stream()
                .collect(Collectors.toList());
        System.out.println(collect);
    }

    /**
     * 遍历，用于遍历流中的每个元素，并执行指定操作
     */
    public static void forEach(){
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        list.stream()
                .forEach(s -> System.out.print(s));
        System.out.println();
    }

    /**
     * 整合，用于将流中的所有元素结合成一个值，常用于求和、求积，就最值等操作
     */
    public static void reduce(){
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        Integer sum = list.stream()
                .reduce(0, (a, b) -> a + b);
        System.out.println(sum);
    }
}