Java集合框架和数组的排序

admin

根据约定，在使用java编程的时候应尽可能的使用现有的类库，当然你也可以自己编写一个排序的方法，或者框架，但是有几个人能写得比JDK里的还要好呢？使用现有的类的另一个好处是代码易于阅读和维护，这篇文章主要讲的是如何使用现有的类库对数组和各种Collection容器进行排序，(文章中的一 部分例子来自《Java Developers Almanac 1.4》)

4 C% f! `+ L. d. m: L5 \, l# q7 t首先要知道两个类:java.util.Arrays和java.util.Collections(注意和Collection的区 别)Collection是集合框架的顶层接口，而Collections是包含了许多静态方法。我们使用Arrays对数组进行排序，使用 Collections对结合框架容器进行排序，如ArraysList,LinkedList等。

例子中都要加上import java.util.*和其他外壳代码，如类和静态main方法，我会在第一个例子里写出全部代码，接下来会无一例外的省略。
0 U0 K) ]2 r* ?6 t( h0 a: p  k
( h5 x6 c, S; z& Z7 Z1 S对数组进行排序

" ^  y6 k1 m" `4 z8 R1 L" y比如有一个整型数组：
1 U3 d4 E* l- o* y
int[] intArray = new int[] {4, 1, 3, -23};
) h; f$ \4 x0 C我们如何进行排序呢？你这个时候是否在想快速排序的算法？看看下面的实现方法：
+ H  s3 ?& {! f$ L
& u- D/ B4 ]3 `7 n& w& Zimport java.util.*;  
public class Sort{  
5 p+ b/ ]/ i! S* B4 `# s! J' X% e8 J. Q    public static void main(String[] args){  
$ m3 z' [( `: W! L. G5 _+ W. K        int[] intArray = new int[] {4, 1, 3, -23};  
        Arrays.sort(intArray);  
    }  
$ ?. o0 m7 V3 J; p}  
; Q$ s4 u8 ]0 Y' B这样我们就用Arrays的静态方法sort()对intArray进行了升序排序，现在数组已经变成了{-23,1,3,4}.
2 [! o  C/ F1 N% N
如果是字符数组:

String[] strArray = new String[] {"z", "a", "C"};
% R% B2 Y$ i; j5 E9 C9 B% d* y, T我们用：

Arrays.sort(strArray);
* F: B  K; A2 t1 u6 W, j进行排序后的结果是{C,a,z},sort()会根据元素的自然顺序进行升序排序。如果希望对大小写不敏感的话可以这样写：

Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);
当然我们也可以指定数组的某一段进行排序比如我们要对数组下表0-2的部分(假设数组长度大于3)进行排序，其他部分保持不变，我们可以使用:
4 ^! R0 p2 O( _  @" D& G
# z. d/ }4 Y. V; S+ |4 W$ pArrays.sort(strArray,0,2);
8 W: }# O, W+ k; E; l这样，我们只对前三个元素进行了排序，而不会影响到后面的部分。

/ p' ~/ N. k. \$ q. x当然有人会想，我怎样进行降序排序？在众多的sort方法中有一个
' B9 f) _7 v% }) I# f  ?
sort(T[] a, Comparator<? super T> c)
0 z' l1 ?, w# Z5 I9 U, {$ t4 |( d我们使用Comparator获取一个反序的比较器即可，Comparator会在稍后讲解，以前面的intArray[]为例：

Arrays.sort(intArray,Comparator.reverseOrder());
这样，我们得到的结果就是{4,3,1,-23}。如果不想修改原有代码我们也可以使用：
; E, l' F, v6 b
Collections.reverse(Arrays.asList(intArray));
; _+ z/ J& `5 h0 m2 h2 D/ g% i得到该数组的反序。结果同样为4,3,1,-23}。
9 }) C+ B/ X( m, V
& M; \) L' x! y$ g现在的情况变了，我们的数组里不再是基本数据类型(primtive type)或者String类型的数组，而是对象数组。这个数组的自然顺序是未知的，因此我们需要为该类实现Comparable接口，比如我们有一个Name类：

5 k) _* K5 I6 {( G. q1 B: z# Gclass Name implements Comparable<Name>{  
    public String firstName,lastName;  
* w9 }- j" H* s6 Y- A% c' L0 k1 M; Z    public Name(String firstName,String lastName){  
. ?1 ~( g4 H7 Z. q6 R1 z! N& M. B: ]( Z        this.firstName=firstName;  
        this.lastName=lastName;  
/ x. h3 n' F( \/ T- c* E    }  
    public int compareTo(Name o) {          //实现接口  
% |: N* z8 h: v8 ^& M$ \        int lastCmp=lastName.compareTo(o.lastName);  
9 w; ~. t/ |3 m& V# o        return (lastCmp!=0?lastCmp:firstName.compareTo(o.firstName));  
    }      
    public String toString(){                //便于输出测试  
. b$ j4 T1 t+ S& O2 l$ j        return firstName+" "+lastName;  
    }  
}  
8 A& c, w" Z- v) V( y" W  S9 P这样，当我们对这个对象数组进行排序时，就会先比较lastName，然后比较firstName 然后得出两个对象的先后顺序，就像compareTo(Name o)里实现的那样。不妨用程序试一试：
4 {" O$ ~( E7 U
# O8 o2 b) |) m9 R$ X! h, h+ G import java.util.*;  
public class NameSort {  
7 C1 _, u. ^! J& `- k. A6 u9 D+ B) U, I     public static void main(String[] args) {  
+ b( Y' G( Q+ H% j7 i         Name nameArray[] = {  
2 R+ V; u( T- E4 U0 f            new Name("John", "Lennon"),  
6 v/ P3 e! J$ q/ {. D9 Y" |% ^1 {            new Name("Karl", "Marx"),  
$ R& F" r2 @( o6 P7 g; a            new Name("Groucho", "Marx"),  
            new Name("Oscar", "Grouch")  
9 C* }( Q- ]( I        };