JAVA认证：Java数组与容器类的分析资料

会计考友

看书的时辰思虑了一个问题，对于java中的array与list有什么样的区别呢？网上找了一篇文章分享下。
+ {7 r( K5 E1 t# U8 g数组是 Java 说话内置的类型，除此之外， Java 有多种保留对象引用的体例。 Java 类库供给了一套相当完整的容器类，使用这些类的体例可以保留和独霸对象。下面分袂进行谈判，在研究Java 容拼荡虍前，先体味一下Java 数组的根基功能和特征。
1. 数组的根基特征
, d. C' p% e# g5 k5 D' h数组与其它种类的容器 （List/Set /Map） 之间的区别在于效率、确定的类型和保留根基类型数据的能力。数组是一种高效的存储和随机访谒对象引用序列的体例，使用数组可以快速的访谒数组中的元素。但 是当建树一个数组对象 （ 注重和对象数组的区别 ） 后，数组的巨细也就固定了，当数组空间不足的时辰就再建树一个新的数组，把旧的数组中所有的引用复制到新的数组中。
8 T# Z$ Z& f, a3 R( dJava 中的数组和容器都需要进行鸿沟搜检，如不美观越界就会获得一个 RuntimeException 异常。这点和 C++ 中有所分歧， C++ 中 vector 的操作符 ［］ 不会做鸿沟搜检，这在速度上会有必然的提高， Java 的数组和容器会因为时刻存在的鸿沟搜检带来一些机能上的开销。
0 P- o9 {. c! v7 K" ~5 LJava 中通用的容器类不会以具体的类型来措置对象，容器中的对象都是以 Object 类型措置的，这是 Java 中所有类的基类。此外，数组可以保留根基类型，而容器不能，它只能保留肆意的 Java 对象。
一般情形下，考虑到效率与类型搜检，应该尽可能考虑使用数组。如不美观要解决一般化的问题，数组可能会受到一些限制，这时可以使用 Java 供给的容器类。
2. 操作数组的适用功能
7 e( `- }  Q$ d9 \* m/ x9 v在 java .util.Arrays 类中，有良多 static 静态体例，供给了操作数组的一些根基功能：
3 X3 M1 z3 t% j( t! Aequals（） 体例 ---- 用于斗劲两个数组是否相等，相等的前提是两个数组的元素个数必需相等，而且对应位置的元素也相等。
6 i6 c3 {) }9 e/ ~fill（） 体例 ---- 用以某个值填衬整个数组，这个体例有点笨。
7 }2 [$ e: W7 d0 V( ?! s  K& \asList（） 体例 ---- 接管肆意的数组为参数，将其改变为 List 容器。
binarySearch（） 体例 ---- 用于在已经排序的数组中查找元素，需要注重的是必需是已经排序过的数组。当 Arrays.binarySearch（） 找到了查找方针时，该体例将返回一个等于或大于 0 的值，否则将返回一个负值，暗示在该数组今朝的排序状况下此方针元素所应该插入的位置。负值的计较公式是 “-x-1” 。 x 指的是第一个大于查找对象的元素在数组中的位置，如不美观数组中所有的元素都小于要查找的对象，则 x = a.size（） 。如不美观数组中包含一再的元素，则无法保证找到的是哪一个元素，如不美观需要对没有频剖ё侏素的数组排序，可以使用 TreeSet 或者 LinkedHashSet 。此外，如不美观使用 Comparator 排序了某个对象数组，在使用该体例时必需供给同样的 Comparator 类型的参数。需要注重的是，根基类型数组无法使用 Comparator 进行排序。
sort（） 体例 ---- 对数组进行升序排序。
1 Q: t' F$ R! s2 G. K2 l' V
1 J+ K. A; V* `" n: @4 \" {在 Java 尺度类库中，还有 static 体例 System.arraycopy（） 用来复制数组，它针对所有类型做了重载。

会计考友

</p>3. 数组的排序
5 i+ j. V' s6 f% q0 ~在 Java1.0 和 1.1 两个版本中，类库贫窭根基的算法操作，搜罗排序的操作， Java2 对此进行了改善。在进行排序的操作时，需要按照对象的现实类型执行斗劲操作，如不美观为每种分歧的类型各自编写一个分歧的排序体例，将会使得代码很难被复用。 一般的轨范设计方针应是“将连结不变的事物与会发改变的事物相分手”。在这里，不变的是通用的排序算法，转变的是各类对象彼此斗劲的体例。
9 j6 I( c2 @7 h3 OJava 有两种体例来实现斗劲的功能，一种是实现 java .lang.Comparable 接口，该接口只有一个 compareTo（） 体例，并以一个 Object 类为参数，如不美观当前对象小于参数则返回负值，如不美观相等返回零，如不美观当前对象大于参数则返回正值。另一种斗劲体例是采用策略 （strategy） 设计模式，将会发生转变的代码封装在它自己的类 （ 策略对象 ） 中，再将策略对象交给连结不变的代滤鱿脯后者使用此策略实现它的算法。是以，可觉得分歧的斗劲体例生成分歧的对象，将它们用在同样的排序轨范中。在此情形 下，经由过程界说一个实现了 Comparator 接口的类而建树了一个策略，这个策略类有 compare（） 和 equals（） 两个体例，一般情形下实现 compare（） 体例即可。
- o- n6 g7 x6 ]( k使用上述两种体例即可对肆意根基类型的数组进行排序，也可以对肆意的对象数组进行排序。再提醒一遍，根基类型数组无法使用 Comparator 进行排序。
Java 尺度类库中的排序算法针对排序的类型进行了优化——针对根基类型设计了“快速排序”，针对对象设计的“不变合并排序”。一般不用担忧其机能。
Java 容器剖析--List和Set
容器类可以大大提高编程效率和编程能力，在Java2 中，所有的容器都由 SUN 公司的 Joshua Bloch 进行了从头设计，丰硕了容器类库的功能。
Java2 容器类类库的用途是“保留对象”，它分为两类：
# n4 b( M6 K3 tCollection ---- 一组自力的元素，凡是这些元素都从命某种轨则。 List 必需连结元素特定的挨次，而 Set 不能有频剖ё侏素。
Map ---- 一构核对的“键值对”对象，即其元素是核对的对象，最典型的应用就是数据字典，而且还有其它普遍的应用。此外， Map 可以返回其所有键组成的 Set 和其所有值组成的 Collection ，或其键值对组成的 Set ，而且还可以像数组一样扩展多维 Map ，只要让 Map 中键值对的每个“值”是一个 Map 即可。
1. 迭代器
迭代器是一种设计模式，它是一个对象，它可以遍历并选择序列中的对象，而开发人员不需要体味该序列的底层结构。迭代器凡是被称为“轻量级”对象， 因为建树它的价钱小。
Java 中的 Iterator 功能斗劲简单，而且只能单向移动：
  d/ D0 j" z  c# |$ N（1） 使用体例 iterator（） 要求容器返回一个 Iterator 。第一次挪用 Iterator 的 next（） 体例时，它返回序列的第一个元素。
" J9 g0 c% l) X$ e5 {（2） 使用 next（） 获得序列中的下矣闽元素。
2 I: P- H* R% i; ]% f" |（3） 使用 hasNext（） 搜检序列中是否还有元素。
! P3 ?0 h, N8 i. _（4） 使用 remove（） 将迭代器新返回的元素删除。


Iterator 是 Java 迭代器最简单的实现，为 List 设计的 ListIterator 具有更多的功能，它可以从两个标的目的遍历 List ，也可以从 List 中插入和删除元素。
2.List 的功能体例
List（interface）： 顺序是 List 最主要的特点；它确保维护元素特定的挨次。 List 为 Collection 添加了良多体例，使得能够向 List 中心插入与移除元素 （ 只举荐 LinkedList 使用 ） 。一个 List 可以生成 ListIterator ，使用它可以从两个标的目的遍历 List ，也可以从 List 中心插入和删除元素。
7 y! _: K9 k; j: ~. A+ ^ArrayList： 由数组实现的 List 。它许可对元素进行快速随机访谒，可是向 List 中心插入与移除元素的速度很慢。 ListIterator 只应该用出处后向前遍历 ArrayList ，而不是用来插入和删除元素，因为这比 LinkedList 开销要大良多。
  _9 m, k  \) w! T" u. C) zLinkedList： 对挨次访谒进行了优化，向 List 中心插入与删除得开销不大，随机访谒则相对较慢 （ 可用 ArrayList 庖代 ） 。它具有体例 addFirst（） 、 addLast（） 、 getFirst（） 、 getLast（） 、 removeFirst（） 、 removeLast（） ，这些体例 （ 没有在任何接口或基类中界说过 ） 使得 LinkedList 可以算作仓库、队列和双向队列使用。
3.Set 的功能体例
6 X) S( s) u! ?5 rSet （interface）： 存入 Set 的每个元素必需是独一的，因为 Set 不保留频剖ё侏素。插手 Set 的 Object 必需界说 equals（） 体例以确保对象的独一性。 Set 与 Collection 有完全一样的接口。 Set 接口不保证维护元素的顺序。
- _8 k+ g: z( L/ vHashSet： 为快速查找而设计的 Set 。存入 HashSet 的对象必需界说 hashCode（） 。
TreeSet： 连结顺序的 Set ，底层为树结构。使用它可以从 Set 中提取有序的序列。
LinkedHashSet： 具有 HashSet 的发芽速度，且内部使用链表维护元素的挨次 （ 插入的顺序 ） 。于是在使用迭代器遍历 Set 时，结不美观会按元素插入的顺序显示。
% y$ z7 h( E; S+ Z1 X" f3 CHashSet 采用散列函数对元素进行排序，这是专门为快速发芽而设计的； TreeSet 采用红黑树的数据结构进行排序元素； LinkedHashSet 内部使用散列以加速发芽速度，同时使用链表维护元素的顺序，使得看起来元素是以插入的挨次保留的。需要注重的是，生成自己的类时， Set 需要维护元素的存储挨次，是以要实现 Comparable 接口并界说 compareTo（） 体例。
Java 容器剖析--Map
  e0 y+ B# J6 y  C6 Y0 i尺度的Java 类库中包含了几种类型的 Map ，它们都拥有同样的根基接口 Map ，可是行为特征各不不异，首要默示在效率、键值对的保留、元素呈现顺序、对象的保留周期和剖断键是否等价的策略等方面。
0 f- T% x2 Y7 ^" E8 z9 K1.Map 的功能体例
Map（interface）： 维护 label 和 value 的联系关系性，使得可以经由过程 label 查找 value 。
  t- b9 A5 F2 {$ |5 zHashMap： Map 基于散列表的实现，庖代了 Hashtable 。插入和发芽 label/value 的开销是固定的，而且可以经由过程机关器设置容量和负载因子，根柢整容器的机能。
LinkedHashMap： 在 HashMap 的基本上做了一些改良，在迭代遍历它时，取得 label/value 的挨次是其插入的顺序，或者是比来起码使用 （LRU） 的顺序，速度上比 HashMap 要慢一点，但在迭代访谒时速度会更快，首要原因是它使用了链表维护内部顺序。
TreeMap： 查看 label 或 label/value 时，元素会被排序，其顺序由 Comparable 或 Comparator 抉择，是以发芽所获得的结不美观是经由排序的。此外，它是独一带有 subMap（） 体例的 Map 具体类，即返回一个子树。它也是 SortedMap 接口的独一实现， subMap（） 体例也是从该接口担任的。
8 H5 X& D: b) Z$ r) g8 bWeakHashMap： Weak Key 映射，许可释放映射所指向的对象。当映射之外没有引用指向某个 label 时，此 label 可以被垃收受接管集器收受接管。
IdentityHashMap： 使用 == 庖代 equals（） 对 label 进行斗劲的散列映射。
' }" V2 G% W/ v' \* Q" B3 Q" w) {2.hashCode（）
当使用尺度库中的类 Integer 作为 HashMap 的 label 时，轨范能够正常运行，可是使用自己建树的类作为 HashMap 的 label 时，凡是犯一个错误。
在 HashMap 中经由过程 label 查找 value 时，现实上是计较 label 对象地址的散列码来确定 value 的。一般情形下，我们是使用基类 Object 的体例 hashCode（） 来生成散列码，它默认是使用对象的地址来计较的，是以由第一个对象 new Apple（5） 和第二个对象 new Apple（5） 生成的散列码是分歧的，不能完成正确的查找。凡是，我们可以编写自己的 hashCode（） 体例来笼盖基类的原始体例，但与此同时，我们必需同时实现 equals（） 体例来判定当前的 label 是否与表中存在的 label 不异。正确的 equals（） 体例知足五个前提：
9 O! i9 C8 G* E* I1 h! M7 I（1） 自反性。对于肆意的 x ， x.equals（x） 必然返回 true 。
（2） 对称性。对于肆意的 x 和 y ，如不美观 y.equals（x） 返回 true ，则 x.equals（y） 也返回 true 。
（3） 传递性。对于肆意的 x 、 y 、 z ，如不美观有 x.equals（y） 返回 true ， y.equals（z） 返回 true ，则 x.equals（z） 必然返回 true 。
（4） 一致性。对于肆意的 x 和 y ，如不美观对象顶用于等价斗劲的信息没有改变，那么无论挪用 x.equals（y） 若干好多次，返回的结不美观应该连结一致，要么一向是 true ，要么一向是 false 。
（5） 对任何不是 null 的 x ， x.equals（null） 必然返回 false 。
  @( m; o# n$ p- Z

1.使用散列的目的：想要使用一个对象来查找另一个对象。使用 TreeSet 或 TreeMap 也能实现此目的。此外，还可以自己实现一个 Map ，此时，必需供给 Map.entrySet（） 体例来生成 Map.Entry 对象的 Set 。
2.使用散列的价值：速度，散列使得发芽可以快速进行。散列将 label 保留载数组中便利快速发芽，因为存储一组元素最快的数据结构是数组，用它来暗示 label 的信息 （ 后面有信息的描述 ） ，而不是 label 自己。经由过程 label 对象计较获得一个数字，作为数组的下标，这个数字就是散列码 （ 即前面所述的信息 ） 。该散列码具体是经由过程界耸ё仝基类 Object 中，可能由轨范员自界说的类笼盖的 hashCode（） 体例，即散列函数生成。为体味决数组容量带来的限制，可以使分歧的 label 生成不异的下标，保留在一个链表 list 中，每一个链表就是数组的一个元素。发芽 label 时就可以经由过程对 list 中的信息进行查找，当散列函数斗劲好，数组的每个位置中的 list 长度较短，则可以快速查找到数组元素 list 中的某个位置，提高了整体速度。
2 k# {; F4 B9 A9 }1 o散列表中的 slot 凡是称为 bucket ，为了使散列分步平均， bucket 的值一般取质数。但事实证实，质数现实上并不是散列 bucket 的理想容量，迩来 Java 散列实现都使用 2 的幂，具体若何验证往后再续。
3.HashMap 的机能因子
: w- I4 P# j% S% E# }# P# N3 c7 r容量 （capacity）： 散列表中 bucket 的数目。
; p/ i2 k* W6 d# l; H5 o4 v: `6 q% K初始化容量 （initial capacity）： 建树散列表时 bucket 的数目。可以在机关体例中指定 HashMap 和 HashSet 的初始化容量。
尺寸 （size）： 散列表中记实的数目。 （ 数组的元素个数，非 list 中元素总和 ）

负载因子 （load factor）： 尺寸 / 容量。负载因子为 0 ，暗示空的散列表， 0.5 暗示半满的散列表。轻负载的散列表具有冲突少，适宜插入与发芽的特点，可是使用迭代器遍历会斗劲慢。较高的负载会削减所需空间巨细。当负载达到指定制瘫， 容器会自动成倍地增添容量，并将原有的对象从头分配，存入新的 bucket 中，这个过程称为“重散列”。

会计考友

</p>4. 重写 hashCode（） 的关头
（1） 对统一个对象挪用 hashCode（） 都应该生成同样的值。
$ Q* Y' |+ f* V+ U  i" U（2） hashCode（） 体例不要依靠于对象中易变的数据，当数据发生转变时， hashCode（） 就会生成一个分歧的散列码，即发生了一个分歧的 label 。
# r4 a% h) u0 E: A（3） hashCode（） 不应依靠于具有独一性的对象信息，例如对象地址。
（4） 散列码应该更关心速度，而不是独一性，因为散列码不必是独一的。
（5） 好的 hashCode（） 应该发生分步平均的散列码。在 Effective Java （Addison-Wesley 2001） 中， Joshua Bloch 给 hashCode（） 给出了设计指导，可以参考。
, z0 k4 R! P9 d. h4 R5 w/ p2 ]  m编写正确高效的 hashCode（） 和 equals（） 可以参考 Apache 的 Jakarta Commons 项目中的工具。
! u9 v6 G- S4 W/ `+ }$ yjava 集结类总结
对象的集结
3 y( \0 A: X4 H2 ~/ N7 y4 n' v. g如不雅察看序的对象数目有限，且寿命可知，那么这个轨范是相当简单的。
5 h1 k* F7 _/ M: E; d% B! \$ Z! L数组
2 F. _& p% P6 C" X数组与其它容器的区别表此刻三个方面：效率，类型识别以及可以持有primitives。数组是Java 供给的，能随机存储和访谒reference序列的诸多体例中的，最高效的一种。数组是一个简单的线性序列，所有它可以快速的访谒其中的元素。可是速度是 有价钱的；当你建树了一个数组之后，它的容量就固定了，而且在其生命周期里不能改变。也许你会提议先建树一个数组，等到快不够用的时辰，再建树一个新的， 然后将旧的数组里的reference全数导到新的琅缦沔。其实（我们往后会讲的）ArrayList就是这么做的。可是这种矫捷性所带来的开销，使得 ArrayList的效率比起数组有了较着下降。
9 u/ P6 [; ]. kJava 对数组和容器都做鸿沟搜检；如不美观过了界，它旧会给一个RuntimeException。这种异常剖明这个错误是由轨范员造成的，这样你就用不着再在轨范 琅缦沔搜检了。
7 D' ?8 l  \9 o3 }% |还有一些泛型容器类搜罗List，Set 和Map。他们措置对象的时辰就仿佛这些对象都没有自己的具体类型一样。也就是说，容器将它所含的元素都算作是（Java 中所有类的根类）Object的。这样你只需要建一种容器，就能把所有类型的对象全都放进去。从这个角度来看，这种做法很不错（只是苦了 primitive。如不美观是常量，你还可以用Java 的 primitive的Wrapper类；如不美观是变量，那就只能放在你自己的类里了）。与其他泛型容器对比，这里浮现数组的第二革优势：建树数组的时辰，你 也同时指了然它所持有的对象的类型（这又引出了第三点－－数组可以持有primitives，而容器却不行）。也就是说，它会在编译的时辰作类型搜检，从 而防止你插入错误类型的对象，或者是在提取对象的时辰把对象的类型给搞错了。Java 在编译和运行时都能阻止你将一个不适当的动静传给对象。所有这并不是说使用容器就有侍趵恚险，只是如不美观编译器能够帮你指定，那么轨范运行会更快，最终用户 也会较少收到轨范运行异常的骚扰。
从效率和类型搜检的角度来看，使用数组老是没错的。可是，如不美观你在解决一个更为一般的问题，那数组就会显得功能太弱了点。


' J1 \8 U3 a6 D& ?+ D数组是第一流的对象
不管你用的是那种类型的数组，数组的标识符现实上都是一个“建树在堆（heap）里的实其适ё仝的对象的”reference。现实上是阿谁对象持 有其他对象的reference。你即可以用数组的初始化语句，隐含地建树这个对象，也可以用new表达式，明晰地建树这个对象，只读的length属性 能告诉你数组能存储若干好多元素。它是数组对象的一部门（现实上也是你独一能访谒的属性或体例）。‘［］’语法是另一条访谒数组对象的路子。
6 b: w: |& K/ w' Q你没法知道数组琅缦沔事实放了若干好多元素，因为length只是告诉你数组能放若干好多元素，也就是说是数组对象的容量，而不是它真正已经持有的元素的数 量。可是，建树数组对象的时辰，它所持有的reference城市被自动地初始化为null，所以你可以经由过程搜检数组的某个 “槽位”是否为null，来判定它是否持有对象。以此类推，primitive的数组，会自动来数字初始化为零，字符初始化为 （char）0，boolean初始化为false。
3 k0 E1 e- l4 h3 h; _# zprimitive容器
" v1 m% P" a; m3 X容拼荡蚧能持有Object对象的reference。而数组除了能持有Objects的reference之外，还可以直接持有 primitive。当然可以使用诸如Integer，Double之类的wrapper类。把primitive的值放到容器中，淡这样总有点滔滔的。 此外， primitive数组的效率要比wrapper类容器的超出跨越良多。
当然，如不美观你使用primitive的时辰，还需要那种“能随需要自动扩展的”容器类的矫捷性，那就不能用数组了。你只能用容器来存储 primitive的wrapper类。
' n: d5 X) e0 f, @% [/ U' j返回一个数组
假设你写了一个体例，它返回的不是一个而是一组工具。那么在Java 中就可以返回的“就是一个数组”。与C++分歧，你永远也不必为Java 的数组费心－－只要你还需要它，它就还在；一旦你用完了，垃圾收受接管器会帮你把它扫除清洁。
Arrays类
java .util 琅缦沔有一个Arrays类，它搜罗了一组可用于数组的static体例，这些体例都是一些适用工具。其中有四个根基体例：用来斗劲两个数组是否相等的 equals（）；用来填充的fill（）；用来对数组进行排序的sort（）；以及用于在一个已排序的数组中查找元素的 binarySearch（）。所有这些体例都对primitive和Object进行了重载。此外还有一个asList（）体例，它接管一个数组，然后 把它转成一个List容器。
; v) _: b3 z3 l虽然Arrays仍是有用的，但它的功能并不完整。举例来说，如不美观它能让我们不用写for轮回就能直接打印数组，那就好了。此外，正如你所看到的 fill（）只能用一个值填数组。所以，如不美观你想把随即生成的数字填进数组的话，fill（）是力所不及的。
复制一个数组
6 X" q/ i# H4 eJava 尺度类库供给了一个System.arraycopy（）的static体例。对比for轮回，它能以更快的速度拷贝数组。 System.arraycopy（）对所有类型都作了重载。
对象数组和primitive数组都能拷贝。可是如不美观你拷贝的是对象数组，那么你只拷贝了它们的reference－－对象自己不会被拷贝。这被 成为浅拷贝（shallow copy）。
数组的斗劲
为了能斗劲数组是否完全相等，Arrays供给了经重载的equals（）体例。当然，也是针对各类primitive以及 Object的。两个数组要想完全相等，他们必需有不异数目的元素，而且数组的每个元素必需与另一个数组的相对应的位置上的元素相等。元素的相等姓，用 equals（）判定。（对于 primitive，它会使用其wrapper类的equals（）；好比int使用Integer.equals（）。）。
数组元素的斗劲
) r' n0 b7 {1 v# F- r& L: @Java 琅缦沔有两种能让你实现斗劲功能的体例。一是实现java .lang.Comparable 接口，并以此实现类“自有的”斗劲体例。这是一个很简单的接口，它只有一个体例compareTo（）。这个体例能接管另一个对象作为参数，如不美观现有对象 比参数小，它就会返回一个负数，如不美观不异则返回零，如不美观现有的对象比参数大，它就返回一个正数。
static randInt（）体例会生成一个介于0到100之间的正数。
6 ^8 j6 ^, ~9 B: f/ y此刻架设，有人给你一个没有实现Comparable接口的类，或者这个类实现了Comparable接口，可是你发现它的工作体例不是你所但愿 的，于是要从头界说一个新的斗劲体例。Java 没有强求你必然要把斗劲代码塞进类里，它的解决方案是使用“策略模式（strategy design pattern）”。有了策略之后，你就能把会变的代码封装到它自己的类里（即所谓的策略对象strategy object）。你把策略对象交给不会变的代码，然后用它运用策略完成整个算法。这样，你就可以用分歧的策略对象来暗示分歧的斗劲体例，然后把它们都交给 统一个排序轨范了。接下来就要“经由过程实现Comparator接口”来界说策略对象了。这个接口有两个体例compare（）和equals（）。可是除 非是有非凡的机能要求，否则你用不着去实现equals（）。因为只若是类，它就都隐含地担任自Object，而Object琅缦沔已经有了一个 equals（）了。所以你尽可以使用缺省的Object的equals（），这样就已经知足接口的要求了。
Collections类里专门有一个会返回与对象自有的斗劲法相反的Comparator的体例。它能很等闲地被用到CompType膳缦沔。
& t, U/ \4 A4 q) z. X, L9 D9 CCollections.reverseorder（）返回了一个Comparator的reference。
compare（）体例会按照第一个参数是小于，等于仍是大于第二个参数，分袂返回负整数，零或是正整数。
数组的排序
有了内置的排序体例之后，你就能对任何数组排序了，非论是primitive的仍是对象数组的，只要它实现了Comparable接口或有一个与 之相关的Comparator对象就行了。
Java 尺度类库所用的排序算法已经作了优化－－对primitive，它用的是“快速排序（Quicksort）”，对对象，它用的是“不变合并排序 （stable merge sort）”。所以除非是prolier剖明排序算法是瓶颈，否则你不用为机能担忧。
发芽有序数组
一旦数组排完序，你就能用Arrays.binarySearch（）进行快速发芽了。可是切忌对一个尚未排序的数组使用 binarySearch（）；因为这么做的结不美观是没意义的。
如不美观Arrays.binarySearch（）找到了，它就返回一个大于或等于0的值。否则它就返回一个负值，而这个负值要表达的意思是，如不美观 你手动维护这个数组的话，这个值应该插在哪个位置。