Java集合框架和数组的排序

admin

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

首先要知道两个类:java.util.Arrays和java.util.Collections(注意和Collection的区 别)Collection是集合框架的顶层接口，而Collections是包含了许多静态方法。我们使用Arrays对数组进行排序，使用 Collections对结合框架容器进行排序，如ArraysList,LinkedList等。
0 h' V( ]  l% |3 l) a$ Y
7 V1 R. _6 S) {+ ?0 M3 {& b例子中都要加上import java.util.*和其他外壳代码，如类和静态main方法，我会在第一个例子里写出全部代码，接下来会无一例外的省略。
8 V" s! K0 G4 _7 p. L0 \* A7 _( g
对数组进行排序

# N% q; v/ N6 z  V! H- @比如有一个整型数组：
; W8 G' }- c( c! X3 K5 X( o* G+ D
int[] intArray = new int[] {4, 1, 3, -23};
# t9 y; H3 ~' f; q' R" t7 R+ W; m我们如何进行排序呢？你这个时候是否在想快速排序的算法？看看下面的实现方法：
0 k+ j$ `! }2 x
import java.util.*;  
, m8 n+ s0 u8 Lpublic class Sort{  
) m) W/ m' L8 u; @4 l. S  u    public static void main(String[] args){  
        int[] intArray = new int[] {4, 1, 3, -23};  
        Arrays.sort(intArray);  
$ j; T" R9 G8 u0 _- w8 G  N; g, z$ m    }  
/ ]' j; n* w$ U. W. p( q3 y+ Y}  
这样我们就用Arrays的静态方法sort()对intArray进行了升序排序，现在数组已经变成了{-23,1,3,4}.

如果是字符数组:

+ @, s3 S2 Z) _0 o# mString[] strArray = new String[] {"z", "a", "C"};
6 @3 z- B( n# @( x$ s6 @我们用：
3 Y1 f& G; `2 `; n" W% o  D6 j
Arrays.sort(strArray);
进行排序后的结果是{C,a,z},sort()会根据元素的自然顺序进行升序排序。如果希望对大小写不敏感的话可以这样写：
2 r, n% J! X6 V( A9 Q: y
& x- w9 q' ?" d! o5 S% F/ ZArrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);
3 K# t: t; E# X6 f/ E+ v( {  `当然我们也可以指定数组的某一段进行排序比如我们要对数组下表0-2的部分(假设数组长度大于3)进行排序，其他部分保持不变，我们可以使用:

Arrays.sort(strArray,0,2);
1 O% \- N7 t8 A, {" _这样，我们只对前三个元素进行了排序，而不会影响到后面的部分。

1 b8 L0 I; }8 u$ M, M6 j4 d% t' \4 Y& x当然有人会想，我怎样进行降序排序？在众多的sort方法中有一个

/ ^  P7 u" L! w/ T; ~) V4 r- b4 tsort(T[] a, Comparator<? super T> c)
6 b8 ?. s% ^. i我们使用Comparator获取一个反序的比较器即可，Comparator会在稍后讲解，以前面的intArray[]为例：
3 W3 Q. _9 D6 a
Arrays.sort(intArray,Comparator.reverseOrder());
* m; J: ^3 n( R" M& O5 n7 y/ W这样，我们得到的结果就是{4,3,1,-23}。如果不想修改原有代码我们也可以使用：

Collections.reverse(Arrays.asList(intArray));
; [* i9 s' Z; P- l; k' ?* A. V得到该数组的反序。结果同样为4,3,1,-23}。
) R) n& ^+ k& z8 y$ g; y/ M7 `
现在的情况变了，我们的数组里不再是基本数据类型(primtive type)或者String类型的数组，而是对象数组。这个数组的自然顺序是未知的，因此我们需要为该类实现Comparable接口，比如我们有一个Name类：

class Name implements Comparable<Name>{  
3 r0 q6 A2 s/ L    public String firstName,lastName;  
6 v  {/ X! U+ ^; [5 Q    public Name(String firstName,String lastName){  
7 |- J4 [( S8 m) d0 d" E        this.firstName=firstName;  
9 W6 ]3 }0 P" _- p* F5 D& A& H0 R        this.lastName=lastName;  
    }  
    public int compareTo(Name o) {          //实现接口  
# u! P% C+ p3 ]& y$ d# M        int lastCmp=lastName.compareTo(o.lastName);  
        return (lastCmp!=0?lastCmp:firstName.compareTo(o.firstName));  
- z9 ]4 N- H: ]2 [6 E" w    }      
    public String toString(){                //便于输出测试  
        return firstName+" "+lastName;  
    }  
) `7 Q6 M$ \* m, x& {* z}  
这样，当我们对这个对象数组进行排序时，就会先比较lastName，然后比较firstName 然后得出两个对象的先后顺序，就像compareTo(Name o)里实现的那样。不妨用程序试一试：

import java.util.*;  
public class NameSort {  
     public static void main(String[] args) {  
         Name nameArray[] = {  
            new Name("John", "Lennon"),  
            new Name("Karl", "Marx"),  
            new Name("Groucho", "Marx"),  
1 B5 k5 `3 }- t- s+ X( n5 ^            new Name("Oscar", "Grouch")  
        };