|
该用户从未签到
|
根据约定,在使用java编程的时候应尽可能的使用现有的类库,当然你也可以自己编写一个排序的方法,或者框架,但是有几个人能写得比JDK里的还要好呢?使用现有的类的另一个好处是代码易于阅读和维护,这篇文章主要讲的是如何使用现有的类库对数组和各种Collection容器进行排序,(文章中的一 部分例子来自《Java Developers Almanac 1.4》)
3 V0 c7 E& K7 j/ t/ _3 A3 S' S+ _- p; R
首先要知道两个类:java.util.Arrays和java.util.Collections(注意和Collection的区 别)Collection是集合框架的顶层接口,而Collections是包含了许多静态方法。我们使用Arrays对数组进行排序,使用 Collections对结合框架容器进行排序,如ArraysList,LinkedList等。3 w3 M$ ]0 |+ I1 M7 j0 P6 u A
5 _8 X5 i2 V9 f0 Y* w! e
例子中都要加上import java.util.*和其他外壳代码,如类和静态main方法,我会在第一个例子里写出全部代码,接下来会无一例外的省略。
: c5 D; |+ c* ]8 C8 H1 d6 t8 v% {& [; E& t
对数组进行排序. C9 i1 g O% f+ m; _" U; D4 ^
% k- f& M- G. _* `比如有一个整型数组:% i9 X: T7 k8 M0 T% `9 `
$ r) B8 ^1 D1 n( g) I
int[] intArray = new int[] {4, 1, 3, -23}; - [. I+ E: \( ^1 m$ f
我们如何进行排序呢?你这个时候是否在想快速排序的算法?看看下面的实现方法:! k7 n! |) I6 t; y" t5 r* z
: g- b) Z' B( L9 b$ x
import java.util.*;
' t( s7 k* V9 Z' H4 @public class Sort{
& F/ I' B4 {% U' J/ K% f public static void main(String[] args){ % J0 A/ N9 L* _0 w" R
int[] intArray = new int[] {4, 1, 3, -23};
W% F5 R- I! k9 b Arrays.sort(intArray); ( s: V1 v! t9 U9 E Z/ [
} ' k3 {& ]& Z" x3 { N, G5 t/ X
}
0 {3 |6 b8 D% V9 D这样我们就用Arrays的静态方法sort()对intArray进行了升序排序,现在数组已经变成了{-23,1,3,4}.
& v/ a8 F' V! g% K, N# T! N1 p( Q$ t: m, f( o0 ]0 _% S
如果是字符数组:
8 t! Q0 t9 t8 M- Z9 U- @5 f% u+ J$ Y" U+ t
String[] strArray = new String[] {"z", "a", "C"};
u( W, ^2 n4 v我们用:
: u% \/ u0 F& F* K
' J9 d3 V, M' l4 E* }5 _% C# KArrays.sort(strArray); & J8 p2 a; d6 V9 G9 S" W3 M+ i$ z
进行排序后的结果是{C,a,z},sort()会根据元素的自然顺序进行升序排序。如果希望对大小写不敏感的话可以这样写:* z& y# r0 m% R9 X( k! v
" X, L! ]8 k0 s0 EArrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);
: a7 u k8 ~# o, }: k当然我们也可以指定数组的某一段进行排序比如我们要对数组下表0-2的部分(假设数组长度大于3)进行排序,其他部分保持不变,我们可以使用:5 Y" @: P( m9 o# D
% R- f, h) X+ b- ?* xArrays.sort(strArray,0,2);
9 n. u5 [' _! R6 s这样,我们只对前三个元素进行了排序,而不会影响到后面的部分。
/ t2 A! P4 Y4 l* ~& `5 K% c& |) f" F' W) j
当然有人会想,我怎样进行降序排序?在众多的sort方法中有一个
. \* F! Y( U' ~6 j0 t' }3 e X# E. M4 o& g! r2 f& o4 C; o1 A
sort(T[] a, Comparator<? super T> c) ; A/ h0 ^( [/ w, l
我们使用Comparator获取一个反序的比较器即可,Comparator会在稍后讲解,以前面的intArray[]为例:
' N N5 I; a9 d8 V& p) H
. |& U( h6 z8 SArrays.sort(intArray,Comparator.reverseOrder()); 3 H3 a8 b0 i6 _( m! c# ], p
这样,我们得到的结果就是{4,3,1,-23}。如果不想修改原有代码我们也可以使用:
& x% B* n: F( f! C3 n3 N% ]. s2 L* Q X6 j' j
Collections.reverse(Arrays.asList(intArray));
" @) v2 Y; J$ y* |% `6 s得到该数组的反序。结果同样为4,3,1,-23}。
% x) q/ e' T$ x0 F" R- @8 g- ]* o8 J! J0 H9 `" D
现在的情况变了,我们的数组里不再是基本数据类型(primtive type)或者String类型的数组,而是对象数组。这个数组的自然顺序是未知的,因此我们需要为该类实现Comparable接口,比如我们有一个Name类:
8 x$ h" H5 h8 f/ v2 R) l/ i& }
% r3 I6 ^, D- W" _& }( ]' z* P rclass Name implements Comparable<Name>{
0 r4 ~, l( _* V1 t public String firstName,lastName; " u' O( D% `: z; k# l, @6 d
public Name(String firstName,String lastName){
, e+ N- C# H: B. J3 F this.firstName=firstName; ! a, p5 y5 G! X
this.lastName=lastName;
4 |6 J; \" J4 M$ B3 I) e. u, j }
& K3 ?$ h% ^9 C+ c5 Z, S% @ public int compareTo(Name o) { //实现接口 * A* M( s5 i) ^' D5 F+ d: z) X
int lastCmp=lastName.compareTo(o.lastName);
' e6 J* g! G- d- t# b return (lastCmp!=0?lastCmp:firstName.compareTo(o.firstName)); 5 K# W1 Y; q! J! _6 ?
}
8 f- i$ C2 E9 o public String toString(){ //便于输出测试 ; I- E$ F; A3 _! v! y' g9 I E( x9 _( g
return firstName+" "+lastName; ( L" r4 R7 R- f( f
} 2 k5 N# q3 X) l! u7 j
}
6 ?% Z7 z7 O2 N/ N/ ?. o1 @4 G; z! J这样,当我们对这个对象数组进行排序时,就会先比较lastName,然后比较firstName 然后得出两个对象的先后顺序,就像compareTo(Name o)里实现的那样。不妨用程序试一试:
! s/ l( c/ i+ |- }: m' }
! l, I3 T& K8 n. W# Y( p- i4 Y( k import java.util.*; 1 e: P2 ~& @* l1 ?& l' U
public class NameSort { 4 D5 G- c! l; c* g/ n7 Z) k
public static void main(String[] args) { * C: H3 R5 g( F% I1 N* a9 {6 [ D
Name nameArray[] = {
, g: K: i2 e! S new Name("John", "Lennon"), 6 D" [8 V1 r. g: p5 ~) q$ d
new Name("Karl", "Marx"),
6 e# a: ]$ s$ N( n! X$ v% l l new Name("Groucho", "Marx"), 8 W& P/ D, ^! @$ r% ~
new Name("Oscar", "Grouch")
6 ~. n; [- ~6 ~ n/ W, F- F B }; |
|