如何在Map.Entry中为映射值编写java 8比较器

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.)

如何用排序编写比较器。如果想在排序后执行以下操作

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;
});

但是有没有办法在条目内使用stream.sorted（“在这里使用相同的比较器逻辑”）。

Entry是一个数组列表，有一堆值。

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

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

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

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

为混乱而哭泣。

Answer 1

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

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

将返回根据< code>getSomething排序的列表。如果该方法返回一个double，那么您可以使用< code > comparing double(Outer::get something)来避免对该值进行装箱。

Answer 2

如果您只是试图获取< code>Map的值，并将它们放入排序的< code>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);

在这里，元素是一个简单的POJO，有一个名为＜code＞sortField＜code＞的＜code＞字符串sorted（）接受一个比较器。这是一个具有2个参数和＜code＞int＜code＞返回类型的函数接口。这对于给定的λ是可以的。

您还可以让元素实现< code>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

您可以定义< code >比较器，然后使用< code>stream.sorted()，如下所示，带有行内注释:

//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