Java编程手冊-Collection框架（上）

朱雀 2021-09-17 13:16 288阅读 0赞

**该文章所讲内容基本涵盖了Collection里面的全部东西，尽管基于jdk 1.5的。可是思路非常清晰**

**1.引言  
1.1 Collection框架的介绍**

尽管我们能够使用数组去存储具有同样类型的元素集合(包含基本类型和对象类型)，可是数组不支持所谓的动态内存分配，一旦分配之后，它的长度就是固定的，无法改变，另外，数组是一个简单的线性结构。在我们的实际开发中，可能会须要更复杂的数据结构。比如linked list, stack, hash table, sets, 或者 trees.

在Java中，有统一的Collection框架来支持这样的动态分配的数据结构（比如：ArrayList, LinkedList, Vector, Stack, HashSet, HashMap, Hashtable），它通过接口统一了全部继承类的基本操作，形成了一套主要的体系。

Java集合框架包(java.util)里包括以下内容：

1、接口集合  
2、类实现  
3、算法（比如排序和查找）

**1.2 Colloction样例— ArrayList (Pre-JDK 1.5)**

ArrayList是一个线性的数据结构，类似于数组。可是它是可伸缩的。

以下使用了ArrayList来存放String集合对象。

// Pre-JDK 1.5
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Iterator;
     
    public class ArrayListPreJDK15Test {
       public static void main(String[] args) {
          List lst = new ArrayList();  // A List contains instances of Object. Upcast ArrayList to List
          lst.add("alpha");            // add() takes Object. String upcast to Object implicitly
          lst.add("beta");
          lst.add("charlie");
          System.out.println(lst);     // [alpha, beta, charlie]
     
          // Get a "iterator" instance from List to iterate thru all the elements of the List
          Iterator iter = lst.iterator();
          while (iter.hasNext()) {      // any more element
             // Retrieve the next element, explicitly downcast from Object back to String
             String str = (String)iter.next();
             System.out.println(str);
          }
       }
    }

**程序分析**

*  2-4行引入了java.util包中集合框架的类和接口

![20160329155105749][]

上图能够看到ArrayList的继承关系。我们能够看到ArrayList实现了List, Collection 和 Iterable接口。Collection和Iterable接口定义了全部集合都须要实现的基本操作。Collection接口定义了怎样加入和移除一个元素。Iterable接口定义了一种机制去遍历集合中的全部元素。

一般不直接使用Collection接口，而是使用它的子接口List(支持索引訪问的有序列表)、Set(不同意元素的反复)、Queue(先进先出)。

*  在第8行中。创建了一个ArrayList实例。并将它向上转换为List接口，由于ArrayList实现了List接口，一般比較良好的编程操作都是在接口上面，而不是在它的实现上面。Collection框架提供了一个接口集合，这样你能够使用这些接口而不是它的实现。
    
      
    
 *  Collection接口定义了一些对主要的操作方法。

// Pre-JDK 1.5
    boolean add(Object element)     // adds an element
    boolean remove(Object element)  // removes an element
    int size()                      // returns the size
    boolean isEmpty()               // checks if empty</span>

能够看到。在pre-JDK 1.5上，add(Object)方法操作的是Object对象，Object类是全部类的超类，因此，全部类都是Object类的子类，不论什么Java类都能够向上转换为Object类。然后加入到集合中，而且这个转换是编译器隐式操作的。它是类型安全的。

*  Iterable接口包括一个抽象方法去获取集合所关联的Iterator对象，这样通过Iterator对象就能够遍历整个集合。

Iterator iterator();   // returns an Iterator object to iterate thru all the elements of the collection

*  Iterator声明了以下的抽象方法进行集合遍历

// Pre-JDK 1.5
    boolean hasNext()  // returns true if it has more elements
    Object next()      // returns the next element
    void remove()      // removes the last element returned by the iterator</span>

