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

分割迭代器工具-SpliteratorUtil

# 📚 介绍

SpliteratorUtil 是 Hutool 核心模块中的分割迭代器工具类，它提供了丰富的 Spliterator 操作方法，用于增强 Java 标准库中 Spliterator 的功能，为 Java 开发者提供了便捷的并行流处理解决方案。

# 设计理念

  • 增强功能：扩展 Java 标准库的 Spliterator 功能
  • 简化使用：提供简洁的 API，简化 Spliterator 的创建和操作
  • 并行支持：优化并行流处理性能
  • 灵活扩展：支持各种类型的 Spliterator 操作
  • 线程安全：所有工具类都是线程安全的，可以在多线程环境下安全使用

# 🔧 核心方法详解

# 1. Spliterator 创建

# from(Collection collection)

功能：从集合创建 Spliterator

参数：

  • collection：要创建 Spliterator 的集合

返回值：Spliterator 对象

示例：

List<String> list = Arrays.asList("a", "b", "c", "d", "e");
// 从集合创建 Spliterator
Spliterator<String> spliterator = SpliteratorUtil.from(list);
Console.log("Spliterator 特征：" + spliterator.characteristics());

# from(Iterator iterator, long size)

功能：从迭代器创建 Spliterator

参数：

  • iterator：要创建 Spliterator 的迭代器
  • size：迭代器的大小，如果未知则使用 Long.MAX_VALUE

返回值：Spliterator 对象

示例：

Iterator<String> iterator = Arrays.asList("a", "b", "c").iterator();
// 从迭代器创建 Spliterator
Spliterator<String> spliterator = SpliteratorUtil.from(iterator, 3);
Console.log("Spliterator 大小：" + spliterator.estimateSize());

# 2. Spliterator 转换

# toStream(Spliterator spliterator)

功能：将 Spliterator 转换为 Stream

参数：

  • spliterator：要转换的 Spliterator

返回值：Stream 对象

示例：

List<String> list = Arrays.asList("a", "b", "c");
Spliterator<String> spliterator = SpliteratorUtil.from(list);
// 将 Spliterator 转换为 Stream
Stream<String> stream = SpliteratorUtil.toStream(spliterator);
List<String> result = stream.collect(Collectors.toList());
Console.log(result); // [a, b, c]

# toParallelStream(Spliterator spliterator)

功能：将 Spliterator 转换为并行 Stream

参数：

  • spliterator：要转换的 Spliterator

返回值：并行 Stream 对象

示例：

List<String> list = Arrays.asList("a", "b", "c", "d", "e");
Spliterator<String> spliterator = SpliteratorUtil.from(list);
// 将 Spliterator 转换为并行 Stream
Stream<String> parallelStream = SpliteratorUtil.toParallelStream(spliterator);
List<String> result = parallelStream.map(String::toUpperCase).collect(Collectors.toList());
Console.log(result); // [A, B, C, D, E]

# 3. Spliterator 合并

# concat(Spliterator<? extends T>... spliterators)

功能：合并多个 Spliterator 为一个

参数：

  • spliterators：要合并的 Spliterator 数组

返回值：合并后的 Spliterator

示例：

List<String> list1 = Arrays.asList("a", "b", "c");
List<String> list2 = Arrays.asList("d", "e", "f");
List<String> list3 = Arrays.asList("g", "h", "i");

// 创建多个 Spliterator
Spliterator<String> s1 = SpliteratorUtil.from(list1);
Spliterator<String> s2 = SpliteratorUtil.from(list2);
Spliterator<String> s3 = SpliteratorUtil.from(list3);

// 合并 Spliterator
Spliterator<String> mergedSpliterator = SpliteratorUtil.concat(s1, s2, s3);
// 转换为 Stream 并处理
Stream<String> stream = SpliteratorUtil.toStream(mergedSpliterator);
List<String> result = stream.collect(Collectors.toList());
Console.log(result); // [a, b, c, d, e, f, g, h, i]

# 4. Spliterator 操作

# filter(Spliterator spliterator, Predicate<? super T> predicate)

功能：过滤 Spliterator 中的元素

参数：

  • spliterator：要过滤的 Spliterator
  • predicate：过滤条件

返回值：过滤后的 Spliterator

示例：

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
Spliterator<Integer> spliterator = SpliteratorUtil.from(list);
// 过滤偶数
Spliterator<Integer> filteredSpliterator = SpliteratorUtil.filter(spliterator, num -> num % 2 == 0);
// 转换为 Stream 并处理
Stream<Integer> stream = SpliteratorUtil.toStream(filteredSpliterator);
List<Integer> result = stream.collect(Collectors.toList());
Console.log(result); // [2, 4, 6, 8, 10]

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

功能：转换 Spliterator 中的元素

参数：

  • spliterator：要转换的 Spliterator
  • mapper：转换函数

返回值：转换后的 Spliterator

示例：

List<String> list = Arrays.asList("a", "b", "c");
Spliterator<String> spliterator = SpliteratorUtil.from(list);
// 将元素转换为大写
Spliterator<String> mappedSpliterator = SpliteratorUtil.map(spliterator, String::toUpperCase);
// 转换为 Stream 并处理
Stream<String> stream = SpliteratorUtil.toStream(mappedSpliterator);
List<String> result = stream.collect(Collectors.toList());
Console.log(result); // [A, B, C]

# 5. Spliterator 特性

