Collections.sort
@SuppressWarnings("unchecked")
public static <T extends Comparable<? super T>> void sort(List<T> list) {
list.sort(null);
}
@SuppressWarnings({"unchecked", "rawtypes"})
public static <T> void sort(List<T> list, Comparator<? super T> c) {
list.sort(c);
}
由jdk源码我们可知，Collections类中的sort函数提供了两种重载。
第一种方法：
<T extends Comparable<? super T>>该方法的泛型必须实现了Comparable中的compareTo()方法，输入为相应的List。
第二种方法：
对泛型不作要求，但是输入参数中需提供Comparator
我们可以通过例子来分析：
public class run {
public static void main(String[] args) throws Exception
{
//类A实现了Comparable接口，所以可以直接使用Collections.sort()方法
A a1 = new A(3);
A a2 = new A(1);
A a3 = new A(2);
ArrayList<A> lista = new ArrayList<A>();
lista.add(a1);
lista.add(a2);
lista.add(a3);
Collections.sort(lista);
for(A a : lista)
System.out.println(a.value);//输出123
//类B没有实现Comparable接口，通过自定义的比较器Comparator来使用Collections.sort()方法
ArrayList<B> listb = new ArrayList<B>();
B b1 = new B(5);
B b2 = new B(7);
B b3 = new B(6);
listb.add(b1);
listb.add(b2);
listb.add(b3);
BComparator comparator = new BComparator();
Collection.sort(listb);//错误，会报错，缺少比较器
Collections.sort(listb, comparator);//正确
for(B b : listb)
System.out.print(b.value);//输出567
}
}
//类A实现了Comparble接口
class A implements Comparable<A> {
public int value;
//升序排列
@Override
public int compareTo(A o) {
if(this.value > o.value)
return 1;
else if(this.value < o.value)
return -1;
else
return 0;
}
public A (int i) {
value = i;
}
}
//类B是一个普通类
class B {
public int value;
public B(int i) {
value = i;
}
}
//定义比较器，实现了Comparator接口，可以用来作为输入参数定义比较方法
class BComparator implements Comparator<B> {
//升序排列
@Override
public int compare(B o1, B o2) {
if(o1.value > o2.value)
return 1;
else if(o1.value < o2.value)
return -1;
else
return 0;
}
}
Arrays.sort
由jdk源码可知，Arrays.sort方法也可以通过自定义Comparator的方法来实现自定义排序。
/*
* @param <T> the class of the objects to be sorted
* @param a the array to be sorted
* @param c the comparator to determine the order of the array. A
* {@code null} value indicates that the elements'
* {@linkplain Comparable natural ordering} should be used.
* @throws ClassCastException if the array contains elements that are
* not <i>mutually comparable</i> using the specified comparator
* @throws IllegalArgumentException (optional) if the comparator is
* found to violate the {@link Comparator} contract
*/
public static <T> void sort(T[] a, Comparator<? super T> c) {
if (c == null) {
sort(a);
} else {
if (LegacyMergeSort.userRequested)
legacyMergeSort(a, c);
else
TimSort.sort(a, 0, a.length, c, null, 0, 0);
}
}
/** To be removed in a future release. */
private static <T> void legacyMergeSort(T[] a, Comparator<? super T> c) {
T[] aux = a.clone();
if (c==null)
mergeSort(aux, a, 0, a.length, 0);
else
mergeSort(aux, a, 0, a.length, 0, c);
}
我们继续通过例子来分析：
public class run {
public static void main(String[] args) throws Exception
{
A a1 = new A(5);
A a2 = new A(7);
A a3 = new A(6);
A[] array2 = new A[3];
array2[0] = a1;
array2[1] = a2;
array2[2] = a3;
Arrays.sort(array2);
for(int i = 0; i < array2.length; i++) {
System.out.print(array2[i].value);//输出567
}
B b1 = new B(5);
B b2 = new B(7);
B b3 = new B(6);
B[] array = new B[3];
array[0] = b1;
array[1] = b2;
array[2] = b3;
BComparator comparator = new BComparator();
Arrays.sort(array);//错误,B没有实现Comparable接口，程序无法判断排序标准
Arrays.sort(array, comparator);//正确
for(int i = 0; i < array.length; i++) {
System.out.print(array[i].value);//输出567
}
}
}
//类A实现了Comparble接口
class A implements Comparable<A> {
public int value;
//升序排列
@Override
public int compareTo(A o) {
if(this.value > o.value)
return 1;
else if(this.value < o.value)
return -1;
else
return 0;
}
public A (int i) {
value = i;
}
}
//类B是一个普通类
class B {
public int value;
public B(int i) {
value = i;
}
}
//定义比较器，实现了Comparator接口，可以用来作为输入参数定义比较方法
class BComparator implements Comparator<B> {
//升序排列
@Override
public int compare(B o1, B o2) {
if(o1.value > o2.value)
return 1;
else if(o1.value < o2.value)
return -1;
else
return 0;
}
}
总结
由上可知，Arrays.sort和Collections.sort实现自定义排序时基本相同，分为两种：
1）被排序的元素自身实现了Comparable接口
2）被排序的元素没有实现Comparable接口，自定义比较器Comparator类作为输入参数输入
区别：
Collection.sort是给List<T>进行排序，而Arrays.sort是给数组进行排序。
PS:
回到Collections.sort的源码：
@SuppressWarnings("unchecked")
public static <T extends Comparable<? super T>> void sort(List<T> list) {
list.sort(null);
}
@SuppressWarnings({"unchecked", "rawtypes"})
public static <T> void sort(List<T> list, Comparator<? super T> c) {
list.sort(c);
}
我们发现调用了list.sort方法，查看该方法的源码
@SuppressWarnings({"unchecked", "rawtypes"})
default void sort(Comparator<? super E> c) {
Object[] a = this.toArray();
Arrays.sort(a, (Comparator) c);
ListIterator<E> i = this.listIterator();
for (Object e : a) {
i.next();
i.set((E) e);
}
}
调用了Arrays.sort方法。
所以，其实Collections.sort实质上是调用的Arrays.sort
