简单总结

默认情况下：Java实现Comparator排序是升序，即自然排序

根据参数，返回值来判断是否交换

对于a，b两个参数（a在前，b在后）

jdk官方的升序基于：

< return -1
> return 1
= return 0

降序就是反过来

< return 1
> return -1
= return 0

底层源码的实现可参考：java comparator 升序、降序、倒序从源码角度理解

如果要升序：那么a<b就是想要的顺序，所以return -1 ，false，不交换。

如果要降序：那么a<b就是不想要的顺序，所以return 1，true，要交换。

为了方便记忆，总结了如下的规律：

  1. 当不管大于、小于、等于时，我们都返回 -1，那么就是倒序。
  2. 当不管大于、小于、等于时，我们都返回0或者1时，效果是一样的，就是不排序。但是0表示的是，相同元素不排序，要是我们把等于返回为-1，那么两个相同的元素会交互顺序；
  3. 当需要返回-1、1、0时，返回1的时候进行位置交换。

升序

ArrayList< Integer > list = new ArrayList<>();
list.add(2);
list.add(1);
list.add(3);
list.add(4);
list.add(8);
list.add(8);
list.sort(new Comparator< Integer >() {
    @Override
    public int compare(Integer o1, Integer o2) {
        // 升序 返回1的时候进行位置交换
        if (o1 < o2) {
            return -1;
        } else if (o1 > o2) {
            return 1;
        } else {
            return 0;
        }
    }
});
System.out.print("排序后 = ");
for (int i = 0; i < list.size(); i++) {
    Integer integer = list.get(i);
    System.out.print(integer);
    if (i != list.size() - 1) {
        System.out.print("、");
    }
}
// 结果
// 排序后 = 1、2、3、4、8、8

降序

ArrayList< Integer > list = new ArrayList<>();
list.add(2);
list.add(1);
list.add(3);
list.add(4);
list.add(8);
list.add(8);
list.sort(new Comparator< Integer >() {
    @Override
    public int compare(Integer o1, Integer o2) {
        // 降序 返回1的时候进行位置交换
        if (o1 > o2) {
            return -1;
        } else if (o1 < o2) {
            return 1;
        } else {
            return 0;
        }
    }
});
System.out.print("排序后 = ");
for (int i = 0; i < list.size(); i++) {
    Integer integer = list.get(i);
    System.out.print(integer);
    if (i != list.size() - 1) {
        System.out.print("、");
    }
}
// 结果
// 排序后 = 8、8、4、3、1、2

倒序

ArrayList< Integer > list = new ArrayList<>();
list.add(2);
list.add(1);
list.add(3);
list.add(4);
list.add(8);
list.add(8);
list.sort(new Comparator< Integer >() {
    @Override
    public int compare(Integer o1, Integer o2) {
        //不管大于、小于和等于 都返回 -1
        return -1;
    }
});
System.out.print("排序后 = ");
for (int i = 0; i < list.size(); i++) {
    Integer integer = list.get(i);
    System.out.print(integer);
    if (i != list.size() - 1) {
        System.out.print("、");
    }
}
// 结果
// 排序后 = 8、8、4、3、1、2

不变

假设不管大于、小于、等于，我们都返回0 ，会发现顺序没有变；而且你会发现，要是都返回1的话，顺序也是没有变的！

当不管大于、小于、等于时，我们都返回一个值时，0和1效果是一样的，就是不排序；-1就是倒序。

ArrayList< Integer > list = new ArrayList<>();
list.add(2);
list.add(1);
list.add(3);
list.add(4);
list.add(8);
list.add(8);
list.sort(new Comparator< Integer >() {
    @Override
    public int compare(Integer o1, Integer o2) {
        // 返回0或者1的时候不排序
        return 1;
    }
});
System.out.print("排序后 = ");
for (int i = 0; i < list.size(); i++) {
    Integer integer = list.get(i);
    System.out.print(integer);
    if (i != list.size() - 1) {
        System.out.print("、");
    }
}
// 结果
// 排序后 = 2、1、3、4、8、8

其实0表示的是，相同元素不排序，要是我们把等于返回为-1，那么两个相同的元素会交互顺序；

对数字而言交换顺序没有关系，但是里面要是是Map对象的话，那就有关系，因为有时我们是希望相同元素不进行顺序调整的。

代码链接：ComparatorDemo