Java集合架構要點概括（Core Knowledge of Java Collection）

標籤：param   java集合架構   for   效能   yun   initial   應該   ica   static   

目錄

• 有哪些集合類
  • Set類
  • Queue類
  • List類
  • Map類
• HashMap的實現原理，是否安全執行緒，如何使其做到安全執行緒
  • HashMap的實現原理
• HashMap的安全執行緒問題

本文主要參考：

1. 《瘋狂Java講義精簡版》-李剛
2. HashMap實現原理分析

有哪些集合類

• 一圖終結

Set，Queue和List都是繼承了Collection，即大多數集合類的根介面。而Map則是單獨的另一個介面發散出來。

Set類

• HashSet:用雜湊演算法儲存集合中的元素，因此存取和尋找效能很好。但不是同步的，在有兩個以上線程同時操作HashSet時，需要用代碼保證其同步。集合元素值可以是null。當HastSet存入一個元素時,會調用該對象的HashCode()方法擷取其雜湊值，然後用雜湊值決定該對象在HashSet中的儲存位置。如果兩個元素通過equals方法比較返回true,但它們的HashCode方法傳回值不相等，HashSet會把它們儲存在不同位置。所以，HashSet集合判斷兩個元素相等的標準是兩個對象通過equals方法比較相等，且HashCode方法的傳回值也相等。（因此，重寫一個類的equals方法時，也應該重寫其HashCode方法，規則是：如果兩個對象equals返回true，則兩個對象的HashCode值也應該相同。如果不這樣做，導致equals返回true，而HashCode相同，則HashSet會把這兩個對象儲存在Hash表的不用位置，從而使兩個對象都添加成功，違背了Set集合的規則。）

• LinkedHashSet：HashSet的子類，和HashSet不同的是利用鏈表維護元素的次序，使得元素看起來是以插入的順序儲存的。因為需要維護元素的插入順序，因此效能略低於HashSet的效能。

• TreeSet：SortedSet介面的實作類別。保證元素的有序排列。支援兩種排序方法，一是自然排序，二是定製排序。自然排序是TreeSet調用元素的compareTo方法比較元素大小，而這就要求元素對應的類必須實現了Comparable介面並實現了CompareTo(Object obj)方法。Java的一些常用類如BigDecimal,BigInteger,所有數值型封裝類，Character,Boolean,String,Date,Time等都實現了Comparable介面。而定製排序，則是利用在構建TreeSet時，傳入Comparator匿名對象並實現其CompareTo方法。

Queue類

類比隊列這種資料結構。隊列是“先進先出”（FIFO）型的容器，尾部進元素，頭部出元素。

• ArrayQueue：Deque介面的實作類別，Deque介面是Queue介面的子介面，代表了一個雙端隊列，定義了一些雙端隊列的方法，這些方法允許從兩端來操作隊列的元素。ArrayDeque從名字來看，就知道是使用數組來實現的雙端隊列。（和ArrayList類似，底層都使用了一個動態，可重新分配的Object[]數組來儲存集合元素，當集合元素超出了該數組的容量時，系統會在底層重新分配一個Object數組來儲存集合元素。）。而ArrayDeque因為具有push和pop方法，因此可以當棧使用。

• PriorityQueue:一個比較標準的隊列實作類別，但是其儲存隊列元素的順序不是按排入佇列的順序，而是按隊列元素的大小進行重新排序。因此當調用peek方法或者poll方法取出隊列中的元素時，並不一定是取出最先進入隊列的元素，從這一點看，PriorityQueue已經違反了隊列的FIFO基本規則。

List類

線性表介面。

• ArrayList：內部用數組形式來儲存集合元素。線程不安全的。

• Vector：也是用數組形式來儲存集合元素，但是因為實現了線程同步功能，而實現機制卻不好，所以各方面效能比較差。

• Stack：Vector的子類，類比棧結構。同樣是安全執行緒，效能較差，所以應該盡量少使用。如果需要使用“棧”這種結構，可以考慮用ArrayDeQue。

• 固定長度的List:工具類Arrays裡提供了一個方法asList可以將以額數組或者制定個數的對象轉換成一個List集合，這個集合不是ArrayList或Vector實作類別的執行個體，而是Arrays內部類ArrayList的執行個體，是一個固定長度的List集合，程式只能遍曆訪問集合裡的元素，不可增加或刪除集合裡的元素。

