java排序和Comparable，Comparator两个接口区别

简介：java的排序可以通过Collections.sort(LIst)和Arrays.sort(Array)进行实现，总的看来大体的实现方式有两种，一种是排序对象自身实现Comparable接口， 另外一种就是在使用sort方法是传入第二个参数Comparator.

跟c,c++中的cmp函数一样， java也需要方法来对比两个对象的大小，cmp的实现由两种方式，一种实现Comparable接口的类，通过实现compareTo方法来对比对象的大小。第二种方法Comparator接口中通过实现compare方法来满足该要求。 在排序过程中equals方法不是必须的。

一、用Comparable接口实现排序

import java.text.Collator;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class User implements Comparable<Object>{

	private static Collator cmp = Collator.getInstance();
	
	private String username;
	
	private String password;
	
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public User(String username, String password) {
		this.username = username;
		this.password = password;
	}

	@Override
	public int compareTo(Object o) {
		User u = (User)o;
		return cmp.compare(this.username, u.getUsername());
	}
	public static void main(String[] args) {
		List<User> us = new ArrayList<User>();
		us.add(new User("chuninsane", "123"));
		us.add(new User("boas", "123"));
		us.add(new User("gg", "123"));
		Collections.sort(us);
		for(User u: us) {
			System.out.println(u.getUsername());
		}
	}
}

上面的compareTo方法中使用Collator中的compare来对User的username进行比较， 最后比较的结果是按照username的字典序进行排序

现在来分析一下Collections.sort方法的源码

 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]);
        }
    }

从上面可以清楚看出，Collections.sort方法也调用了Arrays.sort方法， 将list先转换为Array，然后排序结束之后再将数据复制回list中

下面我们接着分析Arrays.sort方法

public static void sort(Object[] a) {
        if (LegacyMergeSort.userRequested)
            legacyMergeSort(a);
        else
            ComparableTimSort.sort(a);
    }

LegacyMergeSort.userRequested参数决定是采用MergeSort还是使用TimeSort来进行排序
LegacyMergeSort.userRequested由"java.util.Arrays.useLegacyMergeSort"方法进行设置

 legacyMergeSort方法的源码

private static void legacyMergeSort(Object[] a) {
        Object[] aux = a.clone();
        mergeSort(aux, a, 0, a.length, 0);
    }

legacyMergeSort又调用merge进行排序

 private static void mergeSort(Object[] src,
                                  Object[] dest,
                                  int low,
                                  int high,
                                  int off) {
        int length = high - low;

        if (length < INSERTIONSORT_THRESHOLD) {
            for (int i=low; i<high; i++)
                for (int j=i; j>low &&
                         ((Comparable) dest[j-1]).compareTo(dest[j])>0; j--)
                    swap(dest, j, j-1);
            return;
        }

        int destLow  = low;
        int destHigh = high;
        low  += off;
        high += off;
        int mid = (low + high) >>> 1;
        mergeSort(dest, src, low, mid, -off);
        mergeSort(dest, src, mid, high, -off);
    
        if ((<span style="color:#ff0000;">(Comparable)src[mid-1]).compareTo(src[mid])</span> <= 0) {
            System.arraycopy(src, low, dest, destLow, length);
            return;
        }

        for(int i = destLow, p = low, q = mid; i < destHigh; i++) {
            if (q >= high || p < mid && (<span style="color:#ff0000;">(Comparable)src[p]).compareTo(src[q])</span><=0)
                dest[i] = src[p++];
            else
                dest[i] = src[q++];
        }
    }

顾名思义， mergeSort就是归并排序，将dest分成 INSERTIONSORT_THRESHOLD大小的多个子串， 然后采用选择排序对子串进行排序，最后进行整理

上面代码中需要注意的就是((Comparable)src[mid-1]).compareTo(src[mid]) <= 0， 表示两个子串可以直接连接起来。否则就采用归并排序的合并方式进行合并。

②ComparableTimSort.sort方法的源码

