步步深入：java.util.Arrays.sort

java给我们提供了排序的方法，即：java.util.Arrays.sort，在Arrays中，所有的方法都是static的，我们先来看看jdk说明：

1. 以sort（int[] a)为例：

public static void sort(int[] a)

对指定的 int 型数组按数字升序进行排序。该排序算法是一个经过调优的快速排序法，改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的 Engineering a Sort Function", Software-Practice and Experience Vol. 23(11) P. 1249-1265 (November 1993)。此算法在许多数据集上提供 n*log(n) 性能，这导致其他快速排序会降低二次型性能。

参数：a - 要排序的数组 

举例来看如何使用：

int[] arr = {1,5,6,4,2};
        Arrays.sort(arr);
        for(int i : arr)
        	System.out.print(i + " ");／／1 2 4 5 6 

结论：sort方法提供８种基本数据类型和Object类参数的重载方法。基本数据类型的数组元素由关系运算（＞、＞＝、＜、＜＝）比较大小；对象数组元素由实现java.lang.Comparable接口中的e1.compareTo(e2)方法比较大小

2、对象数组元素比较大小

在实现对象数组比较大小之前，我们逐步深入来探究java到底是如何实现sort的：

public class Student{
	public static void main(String[] args) {
        Student[] students = new Student[5];
        students[0] = new Student("赵六", 100);
        students[1] = new Student("张三", 99);
        students[2] = new Student("王五", 85);
        students[3] = new Student("李四", 85);
        students[4] = new Student("孙七", 75);
         
        Arrays.sort(students);
         
        for (int i = 0; i < students.length; i++) {
            Student student = students[i];
            System.out.println(student.name + " : " + student.score);
        }
    }
     
    private String name;
    private int score;
     
    public Student() {
    }
    
    public Student(int score){
    	this.score = score;
    }
     
    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }
    
    public Student(String name) {
        this.name = name;
    }
     
    public String getName() {
        return name;
    }
     
    public void setName(String name) {
        this.name = name;
    }
     
    public int getScore() {
        return score;
    }
     
    public void setScore(int score) {
        this.score = score;
    }
}

结果：

这句话的意思是：Student类不能转化为Comparable，言下之意，你给我的Student我java虚拟机不能比较它们的大小！！！很多朋友在这里就犯糊涂了，java不是提供对象数组比较大小吗？现在为什么抛出exception？我们再回到第一条的结论发现：对象数组必须实现Comparable才能实现比较大小。于是，我们做了个修改如下：

import java.text.Collator;
import java.util.Arrays;
import java.util.Locale;

public class Student implements Comparable{
	public static void main(String[] args) {
        Student[] students = new Student[5];
        students[0] = new Student("赵六", 100);
        students[1] = new Student("张三", 99);
        students[2] = new Student("王五", 85);
        students[3] = new Student("李四", 85);
        students[4] = new Student("孙七", 75);
         
        Arrays.sort(students);
         
        for (int i = 0; i < students.length; i++) {
            Student student = students[i];
            System.out.println(student.name + " : " + student.score);
        }
    }
     
    private String name;
    private int score;
     
    public Student() {
    }
    
    public Student(int score){
    	this.score = score;
    }
     
    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }
    
    public Student(String name) {
        this.name = name;
    }
     
    public String getName() {
        return name;
    }
     
    public void setName(String name) {
        this.name = name;
    }
     
    public int getScore() {
        return score;
    }
     
    public void setScore(int score) {
        this.score = score;
    }
     
    public int compareTo(Student other) {
        if (this.score != other.score) {
            return other.score - this.score;
        } else {
            Collator instance = Collator.getInstance(Locale.CHINA);//提供比较中文，否则按unicode字符比较
            return instance.compare(this.name, other.name);
        }
    }
}

结果：

3、非Comparable之外余将取何用兮？

有的朋友有意见了，我想比较个对象数组大小，每次还得实现个接口，重写个方法，Student就是Student，只有构造方法和getter/setter，不想提供个比较大小的方法，老子觉得麻烦，还有没有其他的方法。三十六计中，有个围魏救赵，有的朋友说了，这是什么意思？听我娓娓道来.....
还是从jdk一探究竟，

public static  void sort(T[] a, Comparator c)

    根据指定比较器产生的顺序对指定对象数组进行排序。数组中的所有元素都必须是通过指定比较器 可相互比较的（也就是说，对于数组中的任何 e1 和 e2 元素而言， c.compare(e1, e2) 不得抛出 ClassCastException）。

    保证此排序是稳定的：不会因调用 sort 方法而对相等的元素进行重新排序。

    该排序算法是一个经过修改的合并排序算法（其中，如果低子列表中的最高元素小于高子列表中的最低元素，则忽略合并）。此算法提供可保证的 n*log(n) 性能。

    参数：
        a - 要排序的数组 
        c - 确定数组顺序的比较器。 null 值指示应该使用元素的 自然顺序。 
    抛出：
        ClassCastException - 如果数组包含使用指定的比较器不 可相互比较的 的元素。 

有的朋友看完就明白了，现在我不去实现Comparable了，直接在外部提供提供个比较类

第一步：先在外部new一个比较类：

public class CompareByScore implements Comparator{

	public int compare(Student s1, Student s2) {
		return s1.getScore() - s2.getScore();
	}

}

第二步：给sort传参

public class TestSort {
	public static void main(String[] args) {
        Student[] students = new Student[5];
        students[0] = new Student("赵六", 100);
        students[1] = new Student("张三", 99);
        students[2] = new Student("王五", 85);
        students[3] = new Student("李四", 85);
        students[4] = new Student("孙七", 75);
         
        Arrays.sort(students,new CompareByScore());
         
        for (int i = 0; i < students.length; i++) {
            Student student = students[i];
            System.out.println(student.getName() + " : " + student.getScore());
        }
    }
}

结果：

如有兴趣，请阅读Comparable和Comparator的区别。http://blog.csdn.net/weixin_38437243/article/details/76732786