• LinkedList:一個比較特殊的集合類，既實現了Deque介面，也實現了List介面（可以根據索引來訪問元素），所以可以當隊列和棧用。內部用鏈表形式來儲存集合元素，因此隨機訪問集合元素時效能較差，但在插入、刪除元素時效能比較出色。

如果多個線程需要同時訪問List集合中的元素，可以考慮使用Collections工具類將集合封裝成線程
安全的集合。

Map類

key-value型儲存方式。

Map和Set聯絡非常緊密，若將Map裡的value都當成key的附庸，那麼就可以像看待Set一樣看待Map了。而從Java源碼來看，也確實是先實現了Map，再封裝一個value都為null的Map來實現的Set集合。

• Hashtable：從名字上來看，就知道是一個古老的類，因為沒有遵守類名每個單字首大寫的規則。

• HashMap：Hashtable和HashMap都是Map的典型實作類別，關係類似於ArrayList和Vector。前者是一個古老的Map實作類別，並且是安全執行緒的，所以效能差於後者。並且Hashtable不允許null作為鍵或者值（會拋出null 指標異常），而HashMap可以。與HashSet類似，用作key的對象必須實現HashCode方法和equals方法，而判斷兩個value相等的方法則相對簡單，只要兩個對象通過equals方法比較返回true即可。

• LinkedHashMap：HashMap的子類，用雙向鏈表維護了key-value對的次序，因此效能略低於HashMap。

• Properties: Hashtable的子類，是一種key和value都為String類的map。如名字所述，該對象在處理屬性檔案時特別方便，可以把Map中的key-value對寫入屬性檔案中，也可以把屬性檔案中的“屬性名稱=屬性值”載入到Map對象中。

• TreeMap：SortedMap介面的實作類別。本身是一個紅/黑樹狀結構資料結構，每個kv對作為紅/黑樹狀結構的一個節點，儲存索引值對時根據key對節點進行排序。同樣分為自然排序和定製排序兩種方式。

HashMap的實現原理，是否安全執行緒，如何使其做到安全執行緒HashMap的實現原理

本部分來自HashMap實現原理分析

HashMap的資料結構

資料結構中有數組和鏈表來實現對資料的儲存，但這兩者基本上是兩個極端。

數組

數組儲存區間是連續的，佔用記憶體嚴重，故空間複雜的很大。但數組的二分尋找時間複雜度小，為O(1)；數組的特點是：定址容易，插入和刪除困難；

鏈表

鏈表格儲存體區間離散，佔用記憶體比較寬鬆，故空間複雜度很小，但時間複雜度很大，達O（N）。鏈表的特點是：定址困難，插入和刪除容易。

雜湊表

那麼我們能不能綜合兩者的特性，做出一種定址容易，插入刪除也容易的資料結構？答案是肯定的，這就是我們要提起的雜湊表。雜湊表（(Hash table）既滿足了資料的尋找方便，同時不佔用太多的內容空間，使用也十分方便。

　　雜湊表有多種不同的實現方法，我接下來解釋的是最常用的一種方法—— 拉鏈法，我們可以理解為“鏈表的數組” ，

從我們可以發現雜湊表是由數組+鏈表組成的，一個長度為16的數組中，每個元素儲存的是一個鏈表的頭結點。那麼這些元素是按照什麼樣的規則儲存到數組中呢。一般情況是通過hash(key)%len獲得，也就是元素的key的雜湊值對數組長度模數得到。比如上述雜湊表中，12%16=12,28%16=12,108%16=12,140%16=12。所以12、28、108以及140都儲存在數組下標為12的位置。

　　HashMap其實也是一個線性數組實現的,所以可以理解為其儲存資料的容器就是一個線性數組。這可能讓我們很不解，一個線性數組怎麼實現按索引值對來存取資料呢？這裡HashMap有做一些處理。

　　首先HashMap裡面實現一個靜態內部類Entry，其重要的屬性有 key , value, next，從屬性key,value我們就能很明顯的看出來Entry就是HashMap索引值對實現的一個基礎bean，我們上面說到HashMap的基礎就是一個線性數組，這個數組就是Entry[]，Map裡面的內容都儲存在Entry[]裡面。

/** * The table, resized as necessary. Length MUST Always be a power of two. */transient Entry[] table;

HashMap的存取實現

既然是線性數組，為什麼能隨機存取？這裡HashMap用了一個小演算法，大致是這樣實現：

// 儲存時:int hash = key.hashCode(); // 這個hashCode方法這裡不詳述,只要理解每個key的hash是一個固定的int值int index = hash % Entry[].length;Entry[index] = value;// 取值時:int hash = key.hashCode();int index = hash % Entry[].length;return Entry[index];

1)put

