Hutool
  • 指南
  • 核心(hutool-core)
  • 集合(collection)
Hutool
2026-01-14
目录

集合流工具-CollStreamUtil

# 📚 介绍

CollStreamUtil 是 Hutool 核心模块中的集合流操作工具类，它提供了丰富的集合与流之间的转换方法，以及增强的流操作功能，为 Java 开发者提供了便捷的集合流处理解决方案。

# 设计理念

  • 简化转换：简化集合与流之间的转换操作
  • 增强功能：扩展 Java 标准库的流操作功能
  • 提高效率：提供高效的流处理方法
  • 统一接口：为不同类型的集合提供统一的流操作接口
  • 线程安全：所有工具类都是线程安全的，可以在多线程环境下安全使用

# 🔧 核心方法详解

# 1. 集合转流

# toStream(Collection collection)

功能：将集合转换为 Stream

参数：

  • collection：要转换的集合

返回值：Stream 对象

示例：

List<String> list = Arrays.asList("a", "b", "c");
// 转换为流
Stream<String> stream = CollStreamUtil.toStream(list);
// 使用流进行操作
List<String> upperCaseList = stream.map(String::toUpperCase).collect(Collectors.toList());
Console.log(upperCaseList); // [A, B, C]

# toParallelStream(Collection collection)

功能：将集合转换为并行流

参数：

  • collection：要转换的集合

返回值：并行 Stream 对象

示例：

List<String> list = Arrays.asList("a", "b", "c");
// 转换为并行流
Stream<String> parallelStream = CollStreamUtil.toParallelStream(list);
// 使用并行流进行操作
List<String> upperCaseList = parallelStream.map(String::toUpperCase).collect(Collectors.toList());
Console.log(upperCaseList); // [A, B, C]

# 2. 迭代器转流

# toStream(Iterator iterator)

功能：将迭代器转换为 Stream

参数：

  • iterator：要转换的迭代器

返回值：Stream 对象

示例：

List<String> list = Arrays.asList("a", "b", "c");
Iterator<String> iterator = list.iterator();
// 迭代器转流
Stream<String> stream = CollStreamUtil.toStream(iterator);
// 使用流进行操作
long count = stream.count();
Console.log(count); // 3

# toStream(Enumeration enumeration)

功能：将枚举转换为 Stream

参数：

  • enumeration：要转换的枚举

返回值：Stream 对象

示例：

Vector<String> vector = new Vector<>(Arrays.asList("a", "b", "c"));
Enumeration<String> enumeration = vector.elements();
// 枚举转流
Stream<String> stream = CollStreamUtil.toStream(enumeration);
// 使用流进行操作
List<String> result = stream.collect(Collectors.toList());
Console.log(result); // [a, b, c]

# 3. 数组转流

# toStream(T[] array)

功能：将数组转换为 Stream

参数：

  • array：要转换的数组

返回值：Stream 对象

示例：

String[] array = {"a", "b", "c"};
// 数组转流
Stream<String> stream = CollStreamUtil.toStream(array);
// 使用流进行操作
List<String> result = stream.collect(Collectors.toList());
Console.log(result); // [a, b, c]

# 4. 流转集合

# toList(Stream stream)

功能：将 Stream 转换为 List

参数：

  • stream：要转换的流

返回值：List 对象

示例：

Stream<String> stream = Stream.of("a", "b", "c");
// 流转List
List<String> list = CollStreamUtil.toList(stream);
Console.log(list); // [a, b, c]

# toSet(Stream stream)

功能：将 Stream 转换为 Set

参数：

  • stream：要转换的流

返回值：Set 对象

示例：

Stream<String> stream = Stream.of("a", "b", "c", "a");
// 流转Set（自动去重）
Set<String> set = CollStreamUtil.toSet(stream);
Console.log(set); // [a, b, c]

# toMap(Stream stream, Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends V> valueMapper)

功能：将 Stream 转换为 Map

参数：

  • stream：要转换的流
  • keyMapper：键映射函数
  • valueMapper：值映射函数

返回值：Map 对象

示例：

Stream<String> stream = Stream.of("a", "b", "c");
// 流转Map，键为元素，值为元素长度
Map<String, Integer> map = CollStreamUtil.toMap(stream, s -> s, String::length);
Console.log(map); // {a=1, b=1, c=1}

