使用lambdas (Java8)，并将其分解到最基本的语法(JVM将在这种情况下推断大量的语法)，你会得到:

Collections.sort(testList, (a, b) -> b.compareTo(a));

更详细的版本:

// Implement a reverse-order Comparator by lambda function
Comparator<Double> comp = (Double a, Double b) -> {
    return b.compareTo(a);
};

Collections.sort(testList, comp);

使用lambda是可能的，因为Comparator接口只有一个方法要实现，因此VM可以推断正在实现哪个方法。由于参数的类型可以推断，所以不需要声明(即(a, b)而不是(Double a, Double b)。并且由于lambda体只有一行，并且该方法被期望返回一个值，因此返回值是推断出来的，不需要花括号。

//Here is sorted List alphabetically with syncronized

package com.mnas.technology.automation.utility;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;

import org.apache.log4j.Logger;

/**
 * @author manoj.kumar
 */
public class SynchronizedArrayList {
    static Logger log = Logger.getLogger(SynchronizedArrayList.class.getName());

    @SuppressWarnings("unchecked")
    public static void main(String[] args) {

        List<Employee> synchronizedList = Collections.synchronizedList(new ArrayList<Employee>());
        synchronizedList.add(new Employee("Aditya"));
        synchronizedList.add(new Employee("Siddharth"));
        synchronizedList.add(new Employee("Manoj"));
        Collections.sort(synchronizedList, new Comparator() {
            public int compare(Object synchronizedListOne, Object synchronizedListTwo) {
                //use instanceof to verify the references are indeed of the type in question
                return ((Employee) synchronizedListOne).name
                        .compareTo(((Employee) synchronizedListTwo).name);
            }
        }); 
    /*for( Employee sd : synchronizedList) {
    log.info("Sorted Synchronized Array List..."+sd.name);
    }*/

        // when iterating over a synchronized list, we need to synchronize access to the synchronized list
        synchronized (synchronizedList) {
            Iterator<Employee> iterator = synchronizedList.iterator();
            while (iterator.hasNext()) {
                log.info("Sorted Synchronized Array List Items: " + iterator.next().name);
            }
        }

    }
}

class Employee {
    String name;

    Employee(String name) {
        this.name = name;

    }
}

在JAVA 8中，现在变得简单多了。

List<String> alphaNumbers = Arrays.asList("one", "two", "three", "four");
List<String> alphaNumbersUpperCase = alphaNumbers.stream()
    .map(String::toUpperCase)
    .sorted()
    .collect(Collectors.toList());
System.out.println(alphaNumbersUpperCase); // [FOUR, ONE, THREE, TWO]

——反过来用这个

.sorted(Comparator.reverseOrder())

  yearList = arrayListOf()
    for (year in 1950 until 2021) {
        yearList.add(year)
    }

   yearList.reverse()
    val list: ArrayList<String> = arrayListOf()

    for (year in yearList) {
        list.add(year.toString())
    }

集合。sort允许您传递一个定义排序逻辑的Comparator实例。因此，我们可以简单地传递Collections.reverseOrder()来排序，而不是按自然顺序对列表进行排序，然后反转它:

// import java.util.Collections;
Collections.sort(testList, Collections.reverseOrder());

正如@Marco13所提到的，除了更习惯(可能更有效)，使用倒序比较器可以确保排序是稳定的(这意味着当元素的顺序根据比较器相等时，它们的顺序不会改变，而倒序将改变顺序)

使用java.util.Collections类的util方法，即

Collections.sort(list)

事实上，如果你想排序自定义对象你可以使用

Collections.sort(List<T> list, Comparator<? super T> c) 

参见集合API