Java Stream 流常用方法

4. 零散数据

使用 Stream.of() 静态方法。

注意：如果传入的是基本数据类型的数组（如 int[]），Stream.of 会把整个数组当成一个元素（即传递的是地址）；引用类型数组则会正常展开。

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

三、第二步：Stream 中间方法 (Intermediate Operations)

中间方法具有惰性求值的特点：它们不会立即执行，只有当遇到'终结方法'时，整个流水线才会启动。

核心规则：Stream 流只能使用一次，复用会报错，建议使用链式编程。中间操作不会修改原集合的数据。

1. 筛选与切片

• limit(n)：截断流，只取前 n 个数据。
• skip(n)：跳过流，扔掉前 n 个数据。

distinct()：元素去重。

注意：该方法依赖元素的 hashCode() 和 equals() 方法。如果是自定义对象，请务必重写这两个方法。

filter(Predicate)：过滤。返回 false 代表当前数据舍弃，返回 true 代表保留。

// 留下 list 中以'张'开头的数据
list.stream().filter(ele -> ele.startsWith("张"));

2. 组合 (Concat)

• Stream.concat(a, b)：将两个流合并为一个流。

3. 映射 (Map & FlatMap)

flatMap(Function)：扁平化映射。主要作用是将一个流中的每个元素映射成一个新的流，然后将这些新的流合并成一个单一的流。

// 示例：将嵌套列表 [[1,2], [3,4], [5,6]] 展平为 [1,2,3,4,5,6]
List<List<Integer>> listOfLists = Arrays.asList(
    Arrays.asList(1, 2),
    Arrays.asList(3, 4),
    Arrays.asList(5, 6)
);
List<Integer> flattenedList = listOfLists.stream()
    .flatMap(List::stream) // 将每个小 List 变成 Stream
    .collect(Collectors.toList());

map(Function)：转换流中的数据类型。

// 示例：将 "张三 -20" 这种字符串转为 int 类型的年龄
List<String> list = Arrays.asList("张三 -20", "李四 -18");
list.stream()
    .map(s -> Integer.parseInt(s.split("-")[1])) // 字符串转数字
    .forEach(System.out::println);

4. 排序 (Sorted)

• sorted()：根据自然顺序排序（要求元素实现 Comparable 接口）。

sorted(Comparator)：通过自定义比较器排序。升序示例：

// 先按年龄排序，年龄相同则按名字排序
List<Person> sortedList = people.stream()
    .sorted(Comparator.comparing(Person::getAge)
        .thenComparing(Person::getName))
    .collect(Collectors.toList());

降序示例：可以在 comparing 后面链式调用 .reversed()，或者直接使用 Comparator.reverseOrder()。

// 按年龄降序
people.stream().sorted(Comparator.comparing(Person::getAge).reversed());

5. 调试 (Peek)

• peek(Consumer)：类似于 forEach，但它是一个中间操作。通常用于在流的各个阶段打印日志，观察数据流向，而不打断流的处理。

四、第三步：Stream 终结方法 (Terminal Operations)

终结方法是流操作的最后一步，调用后流即关闭，无法再次使用。

1. 遍历与统计

• count()：返回流中数据的个数（long 类型）。

forEach(Consumer)：遍历操作，返回值为 void。

stream.forEach(ele -> System.out.println(ele));

2. 查找与匹配

• anyMatch(Predicate)：判断流中是否包含任意一个满足条件的元素。
• allMatch(Predicate)：判断流中是否所有元素都满足条件。
• findFirst()：返回流中的第一个元素（返回类型为 Optional）。

3. 数组转换

• 不传参：返回 Object[]。
• 传参：返回指定类型的数组。

toArray()：

// lambda 表达式中的 value 代表数组的长度
String[] arr = stream.toArray(value -> new String[value]);
// 或者使用方法引用
String[] arr2 = stream.toArray(String[]::new);

4. 归约 (Reduce)

reduce()：用于将流中的所有元素结合起来，得到一个值。例如求和、求最大值等。

// 计算 1-10 的和
Integer sum = Stream.iterate(1, x -> x + 1).limit(10)
    .reduce(0, (a, b) -> a + b);

5. 收集 (Collect)

这是最常用的终结方法，将流转变为集合或其他数据结构。

• Collectors.toList() / toSet()：收集到 List 或 Set 中。

Collectors.groupingBy()：分组（高频用法）。根据某个分类函数对流中的元素进行分组，返回一个 Map。

场景 1：基础分组

// 按照年龄分组，返回 Map<Integer, List<Person>>
Map<Integer, List<Person>> peopleByAge = people.stream()
    .collect(Collectors.groupingBy(Person::getAge));

场景 2：分组并统计

// 按照年龄分组，并计算每个年龄段的人数，返回 Map<Integer, Long>
Map<Integer, Long> peopleCountByAge = people.stream()
    .collect(Collectors.groupingBy(Person::getAge, Collectors.counting()));

Collectors.toMap()：收集到 Map 中。

注意：toMap 如果遇到重复的 Key 会报错，建议处理 Key 冲突。

示例：将 "名字 - 性别 - 年龄" 格式的数据转为 Map，以名字为 Key，年龄为 Value。

List<String> list = Arrays.asList("张三 - 男 -20", "李四 - 女 -18");
Map<String, Integer> map = list.stream()
    .collect(Collectors.toMap(
        s -> s.split("-")[0], // Key: 名字
        s -> Integer.parseInt(s.split("-")[2]) // Value: 年龄
    ));

五、进阶：方法引用 (Method References)

当 Lambda 表达式体中仅仅是调用一个已存在的方法时，可以使用方法引用 :: 来简化代码，使代码更具可读性。

1. 静态方法引用

格式：ClassName::staticMethod

// Lambda: s -> Integer.parseInt(s)
// 引用：Integer::parseInt
list.stream().map(Integer::parseInt).collect(Collectors.toList());

2. 实例方法引用

格式：object::instanceMethod (对象名::成员方法)

StringBuilder sb = new StringBuilder();
// Lambda: s -> sb.append(s)
// 引用：sb::append
list.stream().forEach(sb::append);

3. 特定类型的任意对象的实例方法引用

格式：ClassName::method

适用场景：Lambda 的第一个参数是方法的调用者，后面的参数是方法的形参。

List<String> words = Arrays.asList("apple", "banana");
// Lambda: (s) -> s.length() --> 相当于调用 "apple".length()
// 引用：String::length
List<Integer> lengths = words.stream()
    .map(String::length)
    .collect(Collectors.toList());

4. 构造方法引用

格式：ClassName::new

List<String> names = Arrays.asList("Alice", "Bob");
// Lambda: name -> new Person(name)
// 引用：Person::new
List<Person> people = names.stream()
    .map(Person::new)
    .collect(Collectors.toList());

六、总结

Java Stream API 的核心流程可以概括为：数据源 (Source) -> 中间操作 (Intermediate) -> 终结操作 (Terminal)