在C、C++中有很多排序演算法，但是通常排序演算法不得不讓程式設計師在寫程式碼的過程中陷入對底層很多指標和位置的理解，java不希望這樣，所以排序大多可以由java幫你做掉，例如，你要對一個數組排序，就通過：Collections.sort(list)那麼這個list就被排序了，排序最終呼叫的是Arrays.sort方法來完成的，所以陣列自然是用Arrays.sort了，而SortedSet裡面內部也有排序功能也是類似的方式的來實現的，只是內部呼叫了相關的方法來完成而已；SortedSet只是一個介面，實現類有很多，本文以TreeSet實現類作為例子。

而排序必然就存在對比大小，那麼傳遞的資訊，java是通過什麼來對比大小的呢？compareTo

這個來對比的，而內部對比過程中，需要將資料轉換為Comparable來對比，所以你的物件就需要implementsComparable，並實現內部的方法compareTo，只要你的compareTo實現是你所想要的，那麼排序必然是正確的，那麼是否還有其他的方法，有的，排序的時候，允許你傳入一個對比類，因為這樣也可以減少一些空指標出現的可能性，傳入的類需要實現：Comparator介面，實現其方法：compare類，雖然介面中還定義了equals方法基本不用管它，因為Object就已經實現了，並且內部排序中並沒有用到equals方法來做排序。

下面開始使用例項分別來做中文排序、物件排序，並分別使用物件實現Comparable

介面，以及單獨定義排序物件實現Comparator介面來完成排序：

例項1（通過實現Comparator介面完成中文排序）：

import java.text.Collator;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class ChineseSortCompare {
	
	@SuppressWarnings("rawtypes")
	private final static Comparator CHINA_COMPARE = Collator.getInstance(java.util.Locale.CHINA);

	public static void main(String []args) {
		sortArray();
		sortList();
		System.out.println("李四".compareTo("張三"));//前者大於後者，則為正數，否則為負數，相等為0
	}

	@SuppressWarnings("unchecked")
	private static void sortList() {
		List<String>list = Arrays.asList("張三", "李四", "王五");
		Collections.sort(list , CHINA_COMPARE);
		for(String str : list) {
			System.out.println(str);
		}
	}

	@SuppressWarnings("unchecked")
	private static void sortArray() {
		String[] arr = {"張三", "李四", "王五"};
		Arrays.sort(arr, CHINA_COMPARE);
		for(String str : arr) {
			System.out.println(str);
		}
	}
}
 

可以看到輸出的結果都是一樣的，當然String本身有compare方法，而且其本身也是實現了Comparable介面的，所以你如果不放入CHINA_COMPARE來進行處理的話，將會預設按照String自己的compareTo來做排序，排序的結果自然不是你想要的，當然英文應該是你想要的。

例項2（通過外部定義Comparator來完成物件排序）：

這裡首先要構造一個物件的類，為了簡單，我們就用兩屬性，定義一個UserDO這樣一個類，描述如下：

public class UserDO {
	
	protected String name;
	
	protected String email;
	
	public UserDO() {}
	
	public UserDO(String name , String email) {
		this.name = name;
		this.email = email;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getEmail() {
		return email;
	}

	public void setEmail(String email) {
		this.email = email;
	}
}

定義了兩個屬性為name和email，此時我們想要按照name了排序，那麼我們定義排序的類如下：

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

public class UserDOComparator implements Comparator<UserDO> {
	
	Collator cmp = Collator.getInstance(java.util.Locale.CHINA);
	
	@Override
	public int compare(UserDO userDO1, UserDO userDO2) {
		
		return cmp.compare(userDO1.getName(), userDO2.getName());
	}
}

此時可以看出我們實現了compare方法，是使用拼音排序的，然後我們來模擬一些資料驗證結果：

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.SortedSet;
import java.util.TreeSet;

public class SortUserListTest {
	
	private final static UserDOComparator USER_COMPARATOR = new UserDOComparator();

