Guava有库来划分可迭代类。Iterables是一个实用类，它有静态方法来划分可迭代类。但是返回值是列表的可迭代值。给出的代码显示了如何做到这一点。

Set<Integer> myIntSet = new HashSet<Integer>();
// fill the set
Iterable<List<Integer>> lists = Iterables.partition(myIntSet, SIZE_EACH_PARTITION);

此方法将拆分集合的元素，以便第一个集合包含前2000个元素，第二个集合包含后2000个元素，依此类推。

public static <T> List<Set<T>> split(Set<T> original, int count) {
    // Create a list of sets to return.
    ArrayList<Set<T>> result = new ArrayList<Set<T>>(count);

    // Create an iterator for the original set.
    Iterator<T> it = original.iterator();

    // Calculate the required number of elements for each set.
    int each = original.size() / count;

    // Create each new set.
    for (int i = 0; i < count; i++) {
        HashSet<T> s = new HashSet<T>(original.size() / count + 1);
        result.add(s);
        for (int j = 0; j < each && it.hasNext(); j++) {
            s.add(it.next());
        }
    }
    return result;
}

//As example, in your code...

Set<Integer> originalSet = new HashSet<Integer>();
// [fill the set...]
List<Set<Integer>> splitSets = split(originalSet, 5);
Set<Integer> first = splitSets.get(0); // etc.

如果你不想自己写，可以看看guava . Lists类有一个方法partition（List，int）来把一个列表分割成多个指定大小的列表.

我已经写了一些东西，做分裂的集。
它使用中间数组和列表。
它使用Arrays.asList和Arrays.copyOfRange方法。

import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

public class SetSplitTest {
    //define and initialize set
    private static Set<Integer> largeSet;
    static {
        largeSet  = new HashSet<Integer>();

        for (int i = 0; i < 10000; i++) {
            largeSet.add(i);
        }
    }

    public static void main() {
        System.out.println(largeSet);
        int amountOfSets = 5; //amount of subsets wanted
        Set<Integer>[] subsets = new Set[amountOfSets]; //array holding the subsets

        Integer[] largesetarray =  largeSet.toArray(new Integer[largeSet.size()]);

        for (int i = 1; i <= amountOfSets; i++) {
            int fromIndex = (i-1) * largeSet.size() / amountOfSets;
            int toIndex = i * largeSet.size() / amountOfSets - 1; 
            Set<Integer> subHashSet = new HashSet<Integer>();
            subHashSet.addAll(Arrays.asList(Arrays.copyOfRange(largesetarray, fromIndex, toIndex)));

            subsets[i - 1] = subHashSet;
        }

        for (Set<Integer> subset : subsets) {
            System.out.println(subset);
        }
    }
}

这绝对不是最优雅的解决方案，但它是最好的，我能想到的时刻，当不想循环集自己。

迟回答，但你可以尝试，
1.通过将其转换为列表，使用Guava库来使用Lists.partition(list, PARTITION_VALUE)。
依赖性：

<dependency>
      <groupId>com.google.guava</groupId>
      <artifactId>guava</artifactId>
      <version>31.1-jre</version>
  </dependency>

用法：

import com.google.common.collect.Lists;
import java.util.*;
.
.
Set<String> hashSet = new HashSet<>();
//Fill data to hashSet
List<String> hashSetAsList = new ArrayList<>(hashSet);
List<List<String>> partitionedLists = Lists.partition(hashSetAsList, PARTITION_VALUE);

1.通过使用List.subList(INDEX_START,INDEX_END)

import java.util.*;
.
.
List<String> hashSetAsList = new ArrayList<>(hashSet);
List<String> subList = hashSetAsList.subList(INDEX_START,INDEX_END);
//INDEX_END will be excluded

1.通过将其转换为TreeSet和SortedSet并使用Set.subSet(INDEX_START,INDEX_END) ...这种方式将对集合进行排序

Set<String> hashSet = new HashSet<>();
SortedSet<String> sortedHashSet= new TreeSet<>(hashSet);
Set<String> subSet_1 = sortedHashSet.subSet(INDEX_START,INDEX_END);
//INDEX_END will be excluded

迭代整个集合，并将前2000个元素添加到第一个新集合，将后2000个元素添加到第二个新集合，等等。