Java集合架構和數組的排序

此篇部落客要來自51CTO部落格：http://developer.51cto.com/art/201204/332100.htm

 　　原篇文章存在幾處錯誤，此篇是經過實驗修正版！

　　根據約定，在使用java編程的時候應儘可能的使用現有的類庫，當然你也可以自己編寫一個排序的方法，或者架構，但是有幾個人能寫得比JDK裡的還 要好呢？使用現有的類的另一個好處是代碼易於閱讀和維護，這篇文章主要講的是如何使用現有的類庫對數組和各種Collection容器進行排序，(文章中的一部分例子來自《Java Developers Almanac 1.4》)

　　首先要知道兩個類:java.util.Arrays和java.util.Collections(注意和Collection的區 別)Collection是集合架構的頂層介面，而Collections是包含了許多靜態方法。我們使用Arrays對數組進行排序，使用 Collections對結合架構容器進行排序，如ArraysList,LinkedList等。

　　例子中都要加上import java.util.*和其他外殼代碼，如類和靜態main方法，我會在第一個例子裡寫出全部代碼，接下來會無一例外的省略。

 

　　對數組進行排序

　　比如有一個整型數組：

1. int[] intArray = new int[] {4, 1, 3, -23}; 

　　我們如何進行排序呢？你這個時候是否在想快速排序的演算法？看看下面的實現方法：

1. import java.util.*;  
2. public class Sort{  
3.     public static void main(String[] args){  
4.         int[] intArray = new int[] {4, 1, 3, -23};  
5.         Arrays.sort(intArray);  
6.     }  
7. }  

　　這樣我們就用Arrays的靜態方法sort()對intArray進行了升序排序，現在數組已經變成了{-23,1,3,4}.

　　如果是字元數組:

1. String[] strArray = new String[] {"z", "a", "C"}; 

　　我們用：

1. Arrays.sort(strArray); 

　　進行排序後的結果是{C,a,z}

　　進行排序後的結果是{C,a,z},sort()會根據元素的自然順序進行升序排序。如果希望對大小寫不敏感的話可以這樣寫：

1. Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER); 

　　當然我們也可以指定數組的某一段進行排序比如我們要對數組下表0-2的部分(假設數組長度大於3)進行排序，其他部分保持不變，我們可以使用:

1. Arrays.sort(strArray,0,3); 

　　注意：

sort(double[] a, int fromIndex, int toIndex) 參數： a - 要排序的數組。 fromIndex - 要排序的第一個元素的索引（包括）。 toIndex - 要排序的最後一個元素的索引（不包括）。

　　這樣，我們只對前三個元素進行了排序，而不會影響到後面的部分，結果為{1, 3, 4, -23}。

　　當然有人會想，我怎樣進行降序排序？在眾多的sort方法中有一個

1. sort(T[] a, Comparator<? super T> c) 

　　我們使用Comparator擷取一個反序的比較子即可，Comparator會在稍後講解，以前面的intArray[]為例：

 

 1 public class Sort { 2     public static void main(String[] args) { 3         Integer[] intArray = {4, 1, 3, -23}; 4         Arrays.sort(intArray, new Comparator<Integer>() { 5             public int compare(Integer o1, Integer o2) { 6                 return o2-o1; 7             } 8         }); 9         System.out.println(Arrays.toString(intArray));10     }11 }

 

　　這樣，我們得到的結果就是{4,3,1,-23}。如果不想修改原有代碼我們也可以使用：

1. Collections.reverse(Arrays.asList(intArray)); 

1 public class Sort {2     public static void main(String[] args) {3         Integer[] intArray = {4, 1, 3, -23};4         Arrays.sort(intArray);5         Collections.reverse(Arrays.asList(intArray));6         System.out.println(Arrays.toString(intArray));7     }8 }

　　得到該數組的反序。結果同樣為{4,3,1,-23}。

 