	public static void main(String []args) {
		sortUserDOArray();
		sortUserDOList();
		sortUserBySortedSet();
	}

	private static void sortUserBySortedSet() {
		SortedSet<UserDO>userSet = new TreeSet<UserDO>(USER_COMPARATOR);
		userSet.add(new UserDO("張三" , "[email protected]"));
		userSet.add(new UserDO("李四" , "[email protected]"));
		userSet.add(new UserDO("王五" , "[email protected]"));
		for(UserDO userDO : userSet) {
			System.out.println(userDO.getName());
		}
	}

	private static void sortUserDOList() {
		List<UserDO>list = Arrays.asList(
				new UserDO("張三" , "[email protected]"),
				new UserDO("李四" , "[email protected]"),
				new UserDO("王五" , "[email protected]")
		);
		Collections.sort(list , USER_COMPARATOR);
		for(UserDO userDO : list) {
			System.out.println(userDO.getName());
		}
	}

	private static void sortUserDOArray() {
		UserDO []userDOArray = new UserDO[] {
			new UserDO("張三" , "[email protected]"),
			new UserDO("李四" , "[email protected]"),
			new UserDO("王五" , "[email protected]")
		};
		Arrays.sort(userDOArray , USER_COMPARATOR);
		for(UserDO userDO : userDOArray) {
			System.out.println(userDO.getName());
		}
	}
}

根據這些輸入，你可以看到它的輸出和實際想要的按照名稱的拼音排序是一致的，那麼有人會問，如果我按照兩個欄位排序，先按照一個欄位排序，再按照另一個欄位排序該怎麼辦，其次如果是倒敘應該是如何操作，其實倒敘來講只需要在compare方法中將原有的輸出改成相反數就可以了，compare得到的結果為正數、負數、或0，若為正數，代表第一個資料比第二個大，而負數相反，為0的時候代表相等；而多欄位排序也是如此，通過第一層排序後得到結果，看是否是0，如果是0，那麼就再按照第二個欄位排序即可，否則就直接返回第一層返回的結果，兩者混合應用以及多層排序自然就實現了。

例項3（將上面的UserDO使用一個叫UserComparableDO在類的基礎上進行排序）

首先將UserDO重新編寫為UserComparableDO：

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

public class UserComparableDO extends UserDO implements Comparable<UserDO> {

    public UserComparableDO() {}
	
	public UserComparableDO(String name , String email) {
		this.name = name;
		this.email = email;
	}

	@SuppressWarnings("rawtypes")
	private final static Comparator CHINA_COMPARE = Collator.getInstance(java.util.Locale.CHINA);
	
	@SuppressWarnings("unchecked")
	@Override
	public int compareTo(UserDO userDO) {
		return CHINA_COMPARE.compare(this.getName(), userDO.getName());
	}
}

當然這段程式碼裡面直接在裡面定義一個Comparator是不正確的，一般這個東西是被抽象到系統某些公共的Commons元件裡面的，其次，如果原本沒有UserDO類，相應的屬性寫一次即可，我這裡原本有UserDO所有直接整合，減少很多程式碼。

此時就不需要自己再去寫一個Comparator了，就可以直接排序了，下面是我們的測試程式：

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.SortedSet;
import java.util.TreeSet;

public class SortUserListByComparable {

	public static void main(String []args) {
		sortUserBySortedSet();
		sortUserDOList();
		sortUserDOArray();
	}
	
	private static void sortUserBySortedSet() {
		SortedSet<UserComparableDO>userSet = new TreeSet<UserComparableDO>();
		userSet.add(new UserComparableDO("張三" , "[email protected]"));
		userSet.add(new UserComparableDO("李四" , "[email protected]"));
		userSet.add(new UserComparableDO("王五" , "[email protected]"));
		for(UserComparableDO userDO : userSet) {
			System.out.println(userDO.getName());
		}
	}
	
