Java集合：整體結構

liuxiaopeng發表於2016-05-31
Java

一、Java中集合

　　Java中集合類是Java程式設計中使用最頻繁、最方便的類。集合類作為容器類可以儲存任何型別的資料，當然也可以結合泛型儲存指定的型別（不過泛型僅僅在編譯期有效，執行時是會被擦除的）。集合類中儲存的僅僅是物件的引用，並不儲存物件本身。集合類的容量可以在執行期間進行動態擴充套件，並且還提供很多很方便的方法，如求集合的並集、交集等。

二、集合類結構

　　Java中的集合包含多種資料結構，如連結串列、佇列、雜湊表等。從類的繼承結構來說，可以分為兩大類，一類是繼承自Collection介面，這類集合包含List、Set和Queue等集合類。另一類是繼承自Map介面，這主要包含了雜湊表相關的集合類。下面我們看一下這兩大類的繼承結構圖：

1、List、Set和Queue

 圖中的綠色的虛線代表實現，綠色實線代表介面之間的繼承，藍色實線代表類之間的繼承。

　　 (1)List：我們用的比較多List包括ArrayList和LinkedList，這兩者的區別也很明顯，從其名稱上就可以看出。ArrayList的底層的通過陣列實現，所以其隨機訪問的速度比較快，但是對於需要頻繁的增刪的情況，效率就比較低了。而對於LinkedList，底層通過連結串列來實現，所以增刪操作比較容易完成，但是對於隨機訪問的效率比較低。

我們先看下兩者的插入效率：

 1 package com.paddx.test.collection;
 2 
 3 import java.util.ArrayList;
 4 import java.util.LinkedList;
 5 
 6 public class ListTest {
 7     public static void main(String[] args) {
 8         for(int i=0;i<10000;i++){
 9 
10         }
11         long start = System.currentTimeMillis();
12 
13         LinkedList<Integer> linkedList = new LinkedList<Integer>();
14         for(int i=0;i<100000;i++){
15             linkedList.add(0,i);
16         }
17 
18         long end = System.currentTimeMillis();
19         System.out.println(end - start);
20 
21         ArrayList<Integer> arrayList = new ArrayList<Integer>();
22         for(int i=0;i<100000;i++){
23             arrayList.add(0,i);
24         }
25 
26         System.out.println(System.currentTimeMillis() - end);
27     }
28 }

下面是本地執行的結果：

23
1227

　　可以看出，在這種情況下，LinkedList的插入效率遠遠高於ArrayList，當然這是一種比較極端的情況。我們再來比較一下兩者隨機訪問的效率：

 1 package com.paddx.test.collection;
 2 
 3 import java.util.ArrayList;
 4 import java.util.LinkedList;
 5 import java.util.Random;
 6 
 7 public class ListTest {
 8     public static void main(String[] args) {
 9 
10         Random random = new Random();
11 
12         for(int i=0;i<10000;i++){
13 
14         }
15         LinkedList<Integer> linkedList = new LinkedList<Integer>();
16         for(int i=0;i<100000;i++){
17             linkedList.add(i);
18         }
19 
20         ArrayList<Integer> arrayList = new ArrayList<Integer>();
21         for(int i=0;i<100000;i++){
22             arrayList.add(i);
23         }
24 
25         long start = System.currentTimeMillis();
26 
27 
28         for(int i=0;i<100000;i++){
29             int j = random.nextInt(i+1);
30             int k = linkedList.get(j);
31         }
32 
33         long end = System.currentTimeMillis();
34         System.out.println(end - start);
35 
36         for(int i=0;i<100000;i++){
37             int j = random.nextInt(i+1);
38             int k = arrayList.get(j);
39         }
40 
41         System.out.println(System.currentTimeMillis() - end);
42     }
43 }

下面是我本機執行的結果：

5277
6

　　很明顯可以看出，ArrayList的隨機訪問效率比LinkedList高出好幾個數量級。通過這兩段程式碼，我們應該能夠比較清楚的知道LinkedList和ArrayList的區別和適應的場景。至於Vector，它是ArrayList的執行緒安全版本，而Stack則對應棧資料結構，這兩者用的比較少，這裡就不舉例了。

　　(2)Queue：一般可以直接使用LinkedList完成，從上述類圖也可以看出，LinkedList繼承自Deque，所以LinkedList具有雙端佇列的功能。PriorityQueue的特點是為每個元素提供一個優先順序，優先順序高的元素會優先出佇列。

　　(3)Set：Set與List的主要區別是Set是不允許元素重複的，而List則可以允許元素重複的。判斷元素的重複需要根據物件的hash方法和equals方法來決定。這也是我們通常要為集合中的元素類重寫hashCode方法和equals方法的原因。我們還是通過一個例子來看一下Set和List的區別，以及hashcode方法和equals方法的作用：

package com.paddx.test.collection;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Set;

public class SetTest {

