JAVA Stream相关的API及其示例

Java 8 引入的流 API (java.util.stream) 提供了一系列方法来处理集合中的数据。流 API 使得处理数据更加简洁、高效并且易于理解。

流接口 (java.util.stream.Stream)

Stream 接口定义了许多操作，可以分为中间操作和终端操作两大类。

中间操作

中间操作不会执行任何操作，而是创建一个新的流，以便进行下一步处理。这些操作可以链接起来。

1. 筛选:

   • filter(Predicate<? super T> predicate): 根据给定的条件筛选流中的元素。
   • distinct(): 去除流中的重复元素。

2. 映射:

   • map(Function<? super T, ? extends U> mapper): 将流中的元素转换为另一种类型。
   • flatMap(Function<? super T, ? extends Stream<? extends U>> mapper): 将流中的每个值替换成另一个流，然后将所有的流连接成一个流。

3. 排序:

   • sorted(): 对流中的元素进行自然排序。
   • sorted(Comparator<? super T> comparator): 根据提供的比较器对流中的元素进行排序。

4. 切片:

   • limit(long maxSize): 截取流中的前 maxSize 个元素。
   • skip(long n): 跳过流中的前 n 个元素。

5. 组合:

   • concat(Stream<T> a, Stream<T> b): 将两个流连接在一起。

终端操作

终端操作会触发之前的所有中间操作，并产生一个结果或副作用。一旦执行了终端操作，流就被认为是“消耗”完毕，不能再次使用。

1. 收集:

   • collect(Collector<? super T, ?, R> collector): 将流中的元素收集到集合或其他结构中。
   • collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner): 自定义收集逻辑。

2. 聚合:

   • count(): 计算流中的元素数量。
   • min(Comparator<? super T> comparator): 寻找流中的最小元素。
   • max(Comparator<? super T> comparator): 寻找流中的最大元素。
   • reduce(T identity, BinaryOperator<T> accumulator): 应用累加器函数，将流中的元素减少为一个值。
   • summarizingInt, summarizingLong, summarizingDouble: 生成描述性统计信息。

3. 遍历:

   • forEach(Consumer<? super T> action): 对流中的每个元素执行动作。
   • forEachOrdered(Consumer<? super T> action): 以元素的原始顺序执行动作。

4. 匹配:

   • anyMatch(Predicate<? super T> predicate): 测试是否有元素匹配给定的条件。
   • allMatch(Predicate<? super T> predicate): 测试是否所有元素都匹配给定的条件。
   • noneMatch(Predicate<? super T> predicate): 测试是否没有元素匹配给定的条件。

5. 查找:

   • findFirst(): 返回流中的第一个元素（如果有）。
   • findAny(): 返回流中的任意一个元素（如果有）。

示例代码

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

public class StreamExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // 使用流 API 进行操作
        Stream<Integer> stream = numbers.stream();

        // 筛选偶数
        List<Integer> evenNumbers = stream.filter(n -> n % 2 == 0)
                                          .collect(Collectors.toList());

        // 打印筛选后的结果
        evenNumbers.forEach(System.out::println);

        // 重新创建流
        stream = numbers.stream();

        // 映射每个元素到其平方
        List<Integer> squares = stream.map(n -> n * n)
                                      .collect(Collectors.toList());

        // 打印映射后的结果
        squares.forEach(System.out::println);

        // 重新创建流
        stream = numbers.stream();

        // 排序
        List<Integer> sortedNumbers = stream.sorted()
                                            .collect(Collectors.toList());

        // 打印排序后的结果
        sortedNumbers.forEach(System.out::println);

        // 重新创建流
        stream = numbers.stream();

        // 求和
        int sum = stream.mapToInt(Integer::intValue)
                        .sum();

        // 打印求和结果
        System.out.println("Sum: " + sum);

        // 重新创建流
        stream = numbers.stream();

        // 找到最大的元素
        Optional<Integer> maxElement = stream.max(Comparator.naturalOrder());

        // 打印最大元素
        maxElement.ifPresent(max -> System.out.println("Max element: " + max));
    }
}

输出结果

2
4
6
8
10
1
4
9
16
25
36
49
64
81
100
1
2
3
4
5
6
7
8
9
10
Sum: 55
Max element: 10