Java 将升序排序更改为降序排序

我有下面的代码对列表进行排序，但我需要将其设置为降序排序

List list = new LinkedList(thismap.entrySet());
Collections.sort(list, new Comparator() {
    public int compare(Object o1, Object o2) {
        return ((Comparable) ((Map.Entry) (o2)).getValue())
                .compareTo(((Map.Entry) (o1)).getValue());
    }
});

Map output = new LinkedHashMap();
for (Iterator it = list.iterator(); it.hasNext();) {
    Map.Entry entry = (Map.Entry) it.next();
    output.put(entry.getKey(), entry.getValue());
}

---

所有这些都是关于更改以下方法的内容：

public int compare(Object o1, Object o2) 
{
    return ((Comparable) ((Map.Entry) (o2)).getValue())
           .compareTo(((Map.Entry) (o1)).getValue());
}

返回与下面语句的值不同的结果：

((Comparable)((Map.Entry)(o2)).getValue()).compareTo(((Map.Entry)(o1)).getValue());

假设上面的语句被分配给x。如果x<0，则应返回1， 如果x>0，则返回-1；如果x==0，则返回0，就在

compare（）方法的内部

因此，您的方法可以如下所示：

public int compare(Object o1, Object o2) 
{
   int x = ((Comparable)((Map.Entry)(o2)).getValue())
             .compareTo(((Map.Entry)(o1)).getValue());
   if(x > 0)
     return -1;
   else if (x < 0)
     return 1;

   return 0;
}

public int比较（对象o1，对象o2）
{
intx=（（可比）（（Map.Entry）（o2））.getValue（）
.compareTo（（（Map.Entry）（o1））.getValue（）；
如果（x>0）
返回-1；
else如果（x<0）
返回1；
返回0；
}
所有这些都是关于更改以下方法的内容：

public int compare(Object o1, Object o2) 
{
    return ((Comparable) ((Map.Entry) (o2)).getValue())
           .compareTo(((Map.Entry) (o1)).getValue());
}

返回与下面语句的值不同的结果：

((Comparable)((Map.Entry)(o2)).getValue()).compareTo(((Map.Entry)(o1)).getValue());

假设上面的语句被分配给x。如果x<0，则应返回1，
如果x>0，则返回-1；如果x==0，则返回0，就在
compare（）方法的内部

因此，您的方法可以如下所示：

public int compare(Object o1, Object o2) 
{
   int x = ((Comparable)((Map.Entry)(o2)).getValue())
             .compareTo(((Map.Entry)(o1)).getValue());
   if(x > 0)
     return -1;
   else if (x < 0)
     return 1;

   return 0;
}

public int比较（对象o1，对象o2）
{
intx=（（可比）（（Map.Entry）（o2））.getValue（）
.compareTo（（（Map.Entry）（o1））.getValue（）；
如果（x>0）
返回-1；
else如果（x<0）
返回1；
返回0；
}
一种常见的通用技术是通过简单地交换参数，将比较器封装在反向比较器中

class ReverseComparator<T> implements Comparator<T> {

    private final Comparator target;

    public ReverseComparator(Comparator<T> target) {
        super();
        this.target = target;
    }

    public int compare(T first, T second) {
        return target.compare(second, first);
    } 
}

一种常见的通用技术是通过简单地交换参数将比较器封装在反向比较器中

class ReverseComparator<T> implements Comparator<T> {

    private final Comparator target;

    public ReverseComparator(Comparator<T> target) {
        super();
        this.target = target;
    }

    public int compare(T first, T second) {
        return target.compare(second, first);
    } 
}

简单的通用答案是使用
java.util.Collections.reverseOrder（Comparator）

或者，具体的解决方案是翻转比较方法中的参数：

Comparator myReverseComparator = new Comparator() {
    public int compare(Object o2, Object o1) {  // <== NOTE - params reversed!!
    return ((Comparable) ((Map.Entry) (o2)).getValue())
        .compareTo(((Map.Entry) (o1)).getValue());
    }
}

Comparator myReverseComparator=新的比较器（）{
公共int比较（objecto2，objecto1）{/简单的一般答案是使用
java.util.Collections.reverseOrder（Comparator）

或者，具体的解决方案是翻转比较方法中的参数：

Comparator myReverseComparator = new Comparator() {
    public int compare(Object o2, Object o1) {  // <== NOTE - params reversed!!
    return ((Comparable) ((Map.Entry) (o2)).getValue())
        .compareTo(((Map.Entry) (o1)).getValue());
    }
}

Comparator myReverseComparator=新的比较器（）{
public int compare（Object o2，Object o1）{//只要在
compare
中翻转参数，其余的代码就可以保持相同。只要在
compare
中翻转参数，其余的代码就可以保持相同。为什么不直接使用
java.util.Collections.reverseOrder（Comparator）
而不是滚动您自己的
反向比较器
类？@StephenC感谢您用-1捕获边缘条件。它已从我的响应中删除。为什么不直接使用
java.util.Collections.reverseOrder（Comparator）
而不是滚动您自己的
反向比较器
类？@StephenC感谢您用-1捕捉到边缘条件。它已从我的响应中删除。