如何为 Map.Entry 中的 Map 值编写 java 8 Comparator

Question

这是我所拥有的，我想对条目中的值进行降序排序。

Map<String, Outer> outer = Input
                          .entrySet()
                          .stream
                          .collect(toMap(Map.Entry::getKey, entry->{
                           List<Outer> inner = entry
                                    .getValue()
                                    .stream()
                                    .sorted(Comparator.comparingDouble(???))
                              })) ... (more lines of code.)

如何编写带排序的比较器。 如果想在 sorted 里面做如下操作

if (o1.getSomething() > o2.getSomething())
     return -1;
if (o1.getSomething() < o2.getSomething())
     return 1;
return 0;

获得列表并对其进行排序后，它对我有用。

inner.sort((Outer o1, Outer o2) -> {
if (o1.getSomething() > o2.getSomething())
         return -1;
    if (o1.getSomething() < o2.getSomething())
         return 1;
    return 0;
});

但是有没有办法在 entry 中使用 stream.sorted("在这里使用相同的比较器逻辑")。

Entry 是一个 ArrayList，有一堆值。

entry:[{w:1},{w:2},{w:3},{w:4}];

所以我想对此进行反向排序，如下所示：

entry:[{w:4},{w:3},{w:2},{w:1}];

所以我得到的最终列表是按相反顺序排序的。

抱歉造成混乱。

Answer 1

您可以定义Comparator，然后将stream.sorted() 与内联cmets 一起使用，如下所示：

//Define comparator Lamda exp for Outer class
Comparator<Outer> outerComparator = (o1, o2) -> {
         if (o1.getValue() > o2.getValue())
                return -1;
          else if (o1.getValue() < o2.getValue())
                return 1;
            else 
              return 0;
   };


Map<String, Outer> output = Input.entrySet(). //get elements
        stream(). //get elements
        sorted( //sort elements by passsing outerComparator
        Map.Entry.<String, Outer>comparingByValue(outerComparator)
        .reversed())//reverse for descending order
        .collect(Collectors.toMap(Map.Entry::getKey, 
        Map.Entry::getValue));//collect to Map object

Answer 2

如果您只是想获取Map 的值并将它们放入已排序的List，您可以执行以下操作：

Map<String, Element> elMap = new HashMap<>();
elMap.put("3", new Element("3"));
elMap.put("2", new Element("2"));
elMap.put("1", new Element("1"));

List<Element> elList = elMap.values()
        .stream()
        .sorted((e1, e2) -> {
            return e1.getSortField().compareTo(e2.getSortField());
        })
        .collect(Collectors.toList());
System.out.println(elList);

在这里，Element 是一个简单的 POJO，其中包含一个名为 sortField 的 String 字段。 sorted() 采用 Comparator。这是一个带有 2 个参数和一个 int 返回类型的功能接口。对于给定的 lambda，这没问题。

你也可以让你的元素实现Comparable。然后你可以这样做：

List<Element> elList = elMap.values()
        .stream()
        .sorted()
        .collect(Collectors.toList());

元素实现正确的接口

static class Element implements Comparable<Element> {
    //Constructor, field, getters
    @Override
    public int compareTo(Element o) {
        return this.sortField.compareTo(o.sortField);
    }
}

编辑：

它是地图中的一个列表，我正在尝试对其进行排序。并尝试在链中对其进行排序。

这可以解释为：

Map<String, List<Element>> collected = elMap.entrySet()
        .stream()
        .peek(entry -> System.out.println("Performing arbitrary Map operations"))
        .collect(Collectors.toMap(Map.Entry::getKey, entry -> {
            return entry.getValue()
                    .stream()
                    .sorted(Comparator.comparingDouble(Element::getWeight))
                    .collect(Collectors.toList());
        }));

collected.entrySet()
        .forEach(entry -> {
            System.out.println(entry.getKey() + " : " + entry.getValue());
        });

您通过 'Map.entrySet()' 流式传输并使用它做任何您想做的事情。根据您的问题将其收集回不同的Map 时，您可以使用上面的示例再次流式传输和收集您的List。

Answer 3

据我所知，您的问题实际上只是如何创建一个排序列表作为地图中的值，并根据 getSomething 的返回进行排序。

entry.getValue().stream()
    .sorted(Comparator.comparing(Outer::getSomething))
    .collect(toList())

将返回根据getSomething 排序的列表。如果该方法返回一个双精度值，那么您可以使用 comparingDouble(Outer::getSomething) 来避免对值进行装箱。

Answer 4

如果我猜对了，您想根据给定的比较器对所有值（列表）进行排序。

如果是这种情况，您根本不需要创建流。使用Map 的replaceAll 方法就足够了：

// Orders Outer elements according to Outer's getSomething method 
// in descendant order (assumes getSomething returns a double value)
Comparator<Outer> yourComparator = 
    Comparator.comparingDouble(Outer::getSomething).reversed();

yourMap.replaceAll((k, v) -> {
        Collections.sort(v, yourComparator);
        return v;
    });

这利用了Collections.sort 方法，它接受一个列表和一个比较器。

Answer 5

所以这是对我有用的答案。

.sorted(reverseOrder(comparingDouble(Input::getSomething)))

谢谢大家，