*  第15-20行获取ArrayList相关联的Iterator对象，而且使用while循环来遍历集合。  
    
 *  在18行，`iter.next()` 方法方法返回的是Object类型的对象。这个在上面add(Object)中说过，我们在得到Object类型的对象之后，须要显式的将类型转换为String类型，由于编译器不知道我们须要的详细类型。
 *  事实上我们也能够使用LinkedList, Vector 和 Stack。而且仅仅须要改动第8行的实例化代码就可以，其它不变，这也能够看出接口的统一性。尽管实现不同，可是操作的效果同样。

List lst = new LinkedList();   // use "LinkedList" implementation
    // or
    List lst = new Vector();       // use "Vector" implementation
    // or
    List lst = new Stack();        // use "Stack" implementation

**1.3  Pre-JDK 1.5 Collections不是类型安全的**

Pre-JDK 1.5存在以下的缺陷：

1、编译器会将元素隐式地向上转换为java.lang.Object，可是当我们获取元素的时候，我们获取的就是java.lang.Object类型的对象，我们须要显式的将它向下转换为我们的原始类型。  
2、编译器不能在编译时检查向下转换的有效性。错误的向下转换会在执行是抛出ClassCastException异常。

这两个问题事实上在上面代码的分析过程中也说到过，缺陷也非常明显。

// lst is designed to hold Strings
    lst.add(new Integer(88));  // adds an Integer, implicitly upcast to Object, okay in compile/runtime
     
    Iterator iter = lst.iterator();
    while (iter.hasNext()) {
       String str = (String)iter.next(); // compile okay but runtime ClassCastException
       System.out.println(str);
    }

**1.4 JDK 1.5中引入泛型**

针对上面的缺陷。JDK 1.5中引入了一个新的特性——泛型。它能够传递类型信息，这样编译器在编译的过程中能够进行必要的类型检查。这样就避免的执行是类型安全问题。

List<String> lst = new ArrayList<String>();  // read as List of Strings, ArrayList of Strings

上面我们传递了一个String类型，在ArrayList内部的操作使用的就是String类型，避免了类型的转换。假设加入其它类型的元素，编译器就会报错。

**1.5 带有泛型的ArrayList**

// Post-JDK 1.5 with Generics
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Iterator;
     
    public class ArrayListPostJDK15Test {
       public static void main(String[] args) {
          List<String> lst = new ArrayList<String>();  // Inform compiler about the type
          lst.add("alpha");         // compiler checks if argument's type is String
          lst.add("beta");
          lst.add("charlie");
          System.out.println(lst);  // [alpha, beta, charlie]
     
          Iterator<String> iter = lst.iterator();   // Iterator of Strings
          while (iter.hasNext()) {
             String str = iter.next();  // compiler inserts downcast operator
             System.out.println(str);
          }
     
    //      lst.add(new Integer(1234));   // ERROR: compiler can detect wrong type
    //      Integer intObj = lst.get(0);  // ERROR: compiler can detect wrong type
     
          // Enhanced for-loop (JDK 1.5)
          for (String str : lst) {
             System.out.println(str);
          }
       }
    }

能够看到，使用泛型之后。就基本不存在前面所说隐式和显式类型转换了，由于内部使用的就是我们传递进去的类型。而不是上面所说的Object类型，假设加入其它类型的话，编译器就会报错。

**1.6 向后兼容**  
JDK 1.5是兼容pre-JDK 1.5的使用的。比如在JDK 1.5中使用pre-JDK 1.5的使用方法，仍然是能够运行的，仅仅是相同没有类型检查。

// Pre-JDK 1.5
    List lst = new ArrayList();  // No type information
    lst.add("alpha");   // Without generics, compiler can't check if the type is correct

**1.7 自己主动装箱和自己主动拆箱(JDK 1.5)**

一个集合仅仅能存放对象，它不能包括基本数据类型，比如int或者double，这就存在问题了。虽然数组能够存放基本数据类型，可是前面说过它是不可扩展的。所以假设希望在集合中存放基本数据类型。就必须使用相应的包装类把基本数据类型包装成相应类型的对象，以下这副图相应的就是基本数据类型与对象类型的相应关系。

![20160329164048595][]

在JDK 1.5之前，向集合加入元素。必须将基本数据类型包装为相应的对象类型。从集合获取元素，必须把相应对象类型拆解为相应的基本数据类型。

