Collections.sort(List list) list排序学习笔记

先上代码：

class ListSortExample {
private String flag ;

public ListSortExample(String flag){
this.flag = flag;
}

public String getFlag(){
return this.flag;
}

public void setFlag(String flag){
this.flag = flag;
}
}
/**
* 比较器，重写compare方法，根据ListSortExample的flag字段来排序ListSortExample
*
*/
class ComparatorListSort implements Comparator{
public int compare(Object arg0, Object arg1) {
ListSortExample example0=(ListSortExample)arg0;
ListSortExample example1=(ListSortExample)arg1;
//首先比较年龄，如果年龄相同，则比较名字
int flag=example0.getFlag().compareTo(example1.getFlag());
return flag;
}

}
public class TestListSort{
public static void main(String[] args){
List<ListSortExample> sortExampleList=new ArrayList<ListSortExample>();
sortExampleList.add(new ListSortExample("aa"));
sortExampleList.add(new ListSortExample("ee"));
sortExampleList.add(new ListSortExample("bb"));
sortExampleList.add(new ListSortExample("cg"));

Comparator comparator=new ComparatorListSort();
//排序--注意：sortExampleList中的对象引用必须被comparator进行比较了，即是：comparator对象的compare方法一定是对sortExampleList中的对象就行比较
Collections.sort(sortExampleList, comparator);

for (ListSortExample example:sortExampleList){
System.out.println(example.getFlag());
}

}
}

运行结果：

aa

bb

cg

ee

上面初步对Collections.sort的应用做了一个简单的描述。

下面的篇章我们将会Collections.sort实现进行解析：见代码和代码注释

public static <T> void sort(List<T> list, Comparator<? super T> c) {
//将排序list转化为数组
Object[] a = list.toArray();
//然后调用Arrays的静态方法sort()进行排序，所以说Collections的sort()功能是委派Arrays来实现的，我们重点看看Arrays的sort()方法
Arrays.sort(a, (Comparator)c);

//这边简单：将排序完成的数组对象中的数据赋值给list对象
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) {
//数组拷贝
T[] aux = (T[])a.clone();
if (c==null)
//如果比较器为空，采用默认比较器
mergeSort(aux, a, 0, a.length, 0);
else
//采用用户自定义的比较器来比较排序
mergeSort(aux, a, 0, a.length, 0, c);
}

private static void mergeSort(Object[] src,
Object[] dest,
int low, int high, int off,
Comparator c) {
int length = high - low;
//当数组的数据小于或者等于7个时候，直接采用冒泡排序法进行比较，然后返回
// Insertion sort on smallest arrays
if (length < INSERTIONSORT_THRESHOLD) {
for (int i=low; i<high; i++)
for (int j=i; j>low && c.compare(dest[j-1], dest[j])>0; j--)
swap(dest, j, j-1);
return;
}

// Recursively sort halves of dest into src
int destLow  = low;
int destHigh = high;
low  += off;
high += off;
int mid = (low + high) >>> 1;
//如果数组中的个数大于7的话，通过调用递归方法，一直将原数组划分成多个小数组，数组的长度在7之间的，将这些小数组的中的数据按比较器中的规则排好序
//通过A,B将数组一分为二的，然后再将1/2的数组再次划分为2个，直至最后被划分的数组的长度在7之内，
mergeSort(dest, src, low, mid, -off, c);----A //对src[low], src[mid](假如程为数组1)之间的数据进行排序
mergeSort(dest, src, mid, high, -off, c);----B//对src[mid], src[high](假如程为数组2)之间的数组进行排序
//下面的操作就是将内部已经排序好的数组1，2就行排序
// If list is already sorted, just copy from src to dest.  This is an
// optimization that results in faster sorts for nearly ordered lists.
//当数组2的第一个数据(也就是最小数据)大于数组1的最后一个数据(就是最大数据)，直接合并俩数组到到目标数组
if (c.compare(src[mid-1], src[mid]) <= 0) {
System.arraycopy(src, low, dest, destLow, length);
return;
}

// Merge sorted halves (now in src) into dest
//否则采用算法，什么算法我也忘了，很简单的，依次比较，将比较好了的数据赋值给目标数组
for(int i = destLow, p = low, q = mid; i < destHigh; i++) {
if (q >= high || p < mid && c.compare(src[p], src[q]) <= 0)
dest[i] = src[p++];
else
dest[i] = src[q++];
}

}

废话再说俩句，竟然要排序，显然就要比较要排序元素的顺序或者大小，而比较器的作用就是用来干这个的。用比较器来实现对排序元素的比较。例如上面的代码：Collections.sort(sortExampleList, comparator)；comparator比较器中的compare()方法就是用来比较sortExampleList中的ListSortExample对象。