在 Java 中，一般我们只会对 ArrayList 中的对象进行排序操作。在对数组排序时，我们会使用 ArrayList.sort 方法。这个方法不会有返回值，会直接在原来的 ArrayList 上进行修改。

在 Java 中对语言自带的类型进行排序

如果我们要对数组进行排序，仅仅调用 ArrayList.sort() 是不够的，我们还要告诉 Java 如何对 List 中的对象进行排序 - 这里我们就要引入 Comparator 的概念了。Comparator 对象是专门用来比较两个对象大小的。ArrayList 进行排序的时候会调用传入的 Comparator 对象进行排序。

import java.util.*;

public class compareExample {
    public static void main(String[] args) {
        ArrayList<Integer> arr = new ArrayList<>();
        arr.add(1);
        arr.add(8);
        arr.add(3);
        arr.add(5);
        arr.sort(Comparator.naturalOrder());
        System.out.println(arr);    // Output: [1, 3, 5, 8]
        arr.sort(Comparator.reverseOrder());
        System.out.println(arr);    // Output: [8, 5, 3, 1]
    }
}

在上面这段代码中，我们向 arr 传入了 Comparator.naturalOrder() 这样一个对象。如同它的名字所描述的，这个比较器的作用就是将Array中的内容按照“自然顺序”排列 - 也就是从小到大的顺序。类似naturalOrder，java.util.Comparator 中还有其他的比较器，例如 reverseOrder （将List中的元素从大到小的排序）等。

如果你想排序的 ArrayList 中存放的元素是 Java 已给出的数据类型，那么对它们进行排序就只需要上面这一步就好了。然而，如果你想对自己声明的类型进行排序，我们还需要做一些额外的工作……

在 Java 中对自己定义的类进行排序

如果你想对自己定义的类进行排序，那么有以下两种方法实现：

1. 在自己的类中实现 Java 定义的 Comparable 接口
2. 自己为自己的类实现一个 Comparator 类型，并将这个 Comparator 传到 arr.sort() 中。

下面，假设我们要对这样一个 Java 类进行排序：

class Person{
    public int age;
    public String name;

    public Person(int age, String name){
        this.age = age;
        this.name = name;
    }

    public String toString(){
        return "( age: " + this.age + ", name: " + this.name + " )";
    }
}

实现 Comparable 接口 （推荐）

通过实现 Comparable 接口，Java会识别到这个类是“可比较的”。在调用 ArrayList.sort()的时候，Comparator会调用你的类中的 compareTo方法来判断两个对象之间的大小关系。

public int compareTo(object other){
    /*
        If this object is bigger than the "other" given in the parameter, return a positive integer.
        if this object is smaller than the "other" given in parameter, return a negative integer.
        Otherwise, return 0.
    */
}

class Person implements Comparable<Person>{
    public int age;
    public String name;

    public Person(int age, String name){
        this.age = age;
        this.name = name;
    }

    public int compareTo(Person other){
        if (this.equals(other)){ return 0; }
        if (this.age != other.age){ return this.age - other.age; }
        else{ return this.name.compareTo(other.name); }
    }

    public boolean equals(Person other){
        return this.age == other.age && this.name.equals(other.name);
    }

    public String toString(){
        return "( age: " + this.age + ", name: " + this.name + " )";
    }
}

如果你在自己的Java类上实现了Comparable 接口，那么在数组排序时所有 java.util.Comparator 中的比较器都可以直接传入给 ArrayList。

import java.util.*;

public class compareTest{
    public static void main(String[] args) {
        ArrayList<Person> arr = new ArrayList<>();
        arr.add(new Person(17, "Mark"));
        arr.add(new Person(14, "Test"));
        arr.add(new Person(18, "wyn"));
        arr.sort(Comparator.naturalOrder());
        System.out.println(arr);
    }
}

[( age: 14, name: Test ), ( age: 17, name: Mark ), ( age: 18, name: wyn )]

实现 Comparator 类型 （不推荐）

除了直接实现Comparable接口以外，我们还可以直接定义一个可以比较两个自己类型对象的比较器（Comparator）来达到对存储这个类型对象的数组进行排序的目的。这种情况下，我们要新建一个比较器类型来实现 Comparator 抽象类。Comparator 抽象类只有一个函数 - compare。所以如果我们想实现一个效果和上文的方案相同的比较器，我们可以这样写：

class PersonComparator implements Comparator<Person>{
    public int compare(Person o1, Person o2){
        if (o1 == o2){ return 0; }
        if (o1.age != o2.age) { return o1.age - o2.age; }
        else{ return o1.name.compareTo(o2.name); }
    }
}

这种情况下，我们要对Person类进行排序就需要将自己定义的比较器传入ArrayList.sort()中来进行排序。

import java.util.*;

public class compareTest{
    public static void main(String[] args) {
        ArrayList<Person> arr = new ArrayList<>();
        arr.add(new Person(17, "Mark"));
        arr.add(new Person(14, "Test"));
        arr.add(new Person(18, "wyn"));
        arr.sort(new PersonComparator());
        System.out.println(arr);
    }
}

输出结果如下：

[( age: 14, name: Test ), ( age: 17, name: Mark ), ( age: 18, name: wyn )]