先说 Comparator 接口，这个理解了，下一个就理解了

一、Comparator 的用法(暂不考虑0，因为0不处理)

返回-1，1交换不交换位置，如果撇开比较器的两个参数和jdk默认顺序来说，存粹是错误的

接口如下：原文链接

public interface Comparator<T> {

    int compare(T o1, T o2);
}

现提出如下标准：

• 标准1：jdk 默认要升序排列，即程序排序规则是 asc ,升序排列
• 标准2：Comparator 接口第一个参数 o1 是第二个参数 o2 后面的对象

基于这 2 个标准，假设:

• 1 = true
• -1 = false

重点来了，有以下两种情况和处理方式:

• 情况1：后面的比前面大，即 o1 > o2 ，是 标准1中的 升序 吗？是，返回 true，不交换前后位置。
• 情况2：后面的比前面小，即 o1 < o2 ，是 标准1中的 升序 吗？不是，返回 false, 交换前后位置。

问：为什么第二种降序要交换前后位置？
答：因为 标准1 ，默认要对数组进行升序排列，如果发现降序的序列，自然要交换位置

扩散问题1：如果我想按降序排列呢？
答：那你就在升序时候返回 false，降序时候返回 true 就行

扩散问题2：如果我不比较，直接返回1或者-1呢？
答：因为标准1，返回1(true)代表都是升序，自然不必交换，返回-1(false)代表都不是升序，都要交换，即数组反转

总结：

想要升序排列，如果比较器2个参数是升序排列，就返回true，否则返回false即可
想要降序排列，如果比较器2个参数是降序排列，就返回true，否则返回false即可

附测试代码：

public class ComparatorDemo {

    private final int local;

    public ComparatorDemo(int local) {
        this.local = local;
    }

    @Override
    public String toString() {
        return "" + local;
    }

    public static void main(String[] args) {
        List<ComparatorDemo> asc = new ArrayList<>();

        asc.add(new ComparatorDemo(13));
        asc.add(new ComparatorDemo(3));
        asc.add(new ComparatorDemo(15));
        asc.add(new ComparatorDemo(18));

        // 我想升序排列
        asc.sort((second,first) -> {
            if(second.local > first.local){
                return 1; //是升序，返回true
            }else if(second.local < first.local){
                return -1; //是降序，返回false
            }else {
                return 0;
            }
        });

        System.out.print("升序数组：");
        System.out.println(asc);

        List<ComparatorDemo> desc = new ArrayList<>();

        desc.add(new ComparatorDemo(13));
        desc.add(new ComparatorDemo(3));
        desc.add(new ComparatorDemo(15));
        desc.add(new ComparatorDemo(18));

        // 我想降序排列
        desc.sort((o1,o2) -> {
            if(o1.local > o2.local){
                return -1; //不是降序，返回false
            }else if(o1.local < o2.local){
                return 1; //是降序，返回true
            }else {
                return 0;
            }
        });

        System.out.print("降序数组：");
        System.out.println(desc);
    }

}

二、Comparable 的用法(暂不考虑0，因为0不处理)

规则和 Comparator 一样，只需把当前 Comparable 实例当成Comparator#compare(T o1, T o2)第一个参数即可

测试代码：

public class ComparableImpl implements Comparable<ComparableImpl> {

    private final Integer local;

    public ComparableImpl(Integer num) {
        this.local = num;
    }

    @Override
    public String toString() {
        return "" + local;
    }

    @Override
    public int compareTo(ComparableImpl before) {
        if (local > before.local) {
            return 1; //是升序
        } else if (local < before.local) {
            return -1; //是降序
        }
        return 0;
    }

    public static void main(String[] args) {
        ComparableImpl[] ables = new ComparableImpl[]{
                new ComparableImpl(1),
                new ComparableImpl(13),
                new ComparableImpl(25),
                new ComparableImpl(4),
        };

        Arrays.sort(ables);

        System.out.println(Arrays.toString(ables));
    }

}