    public static void main(String[] args) {
        Person p1 = new Person("lxp",10);
        Person p2 = new Person("lxp",10);
        Person p3 = new Person("lxp",20);

        ArrayList<Person> list = new ArrayList<Person>();
        list.add(p1);
        System.out.println("---------");
        list.add(p2);
        System.out.println("---------");
        list.add(p3);
        System.out.println("List size=" + list.size());

        System.out.println("----分割線-----");

        Set<Person> set = new HashSet<Person>();
        set.add(p1);
        System.out.println("---------");
        set.add(p2);
        System.out.println("---------");
        set.add(p3);
        System.out.println("Set size="+set.size());
    }


    static class Person{
        private String name;
        private int age;

        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }

        @Override
        public boolean equals(Object o) {
            System.out.println("Call equals();name="+name);
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;

            Person person = (Person) o;

            return name.equals(person.name);

        }

        @Override
        public int hashCode() {
            System.out.println("Call hashCode(),age="+age);
            return age;
        }
    }
}

　　上述程式碼的執行結果如下：

---------
---------
List size=3
----分割線-----
Call hashCode(),age=10
---------
Call hashCode(),age=10
Call equals();name=lxp
---------
Call hashCode(),age=20
Set size=2

　　從結果看出，元素加入List的時候，不執行額外的操作，並且可以重複。而加入Set之前需要先執行hashCode方法，如果返回的值在集合中已存在，則要繼續執行equals方法，如果equals方法返回的結果也為真，則證明該元素已經存在，會將新的元素覆蓋老的元素，如果返回hashCode值不同，則直接加入集合。這裡記住一點，對於集合中元素，hashCode值不同的元素一定不相等，但是不相等的元素，hashCode值可能相同。

　　HashSet和LinkedHashSet的區別在於後者可以保證元素插入集合的元素順序與輸出順序保持一致。而TresSet的區別在於其排序是按照Comparator來進行排序的，預設情況下按照字元的自然順序進行升序排列。

　　(4)Iterable：從這個圖裡面可以看到Collection類繼承自Iterable，該介面的作用是提供元素遍歷的功能，也就是說所有的集合類（除Map相關的類）都提供元素遍歷的功能。Iterable裡面包含了Iterator的迭代器，其原始碼如下，大家如果熟悉迭代器模式的話，應該很容易理解。

1 public interface Iterator<E> {
2 
3     boolean hasNext();
4 
5     E next();
6 
7     void remove();
8 }

2、Map：

      Map型別的集合最大的優點在於其查詢效率比較高，理想情況下可以實現O(1)的時間複雜度。Map中最常用的是HashMap，LinkedHashMap與HashMap的區別在於前者能夠保證插入集合的元素順序與輸出順序一致。這兩者與TreeMap的區別在於TreeMap是根據鍵值進行排序的，當然其底層的實現也有本質的區別，如HashMap底層是一個雜湊表，而TreeMap的底層資料結構是一棵樹。我們現在看下TreeMap與LinkedHashMap的區別：

package com.paddx.test.collection;

import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.TreeMap;

public class MapTest {
    public static void main(String[] args) {
        Map<String,String> treeMap = new TreeMap<String,String>();
        Map<String,String> linkedMap = new LinkedHashMap<String, String>();

        treeMap.put("b",null);
        treeMap.put("c",null);
        treeMap.put("a",null);

        for (Iterator<String> iter = treeMap.keySet().iterator();iter.hasNext();){
            System.out.println("TreeMap="+iter.next());
        }

        System.out.println("----------分割線---------");

        linkedMap.put("b",null);
        linkedMap.put("c",null);
        linkedMap.put("a",null);

        for (Iterator<String> iter = linkedMap.keySet().iterator();iter.hasNext();){
            System.out.println("LinkedHashMap="+iter.next());
        }
    }
}

執行上述程式碼，執行結果如下：

TreeMap=a
TreeMap=b
TreeMap=c
----------分割線---------
LinkedHashMap=b
LinkedHashMap=c
LinkedHashMap=a

　　從執行結果可以很明顯的看出這TreeMap和LinkedHashMap的區別，前者是按字串排序進行輸出的，而後者是根據插入順序進行輸出的。細心的讀者可以發現，HashMap與TreeMap的區別，與之前提到的HashSet與TreeSet的區別是一致的，在後續進行原始碼分析的時候，我們可以看到HashSet和TreeSet本質上分別是通過HashMap和TreeMap來實現的，所以它們的區別自然也是相同的。HashTable現在已經很少使用了，與HashMap的主要區別是HashTable是執行緒安全的，不過由於其效率比較低，所以通常使用HashMap，在多執行緒環境下，通常用CurrentHashMap來代替。

三、總結

　　本文只是從整體上介紹了Java集合框架及其繼承關係。除了上述類，集合還提供Collections和Arrays兩個工具類，此外，集合中排序跟Comparable和Comparator緊密相關。在之後的文章中將對上述提的類在JDK中實現原始碼進行詳細分析。

相關文章