	private static void sortUserDOList() {
		List<UserComparableDO>list = Arrays.asList(
				new UserComparableDO("張三" , "[email protected]"),
				new UserComparableDO("李四" , "[email protected]"),
				new UserComparableDO("王五" , "[email protected]")
		);
		Collections.sort(list);
		for(UserComparableDO userDO : list) {
			System.out.println(userDO.getName());
		}
	}

	private static void sortUserDOArray() {
		UserComparableDO []userDOArray = new UserComparableDO[] {
			new UserComparableDO("張三" , "[email protected]"),
			new UserComparableDO("李四" , "[email protected]"),
			new UserComparableDO("王五" , "[email protected]")
		};
		Arrays.sort(userDOArray);
		for(UserComparableDO userDO : userDOArray) {
			System.out.println(userDO.getName());
		}
	}
}

可以看到本次排序中沒有再使用自定義的Comparator作為引數，另外TreeSet的入口引數也沒有再傳入這些引數。

結果知道了，我們簡單看看相關的原始碼來證實這個說法，我們首先來看Collections.sort方法：

原始碼片段1：Collections.sort(List<T> list)

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

此時直接呼叫了Arrays.sort(a)來排序後，將陣列的資料寫回到list，另外根據方法的定義，泛型T要求傳入的類必須是Comparable類的子類或實現類，所以要呼叫Collections.sort(list)這個方法，傳入的list中包含的每行資料必須是implements Comparable這個介面的，否則編譯時就會報錯。

再看過載方法，傳入自定義的Comparator

原始碼片段2：Collections.sort(List<T> list, Comparator<? super T> c)

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相應的過載方法，看來都是在Arrays裡面是實現的，那麼就進一步向下看：

原始碼片段3：Arrays.sort(T[]t):

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

看來程式碼片段交給了mergeSort來處理，而對陣列做了一次克隆，作為排序的基礎資料，而原來的陣列作為排序的目標，mergeSort的程式碼片段應該是核心部分，我們先放在這裡，先看下sort的另一個過載方法，另外需要注意，這裡並沒有像Collections.sort(List<T>list)那樣在編譯時檢查型別，也就是在使用這個方法的時候，數組裡面的每行並沒有implements Comparable也會不會出錯，只是在執行時會報錯而已，在下面的原始碼中會有說明。

原始碼片段4 : Arrays.sort(T[]t, Comparator<? super T> c)

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

看來mergeSort也進行了過載，也就是當傳入了自定義的Comparator和不傳入自定義的Comparator是呼叫不同的方法來實現的，然後我們來看下兩個方法的實現。

原始碼片段5：mergeSort(Object[]src , Object[]dst , int low , int high , int off)

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 (((Comparable)src[mid-1]).compareTo(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 && ((Comparable)src[p]).compareTo(src[q])<=0)
                dest[i] = src[p++];
            else
                dest[i] = src[q++];
        }
    }

/**
 * Swaps x[a] with x[b].
 */
private static void swap(Object[] x, int a, int b) {
	Object t = x[a];
	x[a] = x[b];
	x[b] = t;
}

仔細閱讀程式碼可以發現排序是分段遞歸回調的方式來排序（注意中間的low和high兩個引數的變化），每次如果分段的大小大於INSERTIONSORT_THRESHOLD（定義為7）的時候，則再分段，前一段和後一段，然後分開的兩段再呼叫遞推，遞推後再回歸排序，若發現中間分隔的位置兩個資料是有序，則認為兩段是完全有序的，若不是，那麼再將兩段做一次排序，此時排序就很好排序了，因為兩個塊是排序排好的，所以不需要兩次迴圈，只需要迴圈掃描下去，兩個陣列按照順序向下走，分別對比出最小值寫入陣列，較大者暫時不寫入陣列與另一個數組的下一個值進行對比，最後一截資料（原始碼中是通過越界來判定的）寫入到尾巴當中：

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

這段對兩個有序陣列的排序是很經典的寫法，主要是if語句的濃縮，不然程式碼會寫得很長。

