Java Stream流式编程

为了方便演示流的各种操作，这里数据统一用如下的 arr 集合

List<Integer> arr = Arrays.asList(5, 4, 3, 6, 6, 9, 8, 7, 1, 2);

1.forEach 遍历

函数原型：void forEach(Consumer<? super T> action)

描述：遍历所有元素，并执行相应操作

如：遍历所有元素 并打印

arr.stream().forEach( e -> {System.out.println(e); });

2.filter 过滤

函数原型：Stream<T> filter(Predicate<? super T> predicate)

描述：用参数（函数式接口，可以用lambda表达式）指定一个过滤条件，将过滤之后的数据放到一个新的Stream流中

如：利用filter将 大于等于5 的数据过滤出来，收集到list集合中

List<Integer> res = arr.stream().filter(e -> e >= 5).toList();

3.distinct 元素去重

函数原型：Stream<T> distinct()

描述：去除重复数据，将去重后的数据放到一个新的Stream流中

如：利用distinct对元素进行 去重，收集到list集合中

List<Integer> res = arr.stream().distinct().toList();

4.sorted 排序

函数原型：Stream<T> sorted(Comparator<? super T> comparator)

描述：根据指定的比较方式，对元素进行排序

如：对流中的元素进行 从小到大 排序，排序后的结果收集到list集合中

List<Integer> res = arr.stream().sorted((a, b) -> a - b).toList();

5.max 与 min

函数原型：Optional<T> max(Comparator<? super T> comparator)

                  Optional<T> min(Comparator<? super T> comparator)

描述：根据指定的比较方式，拿到最大值或最小值封装到Optional对象中

如：利用max与min获取最大值，最小值

Integer max = arr.stream().max((a, b) -> a - b).get();
Integer min = arr.stream().min((a, b) -> a - b).get();

6.skip 跳过前几个

函数原型：Stream<T> skip(long n)

描述：跳过流中的前几个数据，将剩下的数据放到一个新的Stream流中

如：利用skip 跳过前3个元素，将剩余的元素放到list集合中

List<Integer> res = arr.stream().skip(3).toList();

7.limit 长度限制

函数原型：Stream<T> limit(long maxSize)

描述：从流中取出元素的个数不能超过maxSize

如：从流中 取出前五个元素

List<Integer> res = arr.stream().limit(5).toList();

8.collect 收集

函数原型：<R, A> R collect(Collector<? super T, A, R> collector)

描述：将流中的元素收集到指定类型的集合中（可以通过Collectors类中的静态方法指定，如toSet()，toList()等）

如：将流中的元素 收集到Set 集合中

Set<Integer> res = arr.stream().collect(Collectors.toSet());

9.map 数据映射

函数原型：<R> Stream<R> map(Function<? super T, ? extends R> mapper)

描述：对流中的每一个元素进行数据映射，将映射后的数据放到一个新的Stream流中

如：利用map进行将数据类型进行映射，将所有的数据都 映射为String 类型

List<String> res = arr.stream().map(e -> String.valueOf(e)).toList();

10.条件判断

① allMatch 全满足

函数原型：boolean allMatch(Predicate<? super T> predicate)

描述：判断所有的元素是否都满足指定条件

如：判断所有的元素 是否都大于5

if (arr.stream().allMatch(e -> e > 5)){
    System.out.println("所有元素都大于5");
}

② anyMatch 存在一个满足

函数原型：boolean anyMatch(Predicate<? super T> predicate)

描述：流中的所有元素，只要存在一个满足条件的，则返回true

如：判断 是否存在大于100 的元素

if (arr.stream().anyMatch(e -> e > 100)) {
    System.out.println("存在元素大于100");
}

③ noneMatch 都不满足

函数原型：boolean noneMatch(Predicate<? super T> predicate)

描述：如果所有元素都不满足条件，则返回true

如：判断所有元素 是否都不小于0

if (arr.stream().noneMatch(e -> e < 0)) {
    System.out.println("arr中的元素都不小于0");
}

11.reduce 合并元素

函数原型：Optional<T> reduce(BinaryOperator<T> accumulator)

描述：通过指定的操作对元素进行合并（如相加）

如：将所有的元素进行 相加，获取相加后的结果

Integer sum = arr.stream().reduce((a, b) -> a + b).get();

12.dropWhile 一直删除

函数原型：Stream<T> dropWhile(Predicate<? super T> predicate)

描述：指定一个条件，遇到第一个不满足条件的元素之前一直删除

如：删除前面 连续小于3的前缀

List<Integer> res = arr.stream()
                         .dropWhile(e -> e < 3)
                         .collect(Collectors.toList());

13.takeWhile 拿出

函数原型：Stream<T> takeWhile(Predicate<? super T> predicate)

描述：指定一个条件，遇到第一个不满足条件的元素之前一直取出

如：取出 连续大于3的前缀

List<Integer> res = arr.stream()
                            .takeWhile(e -> e > 3)
                            .collect(Collectors.toList());

14.flatMap 将流压平

函数原型：<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)

描述：指定一个操作元素函数（该函数会遍历所有元素），返回操作后的结果流

如：将二维数组转为一维数组，将 许多流压成一个流

Integer[][]arr2D = {
    {1,1,1},
    {2,2,2},
    {3,3,3}
};

//  [1, 1, 1, 2, 2, 2, 3, 3, 3]
Object[] res = Arrays.stream(arr2D)
                        .flatMap(a -> Arrays.stream(a))
                        .toArray();