Java回顾之集合

在这篇文章里，我们关注Java中的集合（Collection）。集合是编程语言中基础的一部分，Java自JDK早期，就引入了Java Collection Framework。设计JCF的那个人，后来还写了一本书，叫《Effective Java》。

　　Java中的集合主要集中在2部分，一部分是java.util包中，一部分是java.util.concurrent中，后者是在前者的基础上，定义了一些实现了同步功能的集合。

　　这篇文章主要关注java.util下的各种集合对象。Java中的集合对象可以粗略的分为3类：List、Set和Map。对应的UML图如下（包括了java.util下大部分的集合对象）：

aaarticlea/png;base64,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" alt="" width="738" height="368" />

　　（这张图经过缩放已经变形，完整清晰版图片请参见：http://files.cnblogs.com/wing011203/java_collection_structure.zip，解压缩后就可以看到未经缩放的版本。）

　　Collection概述

　　Java集合中的List和Set都从Collection出来，它是一个学习集合很不错的入口，它包含了集合中通常需要有的操作：

• 添加元素：add/addAll
• 清空集合：clear
• 删除元素：remove/removeAll
• 判断集合中是否包含某元素：contains/containsAll
• 判断集合是否为空：isEmpty
• 计算集合中元素的个数：size
• 将集合转换为数组：toArray
• 获取迭代器：iterator

　　我们来看一个简单的例子，下面的代码会返回一个集合，集合中的元素是随机生成的整数：

 

 private static Collection initCollection()
 {
     Collection<Integer> collection = new ArrayList<Integer>();
     Random r = new Random();
     for (int i = 0 ; i < 5; i++)
     {
         collection.add(new Integer(r.nextInt(100)));
     }

     return collection;
 }

 

　　在对集合进行操作的过程中，遍历是一个经常使用的操作，我们可以使用两种方式对集合进行遍历：

　　1） 使用迭代器对集合进行遍历。正如上面描述Collection接口时所说，所有集合都会有一个迭代器，我们可以用它来遍历集合。

 

 private static void accessCollectionByIterator(Collection<Integer> collection)
 {
     Iterator<Integer> iterator = collection.iterator();
     System.out.println("The value in the list:");
     while(iterator.hasNext())
     {
         System.out.println(iterator.next());
     }
 }

 

　　2）使用foreach遍历集合。

 

 private static void accessCollectionByFor(Collection<Integer> collection)
 {
     System.out.println("The value in the list:");
     for(Integer value : collection)
     {
         System.out.println(value);
     }
 }

 

　　List

　　Java中的List是对数组的有效扩展，它是这样一种结构，如果不使用泛型，它可以容纳任何类型的元素，如果使用泛型，那么它只能容纳泛型指定的类型的元素。和数组相比，List的容量是可以动态扩展的。

　　List中的元素是可以重复的，里面的元素是“有序”的，这里的“有序”，并不是排序的意思，而是说我们可以对某个元素在集合中的位置进行指定。

　　List中常用的集合对象包括：ArrayList、Vector和LinkedList，其中前两者是基于数组来进行存储，后者是基于链表进行存储。其中Vector是线程安全的，其余两个不是线程安全的。

　　List中是可以包括null的，即使是使用了泛型。

　　ArrayList可能是我们平时用到的最多的集合对象了，在上述的示例代码中，我们也是使用它来实例化一个Collection对象，在此不再赘述。

　　Vector

　　Vector的示例如下，首先我们看如何生成和输出Vector：

 

 private static void vectorTest1()
 {
     List<Integer> list = new Vector<Integer>();
     for (int i = 0 ; i < 5; i++)
     {
         list.add(new Integer(100));
     }
     list.add(null);
     System.out.println("size of vector is " + list.size());
     System.out.println(list);
 }

 

　　它的元素中，既包括了重复元素，也包括了null，输出结果如下：

size of vector is 6
[100, 100, 100, 100, 100, null]

　　下面的示例，演示了Vector中的一些常用方法：

 

 private static void vectorTest2()
 {
     Vector<Integer> list = new Vector<Integer>();
     Random r = new Random();
     for (int i = 0 ; i < 10; i++)
     {
         list.add(new Integer(r.nextInt(100)));
     }
     System.out.println("size of vector is " + list.size());
     System.out.println(list);
     System.out.println(list.firstElement());
     System.out.println(list.lastElement());
     System.out.println(list.subList(3, 8));
     List<Integer> temp = new ArrayList<Integer>();
     for(int i = 4; i < 7; i++)
     {
         temp.add(list.get(i));
     }
     list.retainAll(temp);
     System.out.println("size of vector is " + list.size());
     System.out.println(list);
 }

 

　　它的输出结果如下：

 

size of vector is 10
[39, 41, 20, 9, 29, 32, 54, 12, 94, 82]
39
82
[9, 29, 32, 54, 12]
size of vector is 3
[29, 32, 54]

 