注意：這裡的程式碼排序中使用了強制型別轉換為Comparable來呼叫內部的comareTo方法，所以如果你的類沒有implements Comparable那麼在Collections.sort(List<T>list)時編譯時會報錯上面已經說到，在呼叫Arrays.sort(Object []t)時，編譯時並不會報錯，但是執行時會報錯為：java.lang.ClassCastExceptionXXXDO cannot be cast to java.lang.Comparable

排序部分我們再看看其過載的mergeSort方法，就是傳入了自定義的Comparator的方法

原始碼片段6： mergeSort(Object[]src,Object[]dst,int low,int high,intoff,Comparator c)

   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 && c.compare(dest[j-1], 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, 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++];
        }
    }

可以發現演算法和上一個方法完全一樣，唯一的區別就是排序時使用的compare變成了傳入的comparator了，其餘的沒有任何區別。

大概清楚了，此時發現java提供的排序還是比較高效的，大多數情況下你不需要自己去寫排序演算法，最後我們再看看TreeSet中的在add的時候如何實現排序的，也是分別傳入了comparator和沒有傳入，我們跟著原始碼裡面，可以看到傳入了comparator將這個屬性設定給了TreeSet裡面定義的一個TreeeMap，而TreeMap中的一個屬性設定了這個Comparator：

原始碼片段7：TreeSet以及TreeMap設定Comparator的構造方法

public TreeSet(Comparator<? super E> comparator) {
	this(new TreeMap<E,Object>(comparator));
}
TreeSet(NavigableMap<E,Object> m) {
    this.m = m;
}
public TreeMap(Comparator<? super K> comparator) {
        this.comparator = comparator;
}

當然沒有傳入這個Comparator的時候自然沒有設定到TreeMap中了，那麼我們來看看TreeMap的add方法：

原始碼片段8：TreeSet#add(E e)

public boolean add(E e) {

    return m.put(e,PRESENT)==null;

}

這個m是什麼呢？其實通過原始碼片段7就可以看出，m是開始例項化的一個TreeMap，那麼我們就需要看TreeMap的put方法

程式碼片段9：TreeMap#put(K key , V value)

public V put(K key, V value) {
        Entry<K,V> t = root;
        if (t == null) {
            root = new Entry<K,V>(key, value, null);
            size = 1;
            modCount++;
            return null;
        }
        int cmp;
        Entry<K,V> parent;
        // split comparator and comparable paths
        Comparator<? super K> cpr = comparator;
        if (cpr != null) {
            do {
                parent = t;
                cmp = cpr.compare(key, t.key);
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    return t.setValue(value);
            } while (t != null);
        }
        else {
            if (key == null)
                throw new NullPointerException();
            Comparable<? super K> k = (Comparable<? super K>) key;
            do {
                parent = t;
                cmp = k.compareTo(t.key);
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    return t.setValue(value);
            } while (t != null);
        }
        Entry<K,V> e = new Entry<K,V>(key, value, parent);
        if (cmp < 0)
            parent.left = e;
        else
            parent.right = e;
        fixAfterInsertion(e);
        size++;
        modCount++;
        return null;
    }

這裡判定了是否存在Comparator進行不同方式來寫入不同的位置，並沒有過載方法，所以實現上也不一定有什麼絕對非要如何做，只需要保證程式碼可讀性很好就好，一切為它服務，否則那些過多的設計是屬於過度設計，當然並不是說程式碼設計不重要，但是這些需要適可而止；另外TreeSet裡面對於其他的方法也會做排序處理，我們這裡僅僅是用add方法來做一個例子而已。

相信你對java的排序有了一些瞭解，也許本文說了一堆廢話，因為本文不是在說排序演算法，我們只是告訴你java是如何排序的，你在大部分情況下無需自己寫排序演算法來完成排序導致一些不必要的bug，而且效率未必有java本身提供的排序演算法高效。