集合排序，看这篇就够了

Comparator接口中的compare方法用来对集合排序时，需要注意排序的结果是升序排序还是降序排序，话不多说，上代码

1.第一种情况：

/**
 * @Author: guandezhi
 * @Date: 2019/5/9 10:11
 */
public class ComparatorDemo {

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(6);
        list.add(5);
        list.add(7);
        list.add(8);
        list.add(4);

        //第一种情况
        Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                if (o1 < o2) {
                    return -1;
                } else if (o1 > o2) {
                    return 1;
                } else {
                    return 0;
                }
            }
        });

        System.out.println("第一种情况排序结果：" + JSONObject.toJSONString(list));

        //第二种情况
        Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                if (o1 < o2) {
                    return 1;
                } else if (o1 > o2) {
                    return -1;
                } else {
                    return 0;
                }
            }
        });

        System.out.println("第二种情况排序结果：" + JSONObject.toJSONString(list));

        //第三种情况
        Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                if (o1 > o2) {
                    return -1;
                } else if (o1 < o2) {
                    return 1;
                } else {
                    return 0;
                }
            }
        });

        System.out.println("第三种情况排序结果：" + JSONObject.toJSONString(list));

        //第四种情况
        Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                if (o1 > o2) {
                    return 1;
                } else if (o1 < o2) {
                    return -1;
                } else {
                    return 0;
                }
            }
        });
        System.out.println("第四种情况排序结果：" + JSONObject.toJSONString(list));
    }
}

 测试结果如下：

第一种情况排序结果：[1,2,4,5,6,7,8]
第二种情况排序结果：[8,7,6,5,4,2,1]
第三种情况排序结果：[8,7,6,5,4,2,1]
第四种情况排序结果：[1,2,4,5,6,7,8]

从以上结果可以看出，一、四为升序排序，二、三为降序排序。

2.第二种情况：

/**
 * @Author: guandezhi
 * @Date: 2019/5/8 18:16
 */
public class ComparatorTest {

    @Data
    @Builder
    static class User {
        private Integer id;
        private String mobile;
        private Integer age;
    }

    public static void main(String[] args) {
        List<User> users = new ArrayList<>();
        users.add(User.builder().age(10).build());
        users.add(User.builder().age(30).build());
        users.add(User.builder().age(20).build());

        System.out.println(JSONObject.toJSONString(users));

        Collections.sort(users, new Comparator<User>() {
            @Override
            public int compare(User o1, User o2) {
                //升序
                //return o1.getAge() - o2.getAge();
                //降序
                return o2.getAge() - o1.getAge();
            }
        });

        System.out.println(JSONObject.toJSONString(users));

        //Java8 Lambda 写法
        users.sort((User u1, User u2) -> u2.getAge() - u2.getAge());
    }

}

测试结果如下：

o1.getAge() - o2.getAge()为升序排序
o2.getAge() - o1.getAge()为降序排序

 compare原理分析（jdk默认规则）：假如比较的数为a,b

  1.如果return -1 此时a小于b,  a和b的位置不变, 即为升序排列。

  2.如果return 1 此时a大于b，需要交换a和b位置，即为降序排列。

  3.如果return 0 此时a等于b，a和b位置不变。

总结：

   1. 判断compare结果是升序排序还是降序排序，只与两个比较元素的差值有关。

   2.如果差值为-1，为升序排序，差值为1，为降序排序（a为第一个元素，b为第二个元素）。

   3.如果差值为-1，为降序排序，差值为1，为升序排序（b为第一个元素，a为第二个元素）。