疑問：如果兩個key通過hash%Entry[].length得到的index相同，會不會有覆蓋的危險？
　　這裡HashMap裡面用到鏈式資料結構的一個概念。上面我們提到過Entry類裡面有一個next屬性，作用是指向下一個Entry。打個比方， 第一個索引值對A進來，通過計算其key的hash得到的index=0，記做:Entry[0] = A。一會後又進來一個索引值對B，通過計算其index也等於0，現在怎麼辦？HashMap會這樣做:B.next = A,Entry[0] = B,如果又進來C,index也等於0,那麼C.next = B,Entry[0] = C；這樣我們發現index=0的地方其實存取了A,B,C三個索引值對,他們通過next這個屬性連結在一起。所以疑問不用擔心。也就是說數組中儲存的是最後插入的元素。到這裡為止，HashMap的大致實現，我們應該已經清楚了。

 public V put(K key, V value) {        if (key == null)            return putForNullKey(value); //null總是放在數組的第一個鏈表中        int hash = hash(key.hashCode());        int i = indexFor(hash, table.length);        //遍曆鏈表        for (Entry<K,V> e = table[i]; e != null; e = e.next) {            Object k;            //如果key在鏈表中已存在，則替換為新value            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {                V oldValue = e.value;                e.value = value;                e.recordAccess(this);                return oldValue;            }        }        modCount++;        addEntry(hash, key, value, i);        return null;    } void addEntry(int hash, K key, V value, int bucketIndex) {    Entry<K,V> e = table[bucketIndex];    table[bucketIndex] = new Entry<K,V>(hash, key, value, e); //參數e, 是Entry.next    //如果size超過threshold，則擴充table大小。再散列    if (size++ >= threshold)            resize(2 * table.length);}

　　當然HashMap裡面也包含一些最佳化方面的實現，這裡也說一下。比如：Entry[]的長度一定後，隨著map裡面資料的越來越長，這樣同一個index的鏈就會很長，會不會影響效能？HashMap裡面設定一個因子，隨著map的size越來越大，Entry[]會以一定的規則加長長度。

2）get

 public V get(Object key) {        if (key == null)            return getForNullKey();        int hash = hash(key.hashCode());        //先定位到數組元素，再遍曆該元素處的鏈表        for (Entry<K,V> e = table[indexFor(hash, table.length)];             e != null;             e = e.next) {            Object k;            if (e.hash == hash && ((k = e.key) == key || key.equals(k)))                return e.value;        }        return null;} 

3）null key的存取
null key總是存放在Entry[]數組的第一個元素。

   private V putForNullKey(V value) {        for (Entry<K,V> e = table[0]; e != null; e = e.next) {            if (e.key == null) {                V oldValue = e.value;                e.value = value;                e.recordAccess(this);                return oldValue;            }        }        modCount++;        addEntry(0, null, value, 0);        return null;    }     private V getForNullKey() {        for (Entry<K,V> e = table[0]; e != null; e = e.next) {            if (e.key == null)                return e.value;        }        return null;    } 

4）確定數組index：hashcode % table.length模數
HashMap存取時，都需要計算當前key應該對應Entry[]數組哪個元素，即計算數組下標；演算法如下：

   /**     * Returns index for hash code h.     */    static int indexFor(int h, int length) {        return h & (length-1);    }

按位取並，作用上相當於模數mod或者取餘%。（位元運算的巧妙運用：由於位元運算不需要將數轉換為十進位，因此速度較快，而x mod/% n = x & (n-1)，故此處用按位與運算代替模數操作）
這意味著數組下標相同，並不表示hashCode相同。

5）table初始大小

  public HashMap(int initialCapacity, float loadFactor) {        .....        // Find a power of 2 >= initialCapacity        int capacity = 1;        while (capacity < initialCapacity)            capacity <<= 1;        this.loadFactor = loadFactor;        threshold = (int)(capacity * loadFactor);        table = new Entry[capacity];        init();    }

注意table初始大小並不是建構函式中的initialCapacity！！

而是 >= initialCapacity的2的n次冪！！！！

————為什麼這麼設計呢？——

解決hash衝突的辦法

開放定址法（線性探測再散列，二次探測再散列，偽隨機探測再散列）
再雜湊法
鏈地址法
建立一個公用溢出區
Java中hashmap的解決辦法就是採用的鏈地址法。

再散列rehash過程

當雜湊表的容量超過預設容量時，必須調整table的大小。當容量已經達到最大可能值時，那麼該方法就將容量調整到Integer.MAX_VALUE返回，這時，需要建立一張新表，將原表的映射到新表中。

   /**     * Rehashes the contents of this map into a new array with a     * larger capacity.  This method is called automatically when the     * number of keys in this map reaches its threshold.     *     * If current capacity is MAXIMUM_CAPACITY, this method does not     * resize the map, but sets threshold to Integer.MAX_VALUE.     * This has the effect of preventing future calls.     *     * @param newCapacity the new capacity, MUST be a power of two;     *        must be greater than current capacity unless current     *        capacity is MAXIMUM_CAPACITY (in which case value     *        is irrelevant).     */    void resize(int newCapacity) {        Entry[] oldTable = table;        int oldCapacity = oldTable.length;        if (oldCapacity == MAXIMUM_CAPACITY) {            threshold = Integer.MAX_VALUE;            return;        }        Entry[] newTable = new Entry[newCapacity];        transfer(newTable);        table = newTable;        threshold = (int)(newCapacity * loadFactor);    }     /**     * Transfers all entries from current table to newTable.     */    void transfer(Entry[] newTable) {        Entry[] src = table;        int newCapacity = newTable.length;        for (int j = 0; j < src.length; j++) {            Entry<K,V> e = src[j];            if (e != null) {                src[j] = null;                do {                    Entry<K,V> next = e.next;                    //重新計算index                    int i = indexFor(e.hash, newCapacity);                    e.next = newTable[i];                    newTable[i] = e;                    e = next;                } while (e != null);            }        }    }

簡單總結

對於HashSet及其子類而言，它們採用hash演算法來決定集合中元素的儲存位置，並通過hash演算法來控制集合的大小；對於HashMap、Hahstable及其子類而言，它們採用hash演算法來決定Map中key的儲存，並通過hash演算法來增加key集合的大小。hash表裡可以儲存元素的位置被稱為桶（bucket），通常情況下，每個桶裡儲存一個元素，此時有最好的效能，hash演算法可以根據hashCode值計算出桶的儲存位置，接著從桶中取出元素。但hash表的狀態是open的：在發生hash衝突的情況下，單個桶會儲存多個元素，這些元素以鏈表形式儲存，必須按順序搜尋。HashSet和HashMap的hash表都包含如下屬性：- 容量capacity:hash表中通的數量- 初始化容量initial capacity：建立hash表時桶的數量。- 尺寸size：當前hash表中記錄的數量- 負載因子load factor：負載因子=size/capacity，是一個0-1數值。負載因子為0時表示空的hash表，0.5表示半滿的hash表，因此，輕負載的hash表具有衝突少，適宜插入與查詢的特點。除此之外，hash表裡有一個負載極限值，當負載因子達到這個值時，hash表會自動成倍增加容量，並將原有的對象重新分配，放入新的桶內，稱為再雜湊Rehashing。

HashMap的安全執行緒問題

HashMap本身不是安全執行緒的（HashSet,TreeSet,ArrayList,ArrayDeque,LinkedList也都不是安全執行緒的），可以用Collections提供的類方法將它們封裝成線程同步的集合。

Collection c=Collections,synchronizedCollection(new ArrayList());List list=Collections.synchronizedList(new ArrayList());Set s=Collections.synchronizedSet(new HashSet());Map m=Collections,synchronizedMap(new HashMap());

Java集合架構要點概括（Core Knowledge of Java Collection）