在java 8中将哈希映射拆分为分区[重复]

Question

我有hashmap：Map

我想把它分成包含< code>Map的列表:

List<Map<String,Set<String>>> listofMaps;

，每个地图最多 100 个键。我知道如何以常规方式做到这一点。（在条目集上，每 100 个项目创建新地图）。有没有选择使用 java 8 lambda 或其他东西来做到这一点？（类似于 Lists.partitions（） ..）?

Answer 1

将流分割成有序的固定大小的块(如在< code>Lists.partition中)是不可能的，因为在并行执行中，每个块都必须等待其左边的空间块被完全处理。

但是，如果您不关心生成的子映射中键的顺序（因为它是由 Map#iterator 的方法返回的），那么您可以滚动自定义收集器。

private static <K, V> Collector<Map.Entry<K, V>, ?, List<Map<K, V>>> mapSize(int limit) {
    return Collector.of(ArrayList::new,
            (l, e) -> {
                if (l.isEmpty() || l.get(l.size() - 1).size() == limit) {
                    l.add(new HashMap<>());
                }
                l.get(l.size() - 1).put(e.getKey(), e.getValue());
            },
            (l1, l2) -> {
                if (l1.isEmpty()) {
                    return l2;
                }
                if (l2.isEmpty()) {
                    return l1;
                }
                if (l1.get(l1.size() - 1).size() < limit) {
                    Map<K, V> map = l1.get(l1.size() - 1);
                    ListIterator<Map<K, V>> mapsIte = l2.listIterator(l2.size());
                    while (mapsIte.hasPrevious() && map.size() < limit) {
                        Iterator<Map.Entry<K, V>> ite = mapsIte.previous().entrySet().iterator();
                        while (ite.hasNext() && map.size() < limit) {
                            Map.Entry<K, V> entry = ite.next();
                            map.put(entry.getKey(), entry.getValue());
                            ite.remove();
                        }
                        if (!ite.hasNext()) {
                            mapsIte.remove();
                        }
                    }
                }
                l1.addAll(l2);
                return l1;
            }
    );
}

这个将地图条目作为值并将它们放入列表中

累加器，检查当前列表是否为空或最后一张地图的大小是否达到限制。如果是这种情况，它会添加一个新地图。然后将处理的当前条目中的新映射添加到地图中。

合并器需要合并两个并行构建的列表。如果其中一个列表为空，则返回另一个。如果不是这样，您需要检查第一个列表的最后一个映射是否具有所需的元素数量。如果不是这样，我们获取第二个列表的最后一个映射，并向第一个列表的最后一个映射添加元素。如果达到了限制或者第二个列表中没有更多元素要添加，它就会停止。如果空地图的所有元素都被消耗掉了，不要忘记移除它。

这种收集器的一种用法是：

List<Map<String, Set<String>>> listofMaps =
                myMap.entrySet().stream().collect(mapSize(2));

一些示例（具有并行和顺序流）的初始映射由 13 个键值映射组成：

Size of maps 2
{11=[11a, 11b], 12=[12a, 12b]}
{13=[13b, 13a], 8=[8a, 8b]}
{1=[1a, 1b], 2=[2b, 2a]}
{3=[3a, 3b], 6=[6a, 6b]}
{4=[4a, 4b], 5=[5a, 5b]}
{7=[7a, 7b], 10=[10a, 10b]}
{9=[9a, 9b]}
=============================
Size of maps 5
{11=[11a, 11b], 12=[12a, 12b], 13=[13b, 13a], 6=[6a, 6b], 7=[7a, 7b]}
{1=[1a, 1b], 2=[2b, 2a], 3=[3a, 3b], 4=[4a, 4b], 5=[5a, 5b]}
{8=[8a, 8b], 9=[9a, 9b], 10=[10a, 10b]}
=============================
Size of maps 12
{11=[11a, 11b], 12=[12a, 12b], 1=[1a, 1b], 13=[13b, 13a], 2=[2b, 2a], 3=[3a, 3b], 4=[4a, 4b], 5=[5a, 5b], 6=[6a, 6b], 7=[7a, 7b], 8=[8a, 8b], 9=[9a, 9b]}
{10=[10a, 10b]}
=============================
Size of maps 15
{11=[11a, 11b], 12=[12a, 12b], 13=[13b, 13a], 1=[1a, 1b], 2=[2b, 2a], 3=[3a, 3b], 4=[4a, 4b], 5=[5a, 5b], 6=[6a, 6b], 7=[7a, 7b], 8=[8a, 8b], 9=[9a, 9b], 10=[10a, 10b]}

我没有广泛测试过它。另外，我认为您可以对其进行修改，使其更加通用。

例如，您可以接受任意对象，并使用两个函数为您正在处理的每个实例生成一个键和一个值。

private static <T, K, V> Collector<T, ?, List<Map<K, V>>> mapSize(Function<T, K> keyFunc, Function<T, V> mapFunc, int limit) {

与

l.get(l.size() - 1).put(keyFunc.apply(e), mapFunc.apply(e));

并称之为：

.collect(mapSize(Map.Entry::getKey, Map.Entry::getValue, size));

Answer 2

使用我的unorderedBatch（）收集器从这个答案：

Collector<Entry<String, Set<String>>, ?, List<Map<String, Set<String>>>> batchesCollector = 
    unorderedBatches(100, 
        Collectors.toMap(Entry::getKey, Entry::getValue), Collectors.toList());
List<Map<String, Set<String>>> listofMaps = myMap.entrySet().stream()
        .collect(batchesCollector);