　　LinkedList

　　LinkedList使用链表来存储数据，它的示例代码如下：

 

 private static void linkedListTest1()
 {
     LinkedList<Integer> list = new LinkedList<Integer>();
     Random r = new Random();
     for (int i = 0 ; i < 10; i++)
     {
         list.add(new Integer(r.nextInt(100)));
     }
     list.add(null);
     System.out.println("size of linked list is " + list.size());
     System.out.println(list);
     System.out.println(list.element());
     System.out.println(list.getFirst());
     System.out.println(list.getLast());
     System.out.println(list.peek());
     System.out.println(list.peekFirst());
     System.out.println(list.peekLast());
     System.out.println(list.poll());
     System.out.println(list.pollFirst());
     System.out.println(list.pollLast());
     System.out.println(list.pop());
     list.push(new Integer(100));
     System.out.println("size of linked list is " + list.size());
     System.out.println(list);
 }

 

　　这里列出了LinkedList常用的各个方法，从方法名可以看出，LinkedList也可以用来实现栈和队列。

　　输出结果如下：

 

size of linked list is 11
[17, 21, 5, 84, 19, 57, 68, 26, 27, 47, null]
17
17
null
17
17
null
17
21
null
5
size of linked list is 8
[100, 84, 19, 57, 68, 26, 27, 47]

 

　　Set

　　Set 和List类似，都是用来存储单个元素，单个元素的数量不确定。但Set不能包含重复元素，如果向Set中插入两个相同元素，那么后一个元素不会被插入。

　　Set可以大致分为两类：不排序Set和排序Set，不排序Set包括HashSet和LinkedHashSet，排序Set主要指TreeSet。其中HashSet和LinkedHashSet可以包含null。

　　HashSet

　　HashSet是由Hash表支持的一种集合，它不是线程安全的。

　　我们来看下面的示例，它和Vector的第一个示例基本上是相同的：

 

 private static void hashSetTest1()
 {
     Set<Integer> set = new HashSet<Integer>();

     for (int i = 0; i < 3; i++)
     {
         set.add(new Integer(100));
     }
     set.add(null);

     System.out.println("size of set is " + set.size());
     System.out.println(set);
 }

 

　　这里，HashSet中没有包含重复元素，但包含了null，和Vector不同，这里的输出结果如下：

size of set is 2
[null, 100]

　　对于HashSet是如何判断两个元素是否是重复的，我们可以深入考察一下。Object中也定义了equals方法，对于HashSet中的元素，它是根据equals方法来判断元素是否相等的，为了证明这一点，我们可以定义个“不正常”的类型：

 

 class MyInteger
 {
     private Integer value;

     public MyInteger(Integer value)
     {
         this.value = value;
     }

     public String toString()
     {
         return String.valueOf(value);
     }

     public int hashCode()
     {
         return 1;
     }

     public boolean equals(Object obj)
     {
         return false;
     }
 }

 

　　可以看到，对于MyInteger来说，对于任意两个实例，我们都认为它是不相等的。

　　下面是对应的测试方法：

 

 private static void hashSetTest2()
 {
     Set<MyInteger> set = new HashSet<MyInteger>();

     for (int i = 0; i < 3; i++)
     {
         set.add(new MyInteger(100));
     }

     System.out.println("size of set is " + set.size());
     System.out.println(set);
 }

 

　　它的输出结果如下：

size of set is 3
[100, 100, 100]

　　可以看到，现在HashSet里有“重复”元素了，但对于MyInteger来说，它们不是“相同”的。

　　TreeSet

　　TreeSet是支持排序的一种Set，它的父接口是SortedSet。

　　我们首先来看一下TreeSet都有哪些基本操作：

 

 private static void treeSetTest1()
 {
     TreeSet<Integer> set = new TreeSet<Integer>();

     Random r = new Random();
     for (int i = 0 ; i < 5; i++)
     {
         set.add(new Integer(r.nextInt(100)));
     }

     System.out.println(set);
     System.out.println(set.first());
     System.out.println(set.last());
     System.out.println(set.descendingSet());
     System.out.println(set.headSet(new Integer(50)));
     System.out.println(set.tailSet(new Integer(50)));
     System.out.println(set.subSet(30, 60));
     System.out.println(set.floor(50));
     System.out.println(set.ceiling(50));
 }

 

　　它的输出结果如下：

 

[8, 42, 48, 49, 53]
8
53
[53, 49, 48, 42, 8]
[8, 42, 48, 49]
[53]
[42, 48, 49, 53]
49
53

 

　　TreeSet中的元素，一般都实现了Comparable接口，默认情况下，对于Integer来说，SortedList是采用升序来存储的，我们也可以自定义Compare方式，例如以降序的方式来存储。