# 5. 增强流操作

# filter(Stream stream, Predicate<? super T> predicate)

功能：过滤流中的元素

参数：

  • stream：要过滤的流
  • predicate：过滤条件

返回值：过滤后的流

示例：

Stream<String> stream = Stream.of("a", "ab", "abc");
// 过滤长度大于1的元素
Stream<String> filteredStream = CollStreamUtil.filter(stream, s -> s.length() > 1);
List<String> result = filteredStream.collect(Collectors.toList());
Console.log(result); // [ab, abc]

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

功能：转换流中的元素

参数：

  • stream：要转换的流
  • mapper：转换函数

返回值：转换后的流

示例：

Stream<String> stream = Stream.of("a", "b", "c");
// 将元素转换为大写
Stream<String> mappedStream = CollStreamUtil.map(stream, String::toUpperCase);
List<String> result = mappedStream.collect(Collectors.toList());
Console.log(result); // [A, B, C]

# 🚀 综合示例

# 示例1：集合流处理综合应用

public void collStreamUtilTest() {
    // 创建集合
    List<String> list = Arrays.asList("apple", "banana", "orange", "grape", "watermelon");

    // 集合转流，过滤长度大于5的元素，转换为大写，排序，收集为列表
    List<String> result = CollStreamUtil.toStream(list)
        .filter(s -> s.length() > 5)
        .map(String::toUpperCase)
        .sorted()
        .collect(Collectors.toList());

    Console.log(result); // [BANANA, ORANGE, WATERMELON]

    // 集合转并行流，计算元素长度，收集为Map
    Map<String, Integer> lengthMap = CollStreamUtil.toParallelStream(list)
        .collect(Collectors.toMap(s -> s, String::length));

    Console.log(lengthMap); // {apple=5, banana=6, orange=6, grape=5, watermelon=10}
}

# 示例2：迭代器流处理

public void iteratorStreamTest() {
    // 创建集合
    Set<String> set = new HashSet<>(Arrays.asList("a", "b", "c", "d", "e"));

    // 获取迭代器
    Iterator<String> iterator = set.iterator();

    // 迭代器转流，过滤元素，转换为列表
    List<String> result = CollStreamUtil.toStream(iterator)
        .filter(s -> !"c".equals(s))
        .collect(Collectors.toList());

    Console.log(result); // [a, b, d, e]
}

# 🎯 设计优势

  1. 简化转换：简化了集合与流之间的转换操作，一行代码即可完成
  2. 增强功能：扩展了 Java 标准库的流操作功能，提供了更多实用方法
  3. 提高效率：提供了高效的流处理方法，特别是并行流处理
  4. 统一接口：为不同类型的集合和迭代器提供了统一的流操作接口
  5. 线程安全：所有方法都是线程安全的，可以在多线程环境下安全使用
  6. 易于扩展：采用接口设计，便于扩展新的流操作功能

# 📌 注意事项

  1. 流关闭：使用完流后，不需要手动关闭，Stream 会自动处理
  2. 并行流注意事项：并行流虽然可以提高处理速度，但会增加线程开销，对于小规模数据，建议使用串行流
  3. 顺序问题：并行流处理结果的顺序可能与原始集合不同，如果需要保持顺序，建议使用串行流
  4. 异常处理：在流操作中，建议使用 try-catch 处理可能的异常
  5. 内存占用：对于大规模数据，流处理可能会占用较多内存，建议分批处理

# 🚀 总结

CollStreamUtil 是一个功能强大、使用便捷的集合流操作工具类，为 Java 开发者提供了丰富的集合流处理解决方案。它简化了集合与流之间的转换操作，扩展了 Java 标准库的流操作功能，提高了流处理的效率。

无论是简单的集合转流，还是复杂的流处理操作，CollStreamUtil 都能轻松应对。通过合理使用 CollStreamUtil，可以简化集合流处理的开发工作，提高开发效率，同时保证处理的准确性和性能。

CollStreamUtil 是 Hutool 集合模块中的重要组成部分，与其他集合工具类一起，构成了完整的集合操作解决方案，为 Java 开发者提供了丰富的集合操作工具。

集合工具-CollUtil
列表工具-ListUtil

← 列表工具-ListUtil→

Theme by Vdoing | Copyright © 2025-2026 Hutool | Apache-2.0