Как отсортировать список TreeSets с потоками java8

Ответ Юджина сладкий, потому что гуава сладкая. Но если у вас нет Guava в вашем пути к классам, вот еще один способ:

List<Set<Integer>> list = block.stream()
    .flatMap(Set::stream)
    .sorted()
    .collect(partitioning(3));

Сначала я объединяю все наборы в один поток, затем сортирую все элементы и, наконец, собираю весь отсортированный поток в список наборов. Для этого я вызываю вспомогательный метод, который использует пользовательский сборщик:

private static <T> Collector<T, ?, List<Set<T>>> partitioning(int size) {
    class Acc {
        int count = 0;
        List<Set<T>> list = new ArrayList<>();

        void add(T elem) {
            int index = count++ / size;
            if (index == list.size()) list.add(new LinkedHashSet<>());
            list.get(index).add(elem);
        }

        Acc merge(Acc another) {
            another.list.stream().flatMap(Set::stream).forEach(this::add);
            return this;
        }
    }
    return Collector.of(Acc::new, Acc::add, Acc::merge, acc -> acc.list);
}

Метод получает размер каждого раздела и использует локальный класс Acc в качестве изменяемой структуры, которую будет использовать сборщик. Внутри класса Acc я использую List, который будет содержать LinkedHashSet экземпляров, в которых будут храниться элементы потока.

Класс Acc ведет подсчет всех уже собранных элементов. В методе add я вычисляю индекс списка и увеличиваю этот счетчик, а если набора в этой позиции списка не было, я добавляю к нему новый пустой LinkedHashSet. Затем я добавляю элемент в набор.

Поскольку я вызываю sorted() в потоке для сортировки его элементов перед сбором, мне нужно использовать структуры данных, которые сохраняют порядок вставки. Вот почему я использую ArrayList для внешнего списка и LinkedHashSet для внутренних наборов.

Метод merge должен использоваться параллельными потоками для объединения двух ранее накопленных экземпляров Acc. Я просто добавляю все элементы полученного экземпляра Acc в этот экземпляр Acc путем делегирования методу add.

Наконец, я использую Collector.of для создать сборщик на основе методов класса Acc. Последний аргумент — функция завершения, которая просто возвращает список экземпляров Acc.

Если у вас есть guava в пути к классам, это очень просто:

        block
            .stream()
            .flatMap(Set::stream)
            .collect(Collectors.toCollection(TreeSet::new));

    Iterable<List<Integer>> result = Iterables.partition(sorted, 3);

Добавление еще одного ответа, так как это будет больше, чем комментарий. Это действительно то, что сделал принятый ответ, но с «более умным» объединителем, которому не нужно снова и снова выполнять потоковую передачу.

 private static <T> Collector<T, ?, List<Set<T>>> partitioning(int size) {
    class Acc {
        int count = 0;

        List<List<T>> list = new ArrayList<>();

        void add(T elem) {
            int index = count++ / size;
            if (index == list.size()) {
                list.add(new ArrayList<>());
            }
            list.get(index).add(elem);
        }

        Acc merge(Acc right) {

            List<T> lastLeftList = list.get(list.size() - 1);
            List<T> firstRightList = right.list.get(0);
            int lastLeftSize = lastLeftList.size();
            int firstRightSize = firstRightList.size();

            // they have both the same size, simply addAll will work
            if (lastLeftSize + firstRightSize == 2 * size) {
                System.out.println("Perfect!");
                list.addAll(right.list);
                return this;
            }

            // last and first from each chunk are merged "perfectly"
            if (lastLeftSize + firstRightSize == size) {
                System.out.println("Almost perfect");
                int x = 0;
                while (x < firstRightSize) {
                    lastLeftList.add(firstRightList.remove(x));
                    --firstRightSize;
                }
                right.list.remove(0);
                list.addAll(right.list);
                return this;
            }

            right.list.stream().flatMap(List::stream).forEach(this::add);
            return this;
        }

        public List<Set<T>> finisher() {
            return list.stream().map(LinkedHashSet::new).collect(Collectors.toList());
        }

    }
    return Collector.of(Acc::new, Acc::add, Acc::merge, Acc::finisher);
}