方法一

自定义类中实现 Comparable 接口，重写 compareTo(T o) 方法，在 compareTo 方法中对对象如何排序进行描述，再调用 Arrays.sort 即可对对象进行排序
API 文档对 compareTo(T o) 方法的描述为：

Compares this object with the specified object for order. Returns a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the specified object.

用当前对象 this 与指定对象 obj 比较

  1. 当前对象 this 小于指定对象 obj，返回一个负整数
  2. 当前对象 this 等于指定对象 obj，返回 0
  3. 当前对象 this 大于指定对象 obj，返回一个正整数

举个栗子：

import java.util.Arrays;

public class TestComparable {
    public static void main(String[] args) {
        Student[] stu = new Student[5];
        stu[0] = new Student(16, 98);
        stu[1] = new Student(15, 99);
        stu[2] = new Student(14, 99);
        stu[3] = new Student(16, 99);
        stu[4] = new Student(16, 100);

        Arrays.sort(stu);

        System.out.println(Arrays.toString(stu));

    }
}

class Student implements Comparable<Student> {
    int id;
    int score;

    @Override
    public String toString() {
        return "Student{" + "id=" + id + ", score=" + score + '}';
    }

    public Student(int id, int score) {
        this.id = id;
        this.score = score;
    }

    @Override
    public int compareTo(Student o) {
        // 按 id 升序排列，如果 id 相同，按 score 逆序排列
        return (this.id == o.id) ? (o.score - this.score) : this.id - o.id;
    }
}

显然，该方法排序规则直接在类中写死，不太灵活

方法二

Arrays.sort 方法中使用匿名内部类实现 Comparator(T o1, T o2) 接口，重写 compare 方法对对象进行排序
API 文档对 compare​(T o1, T o2) 方法的描述为：

Compares its two arguments for order. Returns a negative integer, zero, or a positive integer as the first argument is less than, equal to, or greater than the second.

比较两个参数

  1. 如果前一个参数 o1 小于后一个参数 o2，返回一个负整数
  2. 如果前一个参数 o1 等于后一个参数 o2，返回 0
  3. 如果前一个参数 o1 大于后一个参数 o2，返回一个正整数

举个栗子：

import java.util.Arrays;
import java.util.Comparator;

public class TestComparator {
    public static void main(String[] args) {
        String[] str = new String[5];
        str[0] = "111111";
        str[1] = "333333";
        str[2] = "444444";
        str[3] = "222222";
        str[4] = "555555";

        // String 实现了 Comparable 接口并默认按从小到大顺序排列
        Arrays.sort(str);

        System.out.println(Arrays.toString(str));

        // 自己实现 Comparator，使其按从大到小顺序排序
        Arrays.sort(str, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return -o1.compareTo(o2);
            }
        });

        System.out.println(Arrays.toString(str));
    }
}

该排序每次调用 Arrays.sort 就得实现一次，太麻烦

使用建议：在需要排序的自定义类中实现 Comparable 接口，实现常用排序规则，对特殊的排序用匿名内部类实现 Comparator