　　下面，我们首先重新定义Integer：

 

 class MyInteger2 implements Comparable
 {
     public int value;

     public MyInteger2(int value)
     {
         this.value = value;
     }

     public int compareTo(Object arg0)
     {
         MyInteger2 temp = (MyInteger2)arg0;
         if (temp == null) return -1;
         if (temp.value > this.value)
         {
             return 1;
         }
         else if (temp.value < this.value)
         {
             return -1;
         }
         return 0;
     }

     public boolean equals(Object obj)
     {
         return compareTo(obj) == 0;
     }

     public String toString()
     {
         return String.valueOf(value);
     }
 }

 

　　下面是测试代码：

 

 private static void treeSetTest2()
 {
     TreeSet<Integer> set1 = new TreeSet<Integer>();
     TreeSet<MyInteger2> set2 = new TreeSet<MyInteger2>();
     Random r = new Random();
     for (int i = 0 ; i < 5; i++)
     {
         int value = r.nextInt(100);
         set1.add(new Integer(value));
         set2.add(new MyInteger2(value));
     }
     System.out.println("Set1 as below:");
     System.out.println(set1);
     System.out.println("Set2 as below:");
     System.out.println(set2);
 }

 

　　代码的运行结果如我们所预期的那样，如下所示：

Set1 as below:
[13, 41, 42, 45, 61]
Set2 as below:
[61, 45, 42, 41, 13]

　　Map

　　Map中存储的是“键值对”，和Set类似，Java中的Map也有两种：排序的和不排序的，不排序的包括HashMap、Hashtable和LinkedHashMap，排序的包括TreeMap。

　　非排序Map

　　HashMap和Hashtable都是采取Hash表的方式进行存储，HashMap不是线程安全的，Hashtable是线程安全的，我们可以把HashMap看做是“简化”版的Hashtable。

　　HashMap是可以存储null的，无论是对Key还是对Value。Hashtable是不可以存储null的。

　　无论HashMap还是Hashtable，我们观察它的构造函数，就会发现它可以有两个参数：initialCapacity和 loadFactor，默认情况下，initialCapacity等于16，loadFactor等于0.75。这和Hash表中可以存放的元素数目有 关系，当元素数目超过initialCapacity*loadFactor时，会触发rehash方法，对hash表进行扩容。如果我们需要向其中插入 过多元素，需要适当调整这两个参数。

　　我们首先来看HashMap的示例：

 

 private static void hashMapTest1()
 {
     Map<Integer,String> map = new HashMap<Integer, String>();

     map.put(new Integer(1), "a");
     map.put(new Integer(2), "b");
     map.put(new Integer(3), "c");

     System.out.println(map);
     System.out.println(map.entrySet());
     System.out.println(map.keySet());
     System.out.println(map.values());
 }

 

　　这会输出HashMap里的元素信息，如下所示。

{1=a, 2=b, 3=c}
[1=a, 2=b, 3=c]
[1, 2, 3]
[a, b, c]

　　下面的示例是对null的演示：

 

 private static void hashMapTest2()
 {
     Map<Integer,String> map = new HashMap<Integer, String>();

     map.put(null, null);
     map.put(null, null);
     map.put(new Integer(4), null);
     map.put(new Integer(5), null);

     System.out.println(map);
     System.out.println(map.entrySet());
     System.out.println(map.keySet());
     System.out.println(map.values());
 }

 

　　执行结果如下：

{null=null, 4=null, 5=null}
[null=null, 4=null, 5=null]
[null, 4, 5]
[null, null, null]

　　接下来我们演示Hashtable，和上述两个示例基本上完全一样（代码不再展开）：

 

 private static void hashTableTest1()
 {
     Map<Integer,String> table = new Hashtable<Integer, String>();

     table.put(new Integer(1), "a");
     table.put(new Integer(2), "b");
     table.put(new Integer(3), "c");

     System.out.println(table);
     System.out.println(table.entrySet());
     System.out.println(table.keySet());
     System.out.println(table.values());
 }

 private static void hashTableTest2()
 {
     Map<Integer,String> table = new Hashtable<Integer, String>();

     table.put(null, null);
     table.put(null, null);
     table.put(new Integer(4), null);
     table.put(new Integer(5), null);

     System.out.println(table);
     System.out.println(table.entrySet());
     System.out.println(table.keySet());
     System.out.println(table.values());
 }

 

　　执行结果如下：

 

{3=c, 2=b, 1=a}
[3=c, 2=b, 1=a]
[3, 2, 1]
[c, b, a]
Exception in thread "main" java.lang.NullPointerException
    at java.util.Hashtable.put(Unknown Source)
    at sample.collections.MapSample.hashTableTest2(MapSample.java:61)
    at sample.collections.MapSample.main(MapSample.java:11)

 

　　可以很清楚的看到，当我们试图将null插入到hashtable中时，报出了空指针异常。

　　排序Map

　　排序Map主要是指TreeMap，它对元素增、删、查操作时的时间复杂度都是O（log（n））。它不是线程安全的。

　　它的特点和TreeSet非常像，这里不再赘述。