集合排序，看这篇就够了

分手后的思念是犯贱 2022-02-03 07:09 292阅读 0赞

### **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为第二个元素）。 ###