浅层次理解Java Arrays.sort()函数

前几天java考试，遇到对对象数组进行排序，不太理解其中的原理，下面来更深入的理解下。（具体sort()的使用方法参考API文档）

Arrays.sort()的使用主要分为对基本数据类型数组的排序和对对象数组的排序.

1.对基本数据类型数组的排序
1>数字排序：
int[] intArray = new int[]{1,56,-5,33};
Arrays.sort(intArray);
System.out.println(Arrays.toString(intArray));
2>字符串排序(先大写后小写)：
String[] strArray = new String[]{"Z", "a", "D"};
Arrays.sort(strArray);
System.out.println(Arrays.toString(strArray));
3>字符串字母表排序(忽略大小写)
Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);
4>反向排序
Arrays.sort(strArray, Collections.reverseOrder());
说明：
1>Arrays.sort()使用的是“经过调优的快速排序法
2>比如int[]，double[]，char[]等基数据类型的数组，Arrays类之只是提供了默认的升序排列，没有提供相应的降序排列方法

2.对对象数组的排序
要实现对对象数组的排序，要先实现Comparable或者Comparator接口。下面先简单了解以下这两个接口以及它们的差别：
1> Comparable 是排序接口,若一个类实现了Comparable接口，就意味着“该类支持排序”。 即然实现Comparable接口的类支持排序，假设现在存在“实现Comparable接口的类的对象的List列表(或数组)”，则该List列表(或数组)可以通过 Collections.sort（或 Arrays.sort）进行排序。
Comparable 接口仅仅只包括一个函数，它的定义如下:

package java.lang;
import java.util.*;
public interface Comparable<T> {
public int compareTo(T o);
}

说明：
假设我们通过 x.compareTo(y) 来“比较x和y的大小”。若返回“负数”，意味着“x比y小”；返回“零”，意味着“x等于y”；返回“正数”，意味着“x大于y”。
2> Comparator 是比较器接口,我们若需要控制某个类的次序，而该类本身不支持排序(即没有实现Comparable接口)；那么，我们可以建立一个“该类的比较器”来进行排序。这个“比较器”只需要实现Comparator接口即可。
Comparator 接口仅仅只包括两个个函数，它的定义如下：

package java.util;
public interface Comparator<T> {
    int compare(T o1, T o2);
    boolean equals(Object obj);
}

说明：
(1) 若一个类要实现Comparator接口：它一定要实现compareTo(T o1,T o2) 函数，但可以不实现 equals(Object obj) 函数。
为什么可以不实现 equals(Object obj) 函数呢？ 因为任何类，默认都是已经实现了equals(Object obj)的。 Java中的一切类都是继承于java.lang.Object，在Object.java中实现了equals(Object obj)函数；所以，其它所有的类也相当于都实现了该函数。
(2) int compare(T o1, T o2) 是“比较o1和o2的大小”。返回“负数”，意味着“o1比o2小”；返回“零”，意味着“o1等于o2”；返回“正数”，意味着“o1大于o2”。
(3) 这个排序算法是“经过调优的合并排序”算法
我们不难发现：Comparable相当于“内部比较器”，而Comparator相当于“外部比较器”。
下面通过期中考试的试题来具体实现两个接口：
键盘输入两个整数m，n。m作为随机数的种子，生成n个学生的高数、物理、英语成绩（成绩均为整数，大于等于0小于等于100），学号从1开始按序递增到n。请按总成绩由低到高排序输出。

import java.util.Comparator;
import java.util.Random;
import java.util.Scanner;

/**
 * Created by hexing on 15-5-20.
 */
//实现Comparable接口
class Student1 implements Comparable<Student1>{
    public int id,grad1, grad2, grad3,sum;
    public int compareTo(Student1 o){
        if(this.sum>o.sum) {
            return 1;
        }else if(this.sum<o.sum)
            return -1;
        else
            return 0;
    }
}

//实现Comparator接口
class Student2 implements Comparator<Student2>{
    public int id,grad1, grad2, grad3,sum;
    public int compare(Student2 o1, Student2 o2){
        return o1.sum-o2.sum;
    }
}

public class test1 {
    public static void main(String[] args) {
        int m, n;
        System.out.println("请输入m,n:");
        Scanner reader = new Scanner(System.in);
        m = reader.nextInt();
        n = reader.nextInt();
        Random r = new Random(m);
        Student1[] s1 = new Student1[n];
        for(int i = 0; i < n; i++){
            s1[i] = new Student1();
            s1[i].id = i+1;
            s1[i].grad1 = r.nextInt(101);
            s1[i].grad2 = r.nextInt(101);
            s1[i].grad3 = r.nextInt(101);
            s1[i].sum = s1[i].grad1+s1[i].grad2+s1[i].grad3;
        }
        Arrays.sort(s1);
        System.out.println("Comparable接口实现的排序：");
        for (int i = 0; i < s1.length; i++){
            System.out.printf("%5d%5d%5d%5d%5d\n",s1[i].id,s1[i].grad1,s1[i].grad2,s1[i].grad3,s1[i].sum);
        }
        Student2[] s = new Student2[n];
        for(int i = 0; i < n; i++){
            s[i] = new Student2();
            s[i].id = i+1;
            s[i].grad1 = r.nextInt(101);
            s[i].grad2 = r.nextInt(101);
            s[i].grad3 = r.nextInt(101);
            s[i].sum = s[i].grad1+s[i].grad2+s[i].grad3;
        }
        Arrays.sort(s, new Student2());
        System.out.println("Comparator接口实现的排序：");
        for (int i = 0; i < s.length; i++){
            System.out.printf("%5d%5d%5d%5d%5d\n",s[i].id,s[i].grad1,s[i].grad2,s[i].grad3,s[i].sum);
        }
    }

}