Stream

Stream 基本概念

Stream 是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。

数据源 -> 中间操作 -> 终止操作

• Stream 自己不会存储元素。
• Stream 不会修改原数据源，而是返回一个新的流。
• Stream 的中间操作通常是惰性执行的，只有遇到终止操作才会真正开始计算。
• 一个 Stream 只能消费一次，执行完终止操作后不能再次使用。

创建 Stream

stream()

通过集合创建流

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
Stream<Integer> stream = list.stream();

stream.forEach(System.out::println);

Arrays.stream(T[] array)

通过数组创建流

String[] arr = {"hello", "world"};
Stream<String> stream = Arrays.stream(arr);

stream.forEach(System.out::println);

Stream.of(T... values)

直接通过一组元素创建流

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);

stream.forEach(System.out::println);

中间操作

中间操作会返回一个新的 Stream，可以继续拼接后续操作。

filter(Predicate<? super T> predicate)

• 作用：按条件过滤元素

List<String> names = Arrays.asList("Tom", "Jerry", "Rose", "Jack");

List<String> result = names.stream()
        .filter(name -> name.length() > 3)
        .collect(Collectors.toList());

System.out.println(result); // [Jerry, Rose, Jack]

distinct()

• 作用：去除重复元素
• 注意：依赖元素的 equals() 和 hashCode()

List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 3, 3, 4);

List<Integer> result = numbers.stream()
        .distinct()
        .collect(Collectors.toList());

System.out.println(result); // [1, 2, 3, 4]

skip(long n)

• 作用：跳过前 n 个元素

List<Integer> numbers = Arrays.asList(10, 20, 30, 40, 50);

List<Integer> result = numbers.stream()
        .skip(2)
        .collect(Collectors.toList());

System.out.println(result); // [40, 50]

limit(long maxSize)

• 作用：截取前 maxSize 个元素

List<Integer> numbers = Arrays.asList(10, 20, 30, 40, 50);

List<Integer> result = numbers.stream()
        .limit(3)
        .collect(Collectors.toList());

System.out.println(result); // [10, 20, 30]

map(Function<? super T, ? extends R> mapper)

• 作用：将流中的元素映射成另一种结果

List<String> names = Arrays.asList("Tom", "Jerry", "Rose");

List<Integer> lengths = names.stream()
        .map(String::length)
        .collect(Collectors.toList());

System.out.println(lengths); // [3, 5, 4]

sorted()

• 作用：按元素自然顺序排序
• 注意：元素必须实现 Comparable

List<Integer> numbers = Arrays.asList(5, 2, 4, 1, 3);

List<Integer> result = numbers.stream()
        .sorted()
        .collect(Collectors.toList());

System.out.println(result); // [1, 2, 3, 4, 5]

sorted(Comparator<? super T> comparator)

• 作用：按指定比较器排序

List<String> names = Arrays.asList("Tom", "Jerry", "Rose", "Bob");

List<String> result = names.stream()
        .sorted((a, b) -> b.length() - a.length())
        .collect(Collectors.toList());

System.out.println(result); // [Jerry, Rose, Tom, Bob]

终止操作

一旦执行终止操作，流就会被消费，不能再次使用。

allMatch(Predicate<? super T> predicate)

• 作用：判断是否所有元素都满足条件
• 返回值：true 或 false

List<Integer> numbers = Arrays.asList(2, 4, 6, 8);

boolean result = numbers.stream()
        .allMatch(num -> num % 2 == 0);

System.out.println(result); // true

anyMatch(Predicate<? super T> predicate)

• 作用：判断是否至少有一个元素满足条件
• 返回值：true 或 false

List<Integer> numbers = Arrays.asList(1, 3, 5, 8);

boolean result = numbers.stream()
        .anyMatch(num -> num % 2 == 0);

System.out.println(result); // true

max(Comparator<? super T> comparator)

• 作用：按比较器规则获取最大元素
• 返回值：Optional<T>

List<Integer> numbers = Arrays.asList(3, 8, 2, 6);

Optional<Integer> max = numbers.stream()
        .max(Integer::compareTo);

System.out.println(max.get()); // 8

min(Comparator<? super T> comparator)

• 作用：按比较器规则获取最小元素
• 返回值：Optional<T>

List<Integer> numbers = Arrays.asList(3, 8, 2, 6);

Optional<Integer> min = numbers.stream()
        .min(Integer::compareTo);

System.out.println(min.get()); // 2

forEach(Consumer<? super T> action)

• 作用：遍历流中的每个元素并执行指定操作

List<String> names = Arrays.asList("Tom", "Jerry", "Rose");

names.stream().forEach(System.out::println);

reduce(T identity, BinaryOperator<T> accumulator)

• 作用：从初始值开始，对流中元素反复进行归约计算
• 返回值：归约结果

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

Integer sum = numbers.stream()
        .reduce(0, Integer::sum);

System.out.println(sum); // 15

reduce(BinaryOperator<T> accumulator)

• 作用：不指定初始值地进行归约
• 返回值：Optional<T>

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

Optional<Integer> sum = numbers.stream()
        .reduce(Integer::sum);

System.out.println(sum.get()); // 15

count()

• 作用：统计流中元素个数
• 返回值：long

List<String> names = Arrays.asList("Tom", "Jerry", "Rose");

long count = names.stream().count();

System.out.println(count); // 3

collect(Collector<? super T, A, R> collector)

• 作用：将流中的元素收集到目标容器中
• 返回值：由收集器决定

List<String> names = Arrays.asList("Tom", "Jerry", "Rose");

Set<String> set = names.stream()
        .collect(Collectors.toSet());

System.out.println(set);

findFirst()

• 作用：返回流中的第一个元素
• 返回值：Optional<T>

List<String> names = Arrays.asList("Tom", "Jerry", "Rose");

Optional<String> first = names.stream().findFirst();

System.out.println(first.get()); // Tom

findAny()

• 作用：返回流中的任意一个元素
• 返回值：Optional<T>

List<String> names = Arrays.asList("Tom", "Jerry", "Rose");

Optional<String> any = names.stream().findAny();

System.out.println(any.get()); // 可能是任意一个元素