如何在Java8中将映射转换为列表

如何在Java8中将

映射

转换为

列表

我编写了这个实现，但它没有效率

Map<String, Double> implicitDataSum = new ConcurrentHashMap<>();
//....
List<Pair<String, Double>> mostRelevantTitles = new ArrayList<>();
implicitDataSum.entrySet().stream().
                .sorted(Comparator.comparing(e -> -e.getValue()))
                .forEachOrdered(e -> mostRelevantTitles.add(new Pair<>(e.getKey(), e.getValue())));

return mostRelevantTitles;

Map implicitDataSum=new ConcurrentHashMap（）；
//....
List mostRelevantTitles=新建ArrayList（）；
implicitDataSum.entrySet（）.stream（）。
.sorted（Comparator.comparing（e->-e.getValue（）））
.forEachOrdered（e->mostRelevantTitles.add（新对（e.getKey（），e.getValue（）））；
返回大多数树标题；

---

我知道它应该使用

.collect（Collectors.someMethod（））

工作。但是我不知道怎么做。

好吧，你想收集

对

元素到

列表中。这意味着您需要将
流
映射到
流

这是通过以下操作完成的：

返回一个流，该流包含将给定函数应用于该流元素的结果

在这种情况下，该函数将是一个将
Map.Entry
转换为
对的函数

最后，您希望将其收集到
列表中
，以便我们可以使用内置收集器

List<Pair<String, Double>> mostRelevantTitles = 
    implicitDataSum.entrySet()
                   .stream()
                   .sorted(Comparator.comparing(e -> -e.getValue()))
                   .map(e -> new Pair<>(e.getKey(), e.getValue()))
                   .collect(Collectors.toList());

列出mostRelevantTitles=
implicitDataSum.entrySet（）
.stream（）
.sorted（Comparator.comparing（e->-e.getValue（）））
.map（e->新对（e.getKey（），e.getValue（））
.collect（Collectors.toList（））；

<>请注意，可以替换比较器<代码>比较器。比较（E->-GETValueE（））<代码> > <代码>映射>条目。比较ByValk（比较器，RealSeq（））< /C> > /P> < P>注意，如果你想要高效实现，你应该考虑这一点：

List<Pair<String, Double>> mostRelevantTitles = 
    implicitDataSum.entrySet()
                   .stream()
                   .map(e -> new Pair<>(e.getKey(), e.getValue()))
                   .collect(Collectors.toList());
mostRelevantTitles.sort(Comparators.comparing(Pair::getSecond, Comparator.reverseOrder()));

列出mostRelevantTitles=
implicitDataSum.entrySet（）
.stream（）
.map（e->新对（e.getKey（），e.getValue（））
.collect（Collectors.toList（））；
排序（Comparators.comparing（Pair:：getSecond，Comparator.reverseOrder（））；

我假设您的
对
类具有
getSecond
getter

使用
sorted（）。我的方法虽然功能不太强大，但直接将数据存储到目标
ArrayList
，然后在不进行任何额外复制的情况下对其进行排序。因此，我的解决方案将花费更少的时间和中间内存。
公共列表过程（最终地图聚合地图）{
    public List<TeamResult> process(final Map<String, Team> aggregatedMap) {
   return aggregatedMap.entrySet()
                       .stream()
                       .map(e -> new TeamResult(e.getKey(),e.getValue()))
                       .collect(Collectors.toList());
    }

返回aggregatedMap.entrySet（）
.stream（）
.map（e->newteamresult（e.getKey（），e.getValue（））
.collect（Collectors.toList（））；
}
根据值按相反顺序对地图进行排序，收集列表中的键，并仅限制列表中的前2个结果

    List<String> list = map.keySet().stream()
                .sorted((k1, k2)->map.get(k2)- map.get(k1))
                .limit(2)
                .collect(Collectors.toList())

List List=map.keySet（）.stream（）
.sorted（（k1，k2）->map.get（k2）-map.get（k1））
.限额（2）
.collect（收集器.toList（））
请注意，
-e.getValue（）
不会对NAN重新排序。正向顺序假定列表末尾有
Double.NaN
值。使用一元负号可以还原除NaN之外的所有内容：NaN仍然位于列表的末尾。是的，
Map.Entry.comparingByValue（Comparator.reverseOrder（））
或
Collections.reverseOrder（Map.Entry.comparingByValue（））
。如果打算比较负值，则应首选Comparator.comparingDouble，以避免重新启动值。