// Pre-JDK 1.5
    Integer intObj = new Integer(5566);    // wrap int to Integer
    int i = intObj.intValue();             // unwrap Integer to int
     
    Double doubleObj = new Double(55.66);  // wrap double to Double
    double d = doubleObj.doubleValue();    // unwrap Double to double

从上面能够看到。在JDK 1.5之前，装箱和解箱操作须要我们自己手动去完毕。 JDK 1.5就针对这一问题。提出了一个新特性。就是自己主动装箱与解箱。也就是本来须要我们手工完毕的事情。编译器帮助我们完毕了。

// JDK 1.5
    Integer intObj = 5566;    // autobox from int to Integer
    int i = intObj;           // auto-unbox from Integer to int
     
    Double doubleObj = 55.66; // autoboxing from double to Double
    double d = doubleObj;     // atuo-unbox from Double to double

**样例—Pre JDK 1.5中集合**

Pre JDK 1.5不支持泛型、自己主动装箱与解箱和for-each循环，以下的代码就显得混乱而且不是类型安全的。

// Pre-JDK 1.5
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.Random;
     
    public class PrimitiveCollectionPreJDK15 {
       public static void main(String[] args) {
          List lst = new ArrayList();
     
          // Add 10 random primitive int into the List
          Random random = new Random();
          for (int i = 1; i <= 10; ++i) {
             // Wrap the primitive int into Integer, upcast to Object
             lst.add(new Integer(random.nextInt(10)));
          }
          System.out.println(lst);
     
          Iterator iter = lst.iterator();
          while (iter.hasNext()) {
             // Explicit downcast to Integer, then unwrap to int
             int i = ((Integer)iter.next()).intValue();   // un-safe at runtime
             System.out.println(i);
          }
       }
    }

**样例—Post-JDK 1.5中的集合**

在JDK1.5之后，就支持了泛型、自己主动装箱与解箱以及for-each循环，代码会更加简洁而且是类型安全的。

// Post-JDK 1.5
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.Random;
     
    public class PrimitiveCollectionJDK15 {
       public static void main(String[] args) {
          List<Integer> lst = new ArrayList<Integer>();
     
          // Add 10 random primitive int into the List
          Random random = new Random();
          for (int i = 1; i <= 10; ++i) {
             lst.add(random.nextInt(10)); // autobox to Integer, upcast to Object, type-safe
          }
          System.out.println(lst);
     
          // Transverse via iterator
          Iterator<Integer> iter = lst.iterator();
          while (iter.hasNext()) {
             int i = iter.next();  // downcast to Integer, auto-unbox to int, type-safe
             System.out.println(i);
          }
     
          // Transverse via enhance for-loop
          for (int i : lst) {      // downcast to Integer, auto-unbox to int, type-safe
             System.out.println(i);
          }
     
          // Retrieve via for-loop with List's index
          for (int i = 0; i < lst.size(); ++i) {
             int j = lst.get(i);   // downcast to Integer, auto-unbox to int, type-safe
             System.out.println(j);
          }
       }
    }

**2. Collection接口**

下图是Collection框架中的接口和经常使用实现类

![20160329170038839][]

**2.1  Iterable<E>接口**

Iterable<E>接口。它包括了一个泛型类型E。E相应的就是集合元素类型，这个接口声明了一个抽象方法`iterator()` 用来获取一个Iterator<E>对象，Iterator用来遍历它所关联集合的全部元素。

Iterator<E> iterator();   // Returns the associated Iterator instance 
                              // that can be used to transverse thru all the elements of the collection

全部Collection的实现 （比如： `ArrayList` ,  `LinkedList` ,  `Vector` ）必须实现这种方法，而且返回的对象也实现了 Iterator接口。

**2.2  Iterator<E>接口**

Iterator<E>接口声明了以下三个抽象方法。

boolean hasNext()  // Returns true if it has more elements
    E next()           // Returns the next element of generic type E
    void remove()      // Removes the last element returned by the iterator

我们能够使用 Iterator和一个while循环进行集合的遍历

List<String> lst = new ArrayList<String>();
    lst.add("alpha");
    lst.add("beta");
    lst.add("charlie");
     
    // Retrieve the Iterator associated with this List via the iterator() method
    Iterator<String> iter = lst.iterator();
    // Transverse thru this List via the Iterator
    while (iter.hasNext()) {
       // Retrieve each element and process
       String str = iter.next();
       System.out.println(str);
    }

**2.3 加强版的for循环 (JDK 1.5)**

对于使用Iterator进行集合的遍历，在JDK 1.5中引入了新的加强版的for循环，使用它进行集合的遍历更加方便。

以下是主要的使用方法

for ( type item : aCollection ) {
       body ;
    }

**能够在集合中改动对象吗？**

加强版的for循环提供了一个方便的方法去遍历集合元素，可是它将Iterator给隐藏了，因此你不能移除或者替换这个元素。

循环变量接受的是一个引用的副本。因此这个加强版的for循环能够通过该引用改动相应的可变元素（比如：StringBuilder），可是不能改动不可变元素（比如：String和基本数据类型相应的对象类型）。

**样例——使用加强版的for循环对于集合的可变元素（比如：StringBuilder）**

import java.util.List;
    import java.util.ArrayList;
     
    public class ForEachMutableTest {
       public static void main(String[] args) {
          List<StringBuilder> lst = new ArrayList<StringBuilder>();
          lst.add(new StringBuilder("alpha"));
          lst.add(new StringBuilder("beta"));
          lst.add(new StringBuilder("charlie"));
          System.out.println(lst);   // [alpha, beta, charlie]
     
          for (StringBuilder sb : lst) {
             sb.append("88");   // can modify "mutable" objects
          }
          System.out.println(lst);  // [alpha88, beta88, charlie88]
       }
    }

**样例——使用加强版的for循环对于集合的不可变元素（比如：StringBuilder）**

import java.util.List;
    import java.util.ArrayList;
     
    public class ForEachImmutableTest {
       public static void main(String[] args) {
          List<String> lst = new ArrayList<String>();
          lst.add("alpha");
          lst.add("beta");
          lst.add("charlie");
          System.out.println(lst);   // [alpha, beta, charlie]
     
          for (String str : lst) {
             str += "change!";   // cannot modify "immutable" objects
          }
          System.out.println(lst);   // [alpha, beta, charlie]
       }
    }

**2.4  Collection<E>接口**

Collection<E>包括一个泛型类型E，E是集合的元素数据类型，而且Collection<E>是集合框架的超类。它包括了其它类都须要实现的基本操作，比如：

// Basic Operations
    int size()                        // Returns the number of elements of this Collection
    void clear()                      // Removes all the elements of this Collection
    boolean isEmpty()                 // Returns true if there is no element in this Collection
    boolean add(E element)            // Ensures that this Collection contains the given element
    boolean remove(Object element)    // Removes the given element, if present
    boolean contains(Object element)  // Returns true if this Collection contains the given element
    
    // Bulk Operations with another Collection
    boolean containsAll(Collection<?> c)       // Collection of any "unknown" object
    boolean addAll(Collection<? extends E> c)  // Collection of E or its sub-types
    boolean removeAll(Collection<?> c)
    boolean retainAll(Collection<?

> c) // Comparison - Objects that are equal shall have the same hashCode boolean equals(Object o) int hashCode() // Array Operations Object\[\] toArray() // Convert to an Object array <T> T\[\] toArray(T\[\] a) // Convert to an array of the given type T

`Collection<E>中仅仅能包括对象类型。不能包括基本数据类型（比如：int和double），所以假设须要将基本数据类型包装成相应的对象类型，JDK 1.5引入了自己主动拆箱和解箱操作来解决问题，这个在前面已经讲过。`

**2.5  List<E>, Set<E> & Queue<E> — Collection<E>的子接口**

在实际开发过程中。我们一般使用Collection的子类接口——`List<E>`, `Set<E>`, 和 `Queue<E>。它们提供了很多其它其它的特性。`

*  `List<E>`:它相当于一个可扩展的线性数组，能够进行索引訪问，而且能够包括反复的元素，我们常常会使用到的一些List的实现类为： `ArrayList`, `LinkedList`, `Vector` 和 `Stack。`  
    
 *  `Set<E>:相当于一个数据集合，它不能包括反复的元素。常常使用到的Set的实现类为：HashSet和 LinkedHashSet，子接口为SortedSet<E> 是一个有序的元素集合，TreeSet是SortedSet<E> 的实现类。`
    
    ``
    
    ``
 *  `Queue<E>: 相当于一个先进先出的队列，它的子接口Deque<E>相当于一个可在两端操作的双向队列，实现类为PriorityQueue, ArrayDeque 和 LinkedList。`
    
    ``
    
    ``

**2.6  Map<K,V>接口**

接口Map<K,V>包括了两个泛型类型K和V。它们组成一个键值对。Map就是一个键值对的集合，键值key是不同意反复的，常常使用到的实现类为`HashMap`, `Hashtable` 和 `LinkedHashMap。它的子接口 SortedMap<K, V> 表示一个基于键值key有序的键值对集合，实现类为TreeMap。`

须要注意的是，Map<K,V>不是Collection<E>的子接口。

**3. List<E>接口与实现**

在实际的编程中。我们很多其它使用的是Collection的子接口`List`, `Set`, 和 `Queue来取代Collection接口，这些子接口仅仅是对Collection接口操作的又一次定义。`

`    List<E>相当于一个可扩展的线性数组，它支持索引訪问，它能够包括反复的元素，也能够包括null元素。`

在`List<E>` 父接口的基础上，`List<E>` 也声明了一些抽象方法。

// Operations at a specified index position
    void add(int index, E element)    // add
    E set(int index, E element)       // replace
    E get(int index)                  // retrieve without remove
    E remove(int index)               // remove last retrieved
    int indexOf(Object obj)
    int lastIndexOf(Object obj)
    // Operations on a range fromIndex (inclusive) toIndex (exclusive)
    List<E> subList(int fromIndex, int toIndex)
    ......
     
    // Operations inherited from Collection<E>
    int size()
    boolean isEmpty()
    boolean add(E element)
    boolean remove(Object obj)
    boolean contains(Object obj)
    void clear();
    ......

抽象类 AbstractList提供了非常多List、Collector和Iterable接口中声明的抽象方法的实现。另外有些方法仍然是抽象的。这些方法会被子类实现，比如`ArrayList` 和 `Vector。`

`3.1  ArrayList<E> & Vector<E> —— List<E>的实现类`

ArrayList<E>是List接口全面的实现类，非常多实用的方法已经被AbstractList实现。可是ArrayList也进行了重写。ArrayList不是线程同步的，因此它不是线程安全的。

Vector是JDK 1.0中遗留的类。在JDK 1.2中将它更新到了Collection中。它是List接口的一个线程同步（线程安全）的实现。包括了非常多遗留的方法（比如：`addElement()`, `removeElement()`, `setElement()`, `elementAt()`, `firstElement()`, `lastElement()`, `insertElementAt()`），毫无疑问，这些遗留的方法是能够使用的。而且保持向后兼容。

须要注意的是，尽管ArrayList<E>不是线程安全的，而Vector是线程安全的，可是ArrayList<E>显然比Vector有更好的性能。

**3.2  Stack<E>——List<E>的实现类**

Stack<E>是一个后进先出的队列，它扩展于Vector。它是一个同步的可扩展的数组，也就是它是线程安全的，包括了以下方法。

E push(E element)       // pushes the specified element onto the top of the stack
    E pop()                 // removes and returns the element at the top of the stack
    E peek()                // returns the element at the top of stack without removing
    boolean empty()         // tests if this stack is empty
    int search(Object obj)  // returns the distance of the specified object from the top
                            //  of stack (distance of 1 for TOS), or -1 if not found

**3.3  LinkedList<E> - List<E>的实现类**

LinkedList<E>是一个双向链表，它实现了List<E>接口，在元素的插入和删除上，效率更高，可是浪费了很多其它复杂的结构。

`    LinkedList<E>` 也实现了`Queue<E>` 和 `Deque<E>，因此它能够充当FIFO 和 LIFO队列。`

`3.4 转换一个List为一个数组 - toArray()`

`在超类接口Collection中定义了一个toArray()方法，它能够使用该列表来创建一个数组。返回的数组能够进行自由的改动。`

Object[] toArray()      // Object[] version
    <T> T[] toArray(T[] a)  // Generic type version

样例：

import java.util.List;
    import java.util.ArrayList;
    import java.util.Arrays;
    public class TestToArray {
       public static void main(String[] args) {
          List<String> lst = new ArrayList<String>();
          lst.add("alpha");
          lst.add("beta");
          lst.add("charlie");
     
          // Use the Object[] version
          Object[] strArray1 = lst.toArray();
          System.out.println(Arrays.toString(strArray1));   // [alpha, beta, charlie]
     
          // Use the generic type verion - Need to specify the type in the argument
          String[] strArray2 = lst.toArray(new String[0]);
          strArray2[0] = "delta";   // modify the returned array
          System.out.println(Arrays.toString(strArray2));   // [delta, beta, charlie]
          System.out.println(lst);  // [alpha, beta, charlie] - no change in the original list
       }
    }

**3.5 将数组转换为一个List - Arrays.asList()**

工具类java.util.Arrays提供了静态方法Arrays.asList()能够将数组转换为List<T>，可是，假设改动了List里面的元素内容。数组中对应的元素内容也会改变，反之亦然。

**样例：**

import java.util.List;
    import java.util.ArrayList;
    import java.util.Arrays;
    public class TestArrayAsList {
       public static void main(String[] args) {
          String[] strs = {"alpha", "beta", "charlie"};
          System.out.println(Arrays.toString(strs));   // [alpha, beta, charlie]
     
          List<String> lst = Arrays.asList(strs);
          System.out.println(lst);  // [alpha, beta, charlie]
     
          // Changes in array or list write thru
          strs[0] += "88";
          lst.set(2, lst.get(2) + "99");
          System.out.println(Arrays.toString(strs)); // [alpha88, beta, charlie99]
          System.out.println(lst);  // [alpha88, beta, charlie99]
     
          // Initialize a list using an array
          List<Integer> lstInt = Arrays.asList(22, 44, 11, 33);
          System.out.println(lstInt);  // [22, 44, 11, 33]
       }
    }

**3.6 ArrayList, Vector, LinkedList 和 Stack的比較**

**略**

**4. 排序与查找**

*  `使用Collections.sort()` 和 `Arrays.sort()可进行排序`  
    
 *  `有些集合，比如SortedSet (TreeSet) 和 SortMap (TreeMap)是有序的`

有两种方法进行排序：

*  是对象实现java.lang.Comparable，重写compareTo()方法去指定两个对象的排序方法。
 *  创建一个指定的java.util.Comparator对象。实现compare()方法去指定两个对象的比較。

**4.1  java.lang.Comparable<T>接口**

java.lang.Comparable<T>能够指定两个对象怎样进行比較，它定义了一个抽象方法。

int compareTo(T o)  // Returns a negative integer, zero, or a positive integer 
                        // as this object is less than, equal to, or greater than the given object

一般推荐 compareTo()方法与`equals()` 和 `hashCode()是一致的，即：`

*  假设`compareTo()返回0。那么equals()应该返回true。`
 *  `假设equals()返回true，那么hashCode()应该返回的是同样的int值。`
    
    ``
    
    ``

全部基本数据类型的包装类（比如：`Byte`, `Short`, `Integer`, `Long`, `Float`, `Double`, `Character` and `Boolean`）都实现了Comparable接口的`compareTo()` 方法。

**样例：**

工具类 `java.util.Arrays` 和 `java.util.Collections相应不同的算法提供了非常多的静态方法，比如排序和查找。`

`在以下这个样例中，使用Arrays.sort() 和 Collections.sort() 方法去对一个String数组和一个Integer的List进行排序，使用的就是它们默认的Comparable实现。`

import java.util.Arrays;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Collections;
     
    public class TestComparable {
       public static void main(String[] args) {
          // Sort and search an "array" of Strings
          String[] array = {"Hello", "hello", "Hi", "HI"};
     
          // Use the Comparable defined in the String class
          Arrays.sort(array);
          System.out.println(Arrays.toString(array));  // [HI, Hello, Hi, hello]
     
          // Try binary search - the array must be sorted
          System.out.println(Arrays.binarySearch(array, "Hello")); // 1
          System.out.println(Arrays.binarySearch(array, "HELLO")); // -1 (insertion at index 0)
     
          // Sort and search a "List" of Integers
          List<Integer> lst = new ArrayList<Integer>();
          lst.add(22);  // auto-box
          lst.add(11);
          lst.add(44);
          lst.add(33);
          Collections.sort(lst);    // Use the Comparable of Integer class
          System.out.println(lst);  // [11, 22, 33, 44]
          System.out.println(Collections.binarySearch(lst, 22)); // 1
          System.out.println(Collections.binarySearch(lst, 35)); // -4 (insertion at index 3)
       }
    }

**4.2  java.util.Comparator<T> 接口**  
    在Comparable之外，我们能够传递一个Comparator对象到排序方法中（`Collections.sort()` 和 `Arrays.sort()`）来实现大小比較，假设Comparator可用，那么Comparator将会重写Comparable。

int compare(T o1, T o2)    // Returns a negative integer, zero, or a positive integer as the 
                               // first argument is less than, equal to, or greater than the second.

须要注意的是，你须要创建 Comparator<T>实例。而且实现`compare()` 方法去进行对象的比較。在Comparable中，仅仅须要调用对象的compareTo()方法。它仅仅须要传递一个參数，表示当前对象和还有一个对象比較，在Comparator<T>须要传递两个參数。表示两个对象的比較。

**样例**

import java.util.Arrays;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Comparator;
     
    public class TestComparator {
     
       // Define a Comparator<String> to order strings in case-insensitive manner
       public static class StringComparator implements Comparator<String> {
          @Override
          public int compare(String s1, String s2) {
             return s1.compareToIgnoreCase(s2);
          }
       }
     
       // Define a Comparator<Integer> to order Integers based on the least significant digit
       public static class IntegerComparator implements Comparator<Integer> {
          @Override
          public int compare(Integer s1, Integer s2) {
             return s1%10 - s2%10;
          }
       }
     
       public static void main(String[] args) {
          // Use a customized Comparator for Strings
          Comparator<String> compStr = new StringComparator();
     
          // Sort and search an "array" of Strings
          String[] array = {"Hello", "Hi", "HI", "hello"};
          Arrays.sort(array, compStr);
          System.out.println(Arrays.toString(array));  // [Hello, hello, Hi, HI]
          System.out.println(Arrays.binarySearch(array, "Hello", compStr)); // 1
          System.out.println(Arrays.binarySearch(array, "HELLO", compStr)); // 1 (case-insensitive)
     
          // Use a customized Comparator for Integers
          Comparator<Integer> compInt = new IntegerComparator();
     
          // Sort and search a "List" of Integers
          List<Integer> lst = new ArrayList<Integer>();
          lst.add(42);  // auto-box
          lst.add(21);
          lst.add(34);
          lst.add(13);
          Collections.sort(lst, compInt);
          System.out.println(lst);  // [21, 42, 13, 34]
          System.out.println(Collections.binarySearch(lst, 22, compInt)); // 1
          System.out.println(Collections.binarySearch(lst, 35, compInt)); // -5 (insertion at index 4)
       }
    }

**建议接着看[Java编程手冊-Collection框架（下）][Java_-Collection]**

參考文章：[Java Programming Tutorial The Collection Framework][]

[20160329155105749]: /images/20210726/e37785222f7a47108a608de7763c84b3.png
[20160329164048595]: /images/20210726/3036e22be4164e8f983a46c349b1e972.png
[20160329170038839]: /images/20210726/db9c1d61cd234037aa5ea691d65d040f.png
[Java_-Collection]: http://blog.csdn.net/hp910315/article/details/51018135
[Java Programming Tutorial The Collection Framework]: https://www3.ntu.edu.sg/home/ehchua/programming/java/J5c_Collection.html