# getCharacteristics(Spliterator<?> spliterator)

功能：获取 Spliterator 的特性

参数：

  • spliterator：要获取特性的 Spliterator

返回值：特性列表

示例：

List<String> list = Arrays.asList("a", "b", "c");
Spliterator<String> spliterator = SpliteratorUtil.from(list);
// 获取 Spliterator 特性
Set<Spliterator.Characteristic> characteristics = SpliteratorUtil.getCharacteristics(spliterator);
Console.log("Spliterator 特性：" + characteristics);

# 🚀 综合示例

# 示例1：Spliterator 基本操作

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

    // 从集合创建 Spliterator
    Spliterator<String> spliterator = SpliteratorUtil.from(list);

    // 获取 Spliterator 特性
    Set<Spliterator.Characteristic> characteristics = SpliteratorUtil.getCharacteristics(spliterator);
    Console.log("Spliterator 特性：" + characteristics);

    // 估计大小
    Console.log("估计大小：" + spliterator.estimateSize());

    // 转换为 Stream 并处理
    Stream<String> stream = SpliteratorUtil.toStream(spliterator);
    List<String> result = stream
        .filter(s -> s.length() > 5)
        .map(String::toUpperCase)
        .sorted()
        .collect(Collectors.toList());

    Console.log("处理结果：" + result); // [BANANA, ORANGE, WATERMELON]
}

# 示例2：Spliterator 并行处理

public void spliteratorParallelTest() {
    // 创建大规模列表
    List<Integer> list = new ArrayList<>();
    for (int i = 0; i < 10000; i++) {
        list.add(i);
    }

    // 从集合创建 Spliterator
    Spliterator<Integer> spliterator = SpliteratorUtil.from(list);

    // 转换为并行 Stream 并处理
    Stream<Integer> parallelStream = SpliteratorUtil.toParallelStream(spliterator);

    long startTime = System.currentTimeMillis();
    // 计算偶数之和
    long sum = parallelStream
        .filter(num -> num % 2 == 0)
        .mapToLong(Long::valueOf)
        .sum();
    long endTime = System.currentTimeMillis();

    Console.log("偶数之和：" + sum);
    Console.log("并行处理时间：" + (endTime - startTime) + "ms");

    // 对比串行处理
    startTime = System.currentTimeMillis();
    sum = list.stream()
        .filter(num -> num % 2 == 0)
        .mapToLong(Long::valueOf)
        .sum();
    endTime = System.currentTimeMillis();

    Console.log("串行处理时间：" + (endTime - startTime) + "ms");
}

# 示例3：Spliterator 合并应用

public void spliteratorConcatTest() {
    // 创建三个不同的列表
    List<String> fruits = Arrays.asList("apple", "banana", "orange");
    List<String> vegetables = Arrays.asList("carrot", "tomato", "potato");
    List<String> meats = Arrays.asList("beef", "pork", "chicken");

    // 从每个列表创建 Spliterator
    Spliterator<String> fruitSpliterator = SpliteratorUtil.from(fruits);
    Spliterator<String> vegetableSpliterator = SpliteratorUtil.from(vegetables);
    Spliterator<String> meatSpliterator = SpliteratorUtil.from(meats);

    // 合并所有 Spliterator
    Spliterator<String> mergedSpliterator = SpliteratorUtil.concat(
        fruitSpliterator,
        vegetableSpliterator,
        meatSpliterator
    );

    // 转换为 Stream 并处理
    Stream<String> stream = SpliteratorUtil.toStream(mergedSpliterator);

    // 按长度分组
    Map<Integer, List<String>> groupedByLength = stream
        .collect(Collectors.groupingBy(String::length));

    Console.log("按长度分组结果：");
    groupedByLength.forEach((length, items) -> {
        Console.log(length + "个字符：" + items);
    });
}

# 🎯 设计优势

  1. 增强功能：扩展了 Java 标准库的 Spliterator 功能，提供了更多实用方法
  2. 简化使用：提供了简洁的 API，简化了 Spliterator 的创建和操作
  3. 并行优化：优化了并行流处理性能，提高了大规模数据处理效率
  4. 灵活扩展：支持各种类型的 Spliterator 操作，包括创建、转换、合并和过滤等
  5. 线程安全：所有方法都是线程安全的，可以在多线程环境下安全使用
  6. 兼容性好：兼容 Java 8 及以上版本，支持各种 Spliterator 实现

# 📌 注意事项

  1. 并行流适用场景：并行流并不总是比串行流快，对于小规模数据，串行流可能更快
  2. 线程安全：虽然 SpliteratorUtil 本身是线程安全的，但数据源的线程安全性取决于具体实现
  3. Spliterator 消耗：Spliterator 是一次性的，一旦遍历或分割后，就不能再次使用
  4. 特性了解：了解 Spliterator 的特性有助于优化并行流处理性能
  5. 内存占用：对于大规模数据，并行流处理可能会占用较多内存，建议根据实际情况调整并行度

# 🚀 总结

SpliteratorUtil 是一个功能强大、使用便捷的分割迭代器工具类，为 Java 开发者提供了丰富的 Spliterator 操作解决方案。它扩展了 Java 标准库的 Spliterator 功能，简化了 Spliterator 的创建和操作，优化了并行流处理性能。

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

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

环形索引工具-RingIndexUtil
迭代器工具-IterUtil

← 迭代器工具-IterUtil→

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