Question

作为输入，我有对象列表，每个对象都有名称和地图：

1)
  Name: m1

  Map: {"c1": 3,
 "c2": 24
 "c3": 12}

2) Name: m2

Map: {"c1": "A",
 "c2": "B",
 "c3": "C"}

3) Name: m3

Map: {"c1": 3.4,
 "c2": 4.6,
 "c3": 12.3}

我需要作为输出，我需要根据地图中名称为m1 的值对所有3个地图进行排序。

首先，我想按降序排列值对象＃1（ m1 ）的地图进行排序（我可以在这里使用LinedHashMap）：

{"c1": 3, "c2": 24, "c3": 12}  =>  {"c2": 24, "c3": 12, "c1": 3}

现在，我想要对象＃2的地图元素和对象＃3的地图，也要按相同的键顺序排序 - C2，C3，C1。所以基本上我想要重新排序2个映射，以便顺序为C2，C3，C1（与 m1 中的顺序相同）， NOT C1，C2，C3。

我怎样才能以最优雅的方式做到这一点？我有一些解决方案 - 但它们很混乱，还有很多额外的步骤。

如果重要：此列表将始终只有3个对象。 Map中的元素数量可以不同，但地图中的键在3个地图中始终相同

Answer 1

所以你知道如何按值排序Map，也许通过阅读这个答案：Sort a Map by values (Java)，答案的Java 8版本是：

m1sorted = m1.entrySet()
             .stream()
             .sorted(Map.Entry.comparingByValue(Collections.reverseOrder()))
             .collect(Collectors.toMap(
               Map.Entry::getKey,
               Map.Entry::getValue,
               (e1, e2) -> e1,
               LinkedHashMap::new
             ));

那么如何按m2的值对m3和m1进行排序？

简单：您提供Comparator到sorted()比较值，例如

.sorted(Comparator.comparing(e -> m1.get(e.getKey())).reversed())

您可能必须明确指定e的类型，因为推理引擎可能会丢失：comparing((Entry<String, String> e) ->

如果您不喜欢Comparator.comparing()和reversed()以及推理问题，您可以使用lambda。

以下是所有代码，作为概念证明：

Map<String, Integer> m1 = new HashMap<>();
m1.put("c1", 3);
m1.put("c2", 24);
m1.put("c3", 12);

Map<String, String> m2 = new HashMap<>();
m2.put("c1", "A");
m2.put("c2", "B");
m2.put("c3", "C");

Map<String, Double> m3 = new HashMap<>();
m3.put("c1", 3.4);
m3.put("c2", 4.6);
m3.put("c3", 12.3);

Map<String, Integer> m1s =
        m1.entrySet()
          .stream()
          .sorted((e1, e2) -> Integer.compare(e2.getValue(), e1.getValue()))
          .collect(Collectors.toMap(Map.Entry::getKey,
                                    Map.Entry::getValue,
                                    (e1, e2) -> e1,
                                    LinkedHashMap::new));

Map<String, String> m2s =
        m2.entrySet()
          .stream()
          .sorted((e1, e2) -> Integer.compare(m1.get(e2.getKey()), m1.get(e1.getKey())))
          .collect(Collectors.toMap(Map.Entry::getKey,
                                    Map.Entry::getValue,
                                    (e1, e2) -> e1,
                                    LinkedHashMap::new));

Map<String, Double> m3s =
        m3.entrySet()
          .stream()
          .sorted((e1, e2) -> Integer.compare(m1.get(e2.getKey()), m1.get(e1.getKey())))
          .collect(Collectors.toMap(Map.Entry::getKey,
                                    Map.Entry::getValue,
                                    (e1, e2) -> e1,
                                    LinkedHashMap::new));

System.out.println(m1s);
System.out.println(m2s);
System.out.println(m3s);

输出

{c2=24, c3=12, c1=3}
{c2=B, c3=C, c1=A}
{c2=4.6, c3=12.3, c1=3.4}

注意如何在lambdas中反转e2和e1以导致降序。

当然，使用Java的面向对象的功能并且只有一个Map对于具有三个值的字段的对象会更好。

根据另一个地图

1 个答案: