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

2022-10-04 12:21:15

该文章所讲内容基本涵盖了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包中集合框架的类和接口

上图能够看到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，这就存在问题了。虽然数组能够存放基本数据类型，可是前面说过它是不可扩展的。所以假设希望在集合中存放基本数据类型。就必须使用相应的包装类把基本数据类型包装成相应类型的对象，以下这副图相应的就是基本数据类型与对象类型的相应关系。

在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框架中的接口和经常使用实现类

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
Programming Tutorial The Collection Framework

码农公寓

相关文章