static void sort(Object[] a) {
          sort(a, 0, a.length);
    }

    static void sort(Object[] a, int lo, int hi) {
        rangeCheck(a.length, lo, hi);
        int nRemaining  = hi - lo;
        if (nRemaining < 2)
            return;  

        if (nRemaining < MIN_MERGE) {
            int initRunLen = countRunAndMakeAscending(a, lo, hi);
            binarySort(a, lo, hi, lo + initRunLen);
            return;
        }

        ComparableTimSort ts = new ComparableTimSort(a);
        int minRun = minRunLength(nRemaining);
        do {
            int runLen = countRunAndMakeAscending(a, lo, hi);

            if (runLen < minRun) {
                int force = nRemaining <= minRun ? nRemaining : minRun;
                binarySort(a, lo, lo + force, lo + runLen);
                runLen = force;
            }

            ts.pushRun(lo, runLen);
            ts.mergeCollapse();

            lo += runLen;
            nRemaining -= runLen;
        } while (nRemaining != 0);

        assert lo == hi;
        ts.mergeForceCollapse();
        assert ts.stackSize == 1;
    }

TimSort是一个归并排序做了大量优化的排序方式
此方法中传入的带排序数组长度若小于阀值MIN_MERGE，则调用binarySort方法， 然后开始真正的TimSort方法的处理（待补充）

二、用Comparator实现排序

jdk中对该接口的描述：

强行对某个对象 collection 进行整体排序 的比较函数。可以将 Comparator 传递给 sort 方法（如 Collections.sort 或 Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用 Comparator 来控制某些数据结构（如有序 set或有序映射）的顺序，或者为那些没有自然顺序的对象 collection 
提供排序。

在Set和Map中Comparator的用法

Comparator的定义

import java.text.Collator;
import java.util.Comparator;

public class UserComparator implements Comparator<User> {

	Collator cmp = Collator.getInstance();
	
	@Override
	public int compare(User o1, User o2) {
		return cmp.compare(o1.getUsername(), o2.getUsername());
	}
}

使用Comparator进行排序

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class User {
	private String username;
	
	private String password;

	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}
	public User(String username, String password) {
		this.username = username;
		this.password = password;
	}
	public static void main(String[] args) {
		List<User> us = new ArrayList<User>();
		us.add(new User("aaa", "123"));
		us.add(new User("bbb", "123"));
		us.add(new User("aaa", "123"));
		Collections.sort(us, new UserComparator());
		for(User u: us) {
			System.out.println(u.getUsername());
		}
	}
	
}

首先还是查看Collections.sort的源码

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]);
        }
    }

这里还是调用的Arrays.sort方法

public static <T> void sort(T[] a, Comparator<? super T> c) {
        if (LegacyMergeSort.userRequested)
            legacyMergeSort(a, c);
        else
            TimSort.sort(a, c);
    }

上面的方法还是和Comparable中的类似

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);
    }

merge的源码

  private static void mergeSort(Object[] src,
                                  Object[] dest,
                                  int low, int high, int off,
                                  Comparator c) {
        int length = high - low;

        if (length < INSERTIONSORT_THRESHOLD) {
            for (int i=low; i<high; i++)
                for (int j=i; j>low && <span style="color:#ff0000;">c.compare(dest[j-1], dest[j])</span>>0; j--)
                    swap(dest, j, j-1);
            return;
        }

        int destLow  = low;
        int destHigh = high;
        low  += off;
        high += off;
        int mid = (low + high) >>> 1;
        mergeSort(dest, src, low, mid, -off, c);
        mergeSort(dest, src, mid, high, -off, c);

        if (c.compare(src[mid-1], src[mid]) <= 0) {
           System.arraycopy(src, low, dest, destLow, length);
           return;
        }

        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++];
        }
    }

从上面的merge可以看出Comparable个Comparator的最大区别就是在进行对象对比时用的方法不同， Comparable中将对象强制转换为Comparable类型，如果你的类没实现Comparable接口则会报 java.lang.ClassCastException XXXDO cannot be cast to java.lang.Comparable错误， Comparator则中则是调用传入的Comparator中的compare方法来比较两个对象的大小。

——结束