Collections的sort方法
通过Collections的sort方法对List进行排序，有两种方法实现：
List<T>中的对象应实现Comparable接口，并实现其compareTo方法
//需要比较的对象类PersonH
public class PersonH implements Comparable<PersonH>
{
private int level;
public Integer getLevel()
{
return level;
}
public void setLevel(Integer level1)
{
this.level = level1;
}
@Override
public int compareTo(PersonH o)
{
return this.getLevel().compareTo(o.getLevel());
}
}
//Main类
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Main
{
/**
* @param args
*/
public static void main(String[] args)
{
PersonH person = new PersonH();
person.setLevel(6);
PersonH person2 = new PersonH();
person2.setLevel(8);
PersonH person3 = new PersonH();
person3.setLevel(3);
List<PersonH> personList = new ArrayList<PersonH>();
personList.add(person);
personList.add(person2);
personList.add(person3);
Collections.sort(personList);//排序
for(PersonH personH : personList) //输出排序后结果
{
System.out.print(personH.getLevel() + "\t");
}
}
}
//运行结果：3 6 8
这种方式相当于类PersonH具备了指定的基本排序策略，因它实现了compareTo方法
2. 根据Collections.sort重载之，来实现
//PersonH类
public class PersonH
{
private int level;
public Integer getLevel()
{
return level;
}
public void setLevel(Integer level1)
{
this.level = level1;
}
}
//Main类
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class Main
{
/**
* @param args
*/
public static void main(String[] args)
{
PersonH person = new PersonH();
person.setLevel(6);
PersonH person2 = new PersonH();
person2.setLevel(8);
PersonH person3 = new PersonH();
person3.setLevel(3);
ArrayList<PersonH> personList = new ArrayList<PersonH>();
personList.add(person);
personList.add(person2);
personList.add(person3);
//这里可以更加灵活地指定比较策略，第一种实现方法是在要比较对象的类中就固定了比较策略。
Collections.sort(personList,new Comparator<PersonH>()
{
public int compare(PersonH p1,PersonH p2)
{
return p1.getLevel().compareTo(p2.getLevel());
}
});
for(PersonH personH : personList)
{
System.out.print(personH.getLevel() + "\t");
}
}
}
//运行结果：3 6 8
下面看一下该方法是如何进行排序的：
对于第一种：
public static <T extends Comparable<? super T>> void sort(List<T> list) {
Object[] a = list.toArray();
Arrays.sort(a);
ListIterator<T> i = list.listIterator();
for (int j=0; j<a.length; j++) {
i.next();
i.set((T)a[j]);
}
}
public static void sort(Object[] a) {
if (LegacyMergeSort.userRequested)
legacyMergeSort(a);
else
ComparableTimSort.sort(a);
}
/** To be removed in a future release. */
private static void legacyMergeSort(Object[] a) {
Object[] aux = a.clone();
mergeSort(aux, a, 0, a.length, 0);
}
对于第二种：
public static <T> void sort(List<T> list, Comparator<? super T> c) {
Object[] a = list.toArray();
Arrays.sort(a, (Comparator)c);
ListIterator i = list.listIterator();
for (int j=0; j<a.length; j++) {
i.next();
i.set(a[j]);
}
}
public static <T> void sort(T[] a, Comparator<? super T> c) {
if (LegacyMergeSort.userRequested)
legacyMergeSort(a, c);
else
TimSort.sort(a, c);
}
/** 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);
}
总之，两种方式都是通过mergeSort和TimSort实现的。
首先看是否指定排序策略，如果没有，则和第一种走一样的逻辑；否则进行指定比较策略的归并排序。
mergeSort函数的源代码可以参考java.util.Arrays类。