　　現在的情況變了，我們的數組裡不再是基礎資料型別 (Elementary Data Type)(primtive type)或者String類型的數組，而是對象數組。這個數組的自然順序是未知的，因此我們需要為該類實現Comparable介面，比如我們有一個Name類：

 1 class Name implements Comparable<Name>{   2     public String firstName,lastName;   3     public Name(String firstName,String lastName){   4         this.firstName=firstName;   5         this.lastName=lastName;   6     }   7     //實現介面  8     public int compareTo(Name o) {            9         int lastCmp=lastName.compareTo(o.lastName);  10         return (lastCmp!=0?lastCmp:firstName.compareTo(o.firstName));  11     }    12     //便於輸出測試  13     public String toString(){                14         return firstName+" "+lastName;  15     }  16 }

　　這樣，當我們對這個對象數組進行排序時，就會先比較lastName，然後比較firstName 然後得出兩個對象的先後順序，就像compareTo(Name o)裡實現的那樣。不妨用程式試一試：

 1 public class NameSort {   2      public static void main(String[] args) {   3          Name nameArray[] = {   4             new Name("John", "Lennon"),   5             new Name("Karl", "Marx"),   6             new Name("Groucho", "Marx"),   7             new Name("Oscar", "Grouch")   8         };  9         Arrays.sort(nameArray);  10         System.out.println(Arrays.toString(nameArray));;  11     }  12 } 

　　結果正如我們所願：[Oscar Grouch, John Lennon, Groucho Marx, Karl Marx]

 

　　對集合架構進行排序

　　如果已經理解了Arrays.sort()對數組進行排序的話，集合架構的使用也是大同小異。只是將Arrays替換成了Collections,注意Collections是一個類而Collection是一個介面，雖然只差一個"s"但是它們的含義卻完全不同。（Comparator and Comparable及Collections and Collection的用法和區別）

　　假如有這樣一個鏈表：

1. LinkedList list=new LinkedList();  
2. list.add(4);  
3. list.add(34);  
4. list.add(22);  
5. list.add(2); 

　　我們只需要使用:

1. Collections.sort(list); 

　　就可以將ll裡的元素按從小到大的順序進行排序，結果就成了:

1. [2, 4, 22, 34] 

　　如果LinkedList裡面的元素是String，同樣會想基礎資料型別 (Elementary Data Type)一樣從小到大排序。

　　如果要實現反序排序也就是從大到小排序:

1. Collections.sort(list,Collectons.reverseOrder()); 

 1 public class Sort2 { 2     public static void main(String[] args) { 3         LinkedList<Integer> list=new LinkedList<Integer>();   4         list.add(4);   5         list.add(34);   6         list.add(22);   7         list.add(2);  8         Collections.sort(list, Collections.reverseOrder()); 9         System.out.println(list.toString());10     }11 }

　　結果為：[34, 22, 4, 2]

　

　　如果LinkedList裡面的元素是自訂的對象，可以像上面的Name對象一樣實現Comparable介面，就可以讓Collection.sort()為您排序了。

　　如果你想按照自己的想法對一個對象進行排序，你可以使用

1. sort(List<T> list, Comparator<? super T> c) 

　　這個方法進行排序，在給出例子之前，先要說明一下Comparator的使用，Comparable介面的格式：

1. public interface Comparator<T> {  
2.     int compare(T o1, T o2);  
3. }  

　　其實Comparator裡的int compare(T o1,T o2)的寫法和Comparable裡的compareTo()方法的寫法差不多。在上面的Name類中我們的比較是從LastName開始的，這是西方人的習慣，到了中國，我們想從fristName開始比較，又不想修改原來的代碼，這個時候，Comparator就可以派上用場了：

1. final Comparator<Name> FIRST_NAME_ORDER=new Comparator<Name>() {  
2.     public int compare(Name n1, Name n2) {  
3.          int firstCmp=n1.firstName.compareTo(n2.firstName);  
4.          return (firstCmp!=0?firstCmp:n1.lastName.compareTo   
5.                  (n2.firstName));  
6.     }  
7. };  

　　這樣一個我們自訂的Comparator FIRST_NAME_ORDER就寫好了。

　　將上個例子裡那個名字數組轉化為List:

1. List<Name> list=Arrays.asList(nameArray);  
2. Collections.sort(list,FIRST_NAME_ORDER); 

　　這樣我們就成功的使用自己定義的比較子設定排序。