【Java】再看排序 —— 关于 Comparator 的用法

谈一个比较基础，又很常用的东西， Comparator 类，之前我写过一篇浅浅的关于这个的文章 ，今天再复盘一下这个问题，把它弄熟

ps: 本文中提供的代码，为了提高可读性都没用 lamdam 和 函数式编程 简化书写，大家平时用的时候，自己使用 IDEA 快捷键转化一下

一、 做什么

Comparator 类常作为 sorted() 方法的参数传递给 sorted 方法，用来解决给集合排序，自定义排序规则的问题 。

那从这个角度看，这个类肯定很常用了，因为我知道大家都不喜欢自己写排序方法，而且自己写的肯定还有性能优化问题，我们直接用 jdk 帮我们封装好的，就即简洁，又易于阅读 。

二、使用

1. 对 Array 数组类型进行排序

下面是 Arrays 类暴露给我们的排序方法 —— sorted

Stream<T> sorted(Comparator<? super T> comparator);

Comparator 接口暴露给我们以下方法给我们实现：

int compare(T o1, T o2);

（1）情况一 ： 直接 new Comparator 对象，然后实现其 compare 方法进行排序

这种情况可以在 compare 内部定义好排序规则，看起来非常直观，通过在 compare 中写好逻辑代码，可以实现多种排序规则 。

这种方式只能用于包装类型的数组，如果数组是基本数据类型，必须转成包装类才能使用实现 compare 方法进行定义排序

    public static void test(){
        // 对包装类型的数组进行排序
        Integer[] a = {1, 2, 3, 0};
        // 直接对 a 排序
        Arrays.sort(a, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        // 不对 a 排序，而是将 a 排序的结果给 a2
        Integer[] a2 = Arrays.stream(a).sorted(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        }).toArray(new IntFunction<Integer[]>() {
            @Override
            public Integer[] apply(int value) {
                return new Integer[value];
            }
        });

        // 对基本数据类型的数组进行排序 —— 不允许自定义排序规则
        int[] b = {1, 3, 2, 4};
        Arrays.sort(b);
        int[] b1 = Arrays.stream(b).sorted().toArray();
    }

（2）情况二： 使用 Comparator 提供的静态方法，链式的添加排序规则

这种方式也可以随意定制排序规则，而且相对来说，代码的可读性更高，如下实例：

        Integer[] a1 = Arrays.stream(a).sorted(Comparator.comparing(new Function<Integer, Integer>() {
            @Override
            public Integer apply(Integer integer) {
                return integer;
            }
        }).reversed()).toArray(new IntFunction<Integer[]>() {
            @Override
            public Integer[] apply(int value) {
                return new Integer[value];
            }
        });

其提供了如下方法，供我们使用 ： 其中 then 那一堆可以帮我们定义二级排序规则，也就是说第一级相等的时候，按照那个属性进行排序

2. 对 Collection 集合类型进行排序

总体思想和上面的差不多

下面是一个例子 ：

public void test2(){
    List<Student> list = new ArrayList<>();
    // 对 list 按照 先年龄 后 成绩的方式排序
    Collections.sort(list, Comparator.comparing(Student :: getAge).thenComparing(Student :: getScore));
    // 将 list 按照先成绩 再年龄 的方式排序，并将结果赋值给 list2
    List<Student> list2 = list.stream().sorted(Comparator.comparing(Student :: getScore).thenComparing(Student :: getAge)).collect(Collectors.toList());
}


class Student{
    int name;
    int age;
    int score;

    public int getName() {
        return name;
    }

    public void setName(int name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }
}

三、总结

• 直接创建 Comparator 类实例， 然后重写 compare 方法定义排序规则
• 使用 Comparator 静态方法进行排序，直接用类名调用进行排序，给方法传入相应的排序指标