将地图中的值转换为集合[关闭]

Question

我有一个字符串映射到字符串列表Map<String, List<String>>
这是从地图中的值创建 Set 的最有效方法吗？

for (List<String> localList : map.values()) {
    set.addAll(localList);
}

Answer 1

取决于“最有效的方式”是什么意思。

从性能的角度来看，您的代码是最高效的。

使用 Java 8 Streams 可以简化代码，但性能会有所下降，但在总体方案中不太可能引起注意，因此 Streams 可能“更高效”。

然而，这主要是一个意见问题。

为了比较，您的代码：

Set<String> set = new HashSet<>();
for (List<String> localList : map.values()) {
    set.addAll(localList);
}

与 Stream 版本相比：

Set<String> set = map.values().stream().flatMap(List::stream).collect(Collectors.toSet());

为了可读性可以写成：

Set<String> set = map.values()
                     .stream()
                     .flatMap(List::stream)
                     .collect(Collectors.toSet());

如果要控制Set的类型，把最后一部分改成：

                     .collect(Collectors.toCollection(TreeSet::new));

Answer 2

Set接口处，任何周边代码都一样

... other code ...
mySet.add(item);
... other code ...

性能影响来自您在调用中放置的用于将项目添加到集合中的循环类型。 （好吧，Set 的类型也很重要，但这是最容易改变的）。

一般Iterators慢一点，索引快一点；但这是一个概括。 “foreach”循环倾向于使用自动生成的迭代器方法，至少到 Java8。我没有调查过去的版本。具体细节，需要进行基准测试。

一般来说，流中使用的隐藏对象（收集器、生产者等）的额外开销也会导致更多的对象被处理，其中一些对象是处理环境的管道框架，推动项目通过流。同样，在我的基准测试（直到 Java8）中，这产生了显着影响，这主要是通过使用传统 C 风格 for 循环方法的直接索引来避免的。

现在要注意了

我只使用ArrayLists，因此我的性能在按索引拉出项目时会更快，这是完全合理的。我不知道您的列表中的具体类是什么。

另外，我没有将我的列表存储在 Map 中，所以在某种程度上，这在某种程度上取决于您用于地图的内容。

建议

要做出的选择太多，每个选择在一种或另一种情况下效果更好，才能真正事先了解这类信息。我强烈建议对此类列表的典型（但不同）地图进行一组基线测量，然后尝试重新运行您的基准测试的小改动。这是真正了解优化环境中性能影响的唯一方法。其他一切都只是猜测。

Answer 3

我假设您将性能作为最有效方式的关键。在这种情况下，简单的基准测试可以提供最佳答案。这是一个简单的 JMH 基准测试：

package test;

import org.openjdk.jmh.annotations.*;

import java.util.*;
import java.util.stream.Collectors;

public class ListOfStringsToSetBenchmark {

    public static void main(String[] args) throws Exception {
        org.openjdk.jmh.Main.main(args);
    }

    @Benchmark
    @Fork(value = 1, warmups = 1)
    @Measurement(iterations = 5)
    @Warmup(iterations = 3)
    @BenchmarkMode(Mode.Throughput)
    public void streams() {
        Map<String, List<String>> map = new HashMap<>();

        map.put("test", Arrays.asList("1", "2", "3"));
        map.put("test2", Arrays.asList("4", "5", "6"));
        map.put("test3", Arrays.asList("7", "8", "9"));

        Set<String> collect = map.values().stream().flatMap(Collection::stream).collect(Collectors.toSet());
    }

    @Benchmark
    @Fork(value = 1, warmups = 1)
    @Measurement(iterations = 5)
    @Warmup(iterations = 3)
    @BenchmarkMode(Mode.Throughput)
    public void parallelStreams() {
        Map<String, List<String>> map = new HashMap<>();

        map.put("test", Arrays.asList("1", "2", "3"));
        map.put("test2", Arrays.asList("4", "5", "6"));
        map.put("test3", Arrays.asList("7", "8", "9"));

        Set<String> collect = map.values().parallelStream().flatMap(Collection::parallelStream).collect(Collectors.toSet());
    }

    @Benchmark
    @Fork(value = 1, warmups = 1)
    @Measurement(iterations = 5)
    @Warmup(iterations = 3)
    @BenchmarkMode(Mode.Throughput)
    public void forEach() {
        Map<String, List<String>> map = new HashMap<>();

        map.put("test", Arrays.asList("1", "2", "3"));
        map.put("test2", Arrays.asList("4", "5", "6"));
        map.put("test3", Arrays.asList("7", "8", "9"));

        Set<String> set = new HashSet<>();

        for (List<String> localList : map.values()) {
            set.addAll(localList);
        }
    }
}

结果

Benchmark                              Mode  Cnt        Score        Error  Units
ListOfStringsToSetBenchmark.forEach          thrpt    5  5290023,805 ±  89846,320  ops/s
ListOfStringsToSetBenchmark.parallelStreams  thrpt    5   588714,960 ±   6289,819  ops/s
ListOfStringsToSetBenchmark.streams          thrpt    5  2940686,522 ± 359335,288  ops/s

注意：为了获得精确的结果，您需要增加迭代值。