Java集合

 

 

Iterator

迭代器，全部的collection集合相關的類均可以使用迭代器遍歷。迭代器Iterator是一個接口，它提供的API有：

 

 

 

 

 

 

 

 

1

abstract boolean hasNext()

2

abstract E next()

3

abstract void remove()

 

 

ListIterator

listIterator是一個接口，繼承了Iterator接口。因爲這個迭代器只適用於List接口的實現類，由list的特殊性，這個迭代器在list的基礎上增長了許多方法：

在Iterator的基礎上，新增的方法有：

 

 

 

6

 

 

 

 

1

abstract void add(E object)

2

abstract boolean hasPrevious()

3

abstract int nextIndex()

4

abstract E previous()

5

abstract int previousIndex()

6

abstract void set(E object)

 

 

Map

 

 

1. Map 是映射接口，Map中存儲的內容是鍵值對(key-value)。
2. AbstractMap 是繼承於Map的抽象類，它實現了Map中的大部分API。其它Map的實現類能夠經過繼承AbstractMap來減小重複編碼。
3. SortedMap 是繼承於Map的接口。SortedMap中的內容是排序的鍵值對，排序的方法是經過比較器(Comparator)。
4. NavigableMap 是繼承於SortedMap的接口。相比於SortedMap，NavigableMap有一系列的導航方法，如"獲取大於/等於某對象的鍵值對"、「獲取小於/等於某對象的鍵值對」等等。
5. TreeMap 繼承於AbstractMap，且實現了NavigableMap接口；所以，TreeMap中的內容是「有序的鍵值對」
6. HashMap 繼承於AbstractMap，但沒實現NavigableMap接口；所以，HashMap的內容是「鍵值對，但不保證次序」！
7. Hashtable 雖然不是繼承於AbstractMap，但它繼承於Dictionary(Dictionary也是鍵值對的接口)，並且也實現Map接口；所以，Hashtable的內容也是「鍵值對，也不保證次序」。但和HashMap相比，Hashtable是線程安全的，並且它支持經過Enumeration去遍歷。
8. WeakHashMap 繼承於AbstractMap。它和HashMap的鍵類型不一樣，WeakHashMap的鍵是「弱鍵」。

Map的API：

 

 

 

14

 

 

 

 

1

abstract void                 clear()

2

abstract boolean              containsKey(Object key)

3

abstract boolean              containsValue(Object value)

4

abstract Set<Entry<K, V>>     entrySet()

5

abstract boolean              equals(Object object)

6

abstract V                    get(Object key)

7

abstract int                  hashCode()

8

abstract boolean              isEmpty()

9

abstract Set<K>               keySet()

10

abstract V                    put(K key, V value)

11

abstract void                 putAll(Map<? extends K, ? extends V> map)

12

abstract V                    remove(Object key)

13

abstract int                  size()

14

abstract Collection<V>        values()

 

 

有一部分來自於collection接口。

1. 關於MAPMap提供接口分別用於返回 鍵集、值集或鍵-值映射關係集。

   1. entrySet()用於返回鍵-值（Map.Entry）集的Set集合
   2. keySet()用於返回鍵集的Set集合
   3. values()用戶返回值集的Collection集合

2. 由於Map中不能包含重複的鍵；每一個鍵最多隻能映射到一個值。因此，鍵-值集、鍵集都是Set，值集時Collection。

3. Map提供了「鍵-值對」、「根據鍵獲取值」、「刪除鍵」、「獲取容量大小」等方法。

 

 

 

​x

 

 

 

 

1

package com.xzj;

2

​

3

import java.awt.*;

4

import java.util.*;

5

import java.util.Map.Entry;

6

​

7

​

8

// @ author :zjxu time:2019-01-14

9

public class Main {

10

    public static void main(String[] args) {

11

        Map<String, Point> hashMap = new HashMap<>();

12

​

13

        hashMap.put("xzj", new Point(23, 326));

14

        hashMap.put("xxx", new Point(23, 325));

15

        hashMap.put("yyy", new Point(23, 324));

16

        hashMap.put("zzz", new Point(23, 327));

17

​

18

        Collection<Point> values = hashMap.values();

19

        Iterator iteratorValue = values.iterator();

20

        while (iteratorValue.hasNext()) {

21

            System.out.println(iteratorValue.next().toString());

22

        }

23

24

        Set<Entry<String, Point>> entrySet = hashMap.entrySet();

25

        Iterator<Entry<String, Point>> iteratorEntry = entrySet.iterator();

26

        while (iteratorEntry.hasNext()) {

27

            System.out.println(iteratorEntry.next().toString());

28

        }

29

​

30

​

31

    }

32

}

 

 

SortedMap

SortedMap是一個繼承於Map接口的接口。它是一個有序的SortedMap鍵值映射。SortedMap的排序方式有兩種：天然排序 、 用戶指定比較器。

插入有序 SortedMap 的全部元素都必須實現 Comparable 接口（或者被指定的比較器所接受）。

另外，全部SortedMap 實現類都應該提供 4 個「標準」構造方法：

1. void（無參數）構造方法，它建立一個空的有序映射，按照鍵的天然順序進行排序。
2. 帶有一個 Comparator 類型參數的構造方法，它建立一個空的有序映射，根據指定的比較器進行排序。
3. 帶有一個 Map 類型參數的構造方法，它建立一個新的有序映射，其鍵-值映射關係與參數相同，按照鍵的天然順序進行排序。
4. 帶有一個 SortedMap 類型參數的構造方法，它建立一個新的有序映射，其鍵-值映射關係和排序方法與輸入的有序映射相同。沒法保證強制實施此建議，由於接口不能包含構造方法。

NavigableMap

NavigableMap是繼承於SortedMap的接口。它是一個可導航的鍵-值對集合，具備了爲給定搜索目標報告最接近匹配項的導航方法。 ​NavigableMap分別提供了獲取「鍵」、「鍵-值對」、「鍵集」、「鍵-值對集」的相關方法。

API以下：

 

 

 

21

 

 

 

 

1

abstract Entry<K, V>             ceilingEntry(K key)

2

abstract Entry<K, V>             firstEntry()

3

abstract Entry<K, V>             floorEntry(K key)

4

abstract Entry<K, V>             higherEntry(K key)

5

abstract Entry<K, V>             lastEntry()

6

abstract Entry<K, V>             lowerEntry(K key)

7

abstract Entry<K, V>             pollFirstEntry()

8

abstract Entry<K, V>             pollLastEntry()

9

abstract K                       ceilingKey(K key)

10

abstract K                       floorKey(K key)

11

abstract K                       higherKey(K key)

12

abstract K                       lowerKey(K key)

13

abstract NavigableSet<K>         descendingKeySet()

14

abstract NavigableSet<K>         navigableKeySet()

15

abstract NavigableMap<K, V>      descendingMap()

16

abstract NavigableMap<K, V>      headMap(K toKey, boolean inclusive)

17

abstract SortedMap<K, V>         headMap(K toKey)

18

abstract SortedMap<K, V>         subMap(K fromKey, K toKey)

19

abstract NavigableMap<K, V>      subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive)

20

abstract SortedMap<K, V>         tailMap(K fromKey)

21

abstract NavigableMap<K, V>      tailMap(K fromKey, boolean inclusive)

 

 

其中的API大體分爲以下幾類：

1. 提供操做鍵-值對的方法。

   1. lowerEntry、floorEntry、ceilingEntry 和 higherEntry 方法，它們分別返回與小於、小於等於、大於等於、大於給定鍵的鍵關聯的 Map.Entry 對象。
   2. firstEntry、pollFirstEntry、lastEntry 和 pollLastEntry 方法，它們返回和/或移除最小和最大的映射關係（若是存在），不然返回 null。

2. 提供操做鍵的方法。這個和第1類比較相似。

   1. lowerKey、floorKey、ceilingKey 和 higherKey 方法，它們分別返回與小於、小於等於、大於等於、大於給定鍵的鍵。

3. 獲取鍵集。

   1. navigableKeySet、descendingKeySet分別獲取正序/反序的鍵集。

4. 獲取鍵-值對的子集。

AbstractMap

1. AbstractMap類提供 Map 接口的骨幹實現，以最大限度地減小實現此接口所需的工做。
2. 要實現不可修改的映射，編程人員只需擴展此類並提供 entrySet 方法的實現便可，該方法將返回映射的映射關係 set 視圖。
3. 一般，返回的 set 將依次在 AbstractSet 上實現。此 set 不支持 add() 或 remove() 方法，其迭代器也不支持 remove() 方法。
4. 要實現可修改的映射，編程人員必須另外重寫此類的 put 方法（不然將拋出 UnsupportedOperationException），entrySet().iterator() 返回的迭代器也必須另外實現其 remove 方法。

AbstractMap實現了Map、接口中的大部分方法。然後添加了一個entrySet的方法。沒有繼承這個抽象類的HashTable沒有這個方法。

 

 

 

16

 

 

 

 

1

abstract Set<Entry<K, V>>     entrySet()

2

         void                 clear()

3

         boolean              containsKey(Object key)

4

         boolean              containsValue(Object value)

5

         boolean              equals(Object object)

6

         V                    get(Object key)

7

         int                  hashCode()

8

         boolean              isEmpty()

9

         Set<K>               keySet()

10

         V                    put(K key, V value)

11

         void                 putAll(Map<? extends K, ? extends V> map)

12

         V                    remove(Object key)

13

         int                  size()

14

         String               toString()

15

         Collection<V>        values()

16

         Object               clone()

 

 

 

TreeMap

1. TreeMap 是一個有序的key-value集合，它是經過紅黑樹實現的。
2. TreeMap 繼承於AbstractMap，因此它是一個Map，即一個key-value集合。
3. TreeMap 實現了NavigableMap接口，意味着它支持一系列的導航方法。好比返回有序的key集合。
4. TreeMap 實現了Cloneable接口，意味着它能被克隆。
5. TreeMap 實現了java.io.Serializable接口，意味着它支持序列化。
6. TreeMap基於紅黑樹實現。該映射根據其鍵的天然順序進行排序，或者根據建立映射時提供的 Comparator 進行排序，具體取決於使用的構造方法。
7. TreeMap的基本操做 containsKey、get、put 和 remove 的時間複雜度是 log(n) 。
8. 另外，TreeMap是非同步的。

API以下：

 

 

 

34

 

 

 

 

1

Entry<K, V>                ceilingEntry(K key)

2

K                          ceilingKey(K key)

3

void                       clear()

4

Object                     clone()

5

Comparator<? super K>      comparator()

6

boolean                    containsKey(Object key)

7

NavigableSet<K>            descendingKeySet()

8

NavigableMap<K, V>         descendingMap()

9

Set<Entry<K, V>>           entrySet()

10

Entry<K, V>                firstEntry()

11

K                          firstKey()

12

Entry<K, V>                floorEntry(K key)

13

K                          floorKey(K key)

14

V                          get(Object key)

15

NavigableMap<K, V>         headMap(K to, boolean inclusive)

16

SortedMap<K, V>            headMap(K toExclusive)

17

Entry<K, V>                higherEntry(K key)

18

K                          higherKey(K key)

19

boolean                    isEmpty()

20

Set<K>                     keySet()

21

Entry<K, V>                lastEntry()

22

K                          lastKey()

23

Entry<K, V>                lowerEntry(K key)

24

K                          lowerKey(K key)

25

NavigableSet<K>            navigableKeySet()

26

Entry<K, V>                pollFirstEntry()

27

Entry<K, V>                pollLastEntry()

28

V                          put(K key, V value)

29

V                          remove(Object key)

30

int                        size()

31

SortedMap<K, V>            subMap(K fromInclusive, K toExclusive)

32

NavigableMap<K, V>         subMap(K from, boolean fromInclusive, K to, boolean toInclusive)

33

NavigableMap<K, V>         tailMap(K from, boolean inclusive)

34

SortedMap<K, V>            tailMap(K fromInclusive)

 

 

HashMap

1. HashMap 是一個散列表，它存儲的內容是鍵值對(key-value)映射。
2. 繼承於AbstractMap，實現了Map、Cloneable、java.io.Serializable接口。
3. HashMap 的實現不是同步的，這意味着它不是線程安全的。它的key、value均可覺得null。此外，HashMap中的映射不是有序的。

HashMap 的實例有兩個參數影響其性能：「初始容量」 和 「加載因子」。容量 是哈希表中桶的數量，初始容量 只是哈希表在建立時的容量。加載因子 是哈希表在其容量自動增長以前能夠達到多滿的一種尺度。當哈希表中的條目數超出了加載因子與當前容量的乘積時，則要對該哈希表進行 rehash 操做（即重建內部數據結構），從而哈希表將具備大約兩倍的桶數。 ​一般，默認加載因子是 0.75, 這是在時間和空間成本上尋求一種折衷。加載因子太高雖然減小了空間開銷，但同時也增長了查詢成本（在大多數 HashMap 類的操做中，包括 get 和 put 操做，都反映了這一點）。在設置初始容量時應該考慮到映射中所需的條目數及其加載因子，以便最大限度地減小 rehash 操做次數。若是初始容量大於最大條目數除以加載因子，則不會發生 rehash 操做。

API以下：

 

 

 

13

 

 

 

 

1

void                 clear()

2

Object               clone()

3

boolean              containsKey(Object key)

4

boolean              containsValue(Object value)

5

Set<Entry<K, V>>     entrySet()

6

V                    get(Object key)

7

boolean              isEmpty()

8

Set<K>               keySet()

9

V                    put(K key, V value)

10

void                 putAll(Map<? extends K, ? extends V> map)

11

V                    remove(Object key)

12

int                  size()

13

Collection<V>        values()

 

 

LinkedHashMap

Map基本均可以使用HashMap，不過HashMap有一個問題，就是迭代HashMap的順序並非HashMap放置的順序，也就是無序。HashMap的這一缺點每每會帶來困擾，由於有些場景，咱們期待一個有序的Map。

這個時候，LinkedHashMap就閃亮登場了，他繼承自HashMap，雖然增長了時間和空間上的開銷，可是經過維護一個運行於全部條目的雙向鏈表，LinkedHashMap保證了元素迭代的順序。該迭代順序能夠是插入順序或者是訪問順序。

關 注 點	結 論
LinkedHashMap是否容許空	Key和Value都容許空
LinkedHashMap是否容許重複數據	Key重複會覆蓋、Value容許重複
LinkedHashMap是否有序	有序
LinkedHashMap是否線程安全	非線程安全

一、LinkedHashMap能夠認爲是HashMap+LinkedList，即它既使用HashMap操做數據結構，又使用LinkedList維護插入元素的前後順序。

二、LinkedHashMap的基本實現思想就是----多態。能夠說，理解多態，再去理解LinkedHashMap原理會事半功倍；反之也是，對於LinkedHashMap原理的學習，也能夠促進和加深對於多態的理解。

HashTable

因爲HashMap和HashTable的特殊關係，這裏就只討論兩者區別。

HashMap和Hashtable的比較是Java面試中的常見問題，用來考驗程序員是否可以正確使用集合類以及是否能夠隨機應變使用多種思路解決問題。HashMap的工做原理、ArrayList與Vector的比較以及這個問題是有關Java 集合框架的最經典的問題。Hashtable是個過期的集合類，存在於Java API中好久了。在Java 4中被重寫了，實現了Map接口，因此自此之後也成了Java集合框架中的一部分。Hashtable和HashMap在Java面試中至關容易被問到，甚至成爲了集合框架面試題中最常被考的問題，因此在參加任何Java面試以前，都不要忘了準備這一題。

HashMap和Hashtable都實現了Map接口，但決定用哪個以前先要弄清楚它們之間的分別。主要的區別有：線程安全性，同步(synchronization)，以及速度。

1. HashMap幾乎能夠等價於Hashtable，除了HashMap是非synchronized的，並能夠接受null（ HashMap能夠接受爲null的鍵值(key)和值(value)，而Hashtable則不行 ）。
2. HashMap是非synchronized，而Hashtable是synchronized，這意味着Hashtable是線程安全的，多個線程能夠共享一個Hashtable；而若是沒有正確的同步的話，多個線程是不能共享HashMap的。Java 5提供了ConcurrentHashMap，它是HashTable的替代，比HashTable的擴展性更好。
3. 另外一個區別是HashMap的迭代器(Iterator)是fail-fast迭代器，而Hashtable的enumerator迭代器不是fail-fast的。因此當有其它線程改變了HashMap的結構（增長或者移除元素），將會拋出ConcurrentModificationException，但迭代器自己的remove()方法移除元素則不會拋出ConcurrentModificationException異常。但這並非一個必定發生的行爲，要看JVM。這條一樣也是Enumeration和Iterator的區別。
4. 因爲Hashtable是線程安全的也是synchronized，因此在單線程環境下它比HashMap要慢。若是你不須要同步，只須要單一線程，那麼使用HashMap性能要好過Hashtable。
5. HashMap不能保證隨着時間的推移Map中的元素次序是不變的。

HashMap能夠經過下面的語句進行同步： Map m = Collections.synchronizeMap(hashMap);

Collection

Collection是一個接口，其下有兩個接口和（List接口和Set接口）一個抽象類（AbstractCollection）。

因爲Collection實現了Iterator接口，因此collection全部的實現類對象，均可以使用迭代器Iterator遍歷

collection提供的API以下：

 

 

 

15

 

 

 

 

1

abstract boolean         add(E object)

2

abstract boolean         addAll(Collection<? extends E> collection)

3

abstract void            clear()

4

abstract boolean         contains(Object object)

5

abstract boolean         containsAll(Collection<?> collection)

6

abstract boolean         equals(Object object)

7

abstract int             hashCode()

8

abstract boolean         isEmpty()

9

abstract Iterator<E>     iterator()

10

abstract boolean         remove(Object object)

11

abstract boolean         removeAll(Collection<?> collection)

12

abstract boolean         retainAll(Collection<?> collection)

13

abstract int             size()

14

abstract <T> T[]         toArray(T[] array)

15

abstract Object[]        toArray()

 

 

全部的Collection的實現類的構造方法，均可以使用另外一個Collection的對象做爲參數，添加進去，從而構造一個新的collection對象。也就是說，能夠經過構造方法，將一個collection的對象，轉化成另外一種集合類對象。

 

 

 

24

 

 

 

 

1

package com.xzj;

2

​

3

import java.awt.*;

4

import java.util.ArrayList;

5

import java.util.HashSet;

6

import java.util.Iterator;

7

import java.util.Set;

8

​

9

// @ author :zjxu time:2019-01-14

10

public class Main {

11

    public static void main(String[] args) {

12

        ArrayList<Point> arrayList = new ArrayList<>();

13

        arrayList.add(new Point(0, 3));

14

        arrayList.add(new Point(1, 2));

15

​

16

        Set<Point> set = new HashSet(arrayList);

17

​

18

        Iterator iterator = set.iterator();

19

        while (iterator.hasNext()) {

20

            System.out.println(iterator.next().toString());

21

        }

22

    }

23

}

24

​

 

 

List

list是一個接口，抽象類AbstractList實現了這個接口和AbstractCollection這個抽象類。

list是一個有序的隊列 。其中的每個元素都有本身的index，從’0’開始，依次增長。因爲序列性，可使用for-index遍歷。

list中能夠存在重複的元素。

list中容許使用空元素

list在collection的基礎上添加的API以下：

 

 

 

10

 

 

 

 

1

abstract void                add(int location, E object)

2

abstract boolean             addAll(int location, Collection<? extends E> collection)

3

abstract E                   get(int location)

4

abstract int                 indexOf(Object object)

5

abstract int                 lastIndexOf(Object object)

6

abstract ListIterator<E>     listIterator(int location)

7

abstract ListIterator<E>     listIterator()

8

abstract E                   remove(int location)

9

abstract E                   set(int location, E object)

10

abstract List<E>             subList(int start, int end)

 

 

ArrayList

繼承圖：

 

1. ArrayList 是一個數組隊列，至關於 動態數組。與Java中的數組相比，它的容量能動態增加。
2. ArrayList 繼承了AbstractList，實現了List。它是一個數組隊列，提供了相關的添加、刪除、修改、遍歷等功能。
3. ArrayList實現了RandmoAccess接口，即提供了隨機訪問功能。在ArrayList中，咱們便可以經過元素的index快速獲取元素對象，這就是快速隨機訪問。
4. ArrayList 實現Serializable接口，這意味着ArrayList支持序列化，能經過序列化去傳輸。
5. ArrayList 實現了Cloneable接口，即覆蓋了函數clone()，能被克隆。

ArrayList的API以下：

 

 

 

32

 

 

 

 

1

// Collection中定義的API

2

boolean             add(E object)

3

boolean             addAll(Collection<? extends E> collection)

4

void                clear()

5

boolean             contains(Object object)

6

boolean             containsAll(Collection<?> collection)

7

boolean             equals(Object object)

8

int                 hashCode()

9

boolean             isEmpty()

10

Iterator<E>         iterator()

11

boolean             remove(Object object)

12

boolean             removeAll(Collection<?> collection)

13

boolean             retainAll(Collection<?> collection)

14

int                 size()

15

<T> T[]             toArray(T[] array)

16

Object[]            toArray()

17

// AbstractCollection中定義的API

18

void                add(int location, E object)

19

boolean             addAll(int location, Collection<? extends E> collection)

20

E                   get(int location)

21

int                 indexOf(Object object)

22

int                 lastIndexOf(Object object)

23

ListIterator<E>     listIterator(int location)

24

ListIterator<E>     listIterator()

25

E                   remove(int location)

26

E                   set(int location, E object)

27

List<E>             subList(int start, int end)

28

// ArrayList新增的API

29

Object               clone()

30

void                 ensureCapacity(int minimumCapacity)

31

void                 trimToSize()

32

void                 removeRange(int fromIndex, int toIndex)

 

 

Vector

vector的繼承圖：

 

 

1. Vector 是矢量隊列，它是JDK1.0版本添加的類。繼承於AbstractList，實現了List, RandomAccess, Cloneable這些接口。
2. Vector 繼承了AbstractList，實現了List；因此，它是一個隊列，支持相關的添加、刪除、修改、遍歷等功能。
3. Vector 實現了RandmoAccess接口，即提供了隨機訪問功能。RandmoAccess是java中用來被List實現，爲List提供快速訪問功能的。
4. 在Vector中，咱們能夠經過元素的序號快速獲取元素對象；這就是快速隨機訪問。
5. Vector 實現了Cloneable接口，即實現clone()函數。它能被克隆。
6. 和ArrayList不一樣，Vector中的操做是線程安全的。

API：

 

 

 

41

 

 

 

 

1

synchronized boolean        add(E object)

2

             void           add(int location, E object)

3

synchronized boolean        addAll(Collection<? extends E> collection)

4

synchronized boolean        addAll(int location, Collection<? extends E> collection)

5

synchronized void           addElement(E object)

6

synchronized int            capacity()

7

             void           clear()

8

synchronized Object         clone()

9

             boolean        contains(Object object)

10

synchronized boolean        containsAll(Collection<?> collection)

11

synchronized void           copyInto(Object[] elements)

12

synchronized E              elementAt(int location)

13

             Enumeration<E> elements()

14

synchronized void           ensureCapacity(int minimumCapacity)

15

synchronized boolean        equals(Object object)

16

synchronized E              firstElement()

17

             E              get(int location)

18

synchronized int            hashCode()

19

synchronized int            indexOf(Object object, int location)

20

             int            indexOf(Object object)

21

synchronized void           insertElementAt(E object, int location)

22

synchronized boolean        isEmpty()

23

synchronized E              lastElement()

24

synchronized int            lastIndexOf(Object object, int location)

25

synchronized int            lastIndexOf(Object object)

26

synchronized E              remove(int location)

27

             boolean        remove(Object object)

28

synchronized boolean        removeAll(Collection<?> collection)

29

synchronized void           removeAllElements()

30

synchronized boolean        removeElement(Object object)

31

synchronized void           removeElementAt(int location)

32

synchronized boolean        retainAll(Collection<?> collection)

33

synchronized E              set(int location, E object)

34

synchronized void           setElementAt(E object, int location)

35

synchronized void           setSize(int length)

36

synchronized int            size()

37

synchronized List<E>        subList(int start, int end)

38

synchronized <T> T[]        toArray(T[] contents)

39

synchronized Object[]       toArray()

40

synchronized String         toString()

41

synchronized void           trimToSize()

 

 

 

LinkedList

繼承圖：

 

 

1. LinkedList 是一個繼承於AbstractSequentialList的雙向鏈表。它也能夠被看成堆棧、隊列或雙端隊列進行操做。
2. LinkedList 實現 List 接口，能對它進行隊列操做。
3. LinkedList 實現 Deque 接口，即能將LinkedList看成雙端隊列使用
4. LinkedList 實現了Cloneable接口，即覆蓋了函數clone()，能克隆。
5. LinkedList 實現java.io.Serializable接口，這意味着LinkedList支持序列化，能經過序列化去傳輸。
6. LinkedList 是非同步的。

LinkedList的本質是雙向鏈表。

• header是雙向鏈表的表頭，它是雙向鏈表節點所對應的類Entry的實例
• Entry中包含成員變量： previous, next, element。
• 其中，previous是該節點的上一個節點，next是該節點的下一個節點，element是該節點所包含的值。
• size是雙向鏈表中節點的個數。
• LinkedList繼承於AbstractSequentialList，而且實現了Dequeue接口。
• LinkedList包含兩個重要的成員：header 和 size。 　　

API:

 

 

 

39

 

 

 

 

1

boolean       add(E object)

2

void          add(int location, E object)

3

boolean       addAll(Collection<? extends E> collection)

4

boolean       addAll(int location, Collection<? extends E> collection)

5

void          addFirst(E object)

6

void          addLast(E object)

7

void          clear()

8

Object        clone()

9

boolean       contains(Object object)

10

Iterator<E>   descendingIterator()

11

E             element()

12

E             get(int location)

13

E             getFirst()

14

E             getLast()

15

int           indexOf(Object object)

16

int           lastIndexOf(Object object)

17

ListIterator<E>     listIterator(int location)

18

boolean       offer(E o)

19

boolean       offerFirst(E e)

20

boolean       offerLast(E e)

21

E             peek()

22

E             peekFirst()

23

E             peekLast()

24

E             poll()

25

E             pollFirst()

26

E             pollLast()

27

E             pop()

28

void          push(E e)

29

E             remove()

30

E             remove(int location)

31

boolean       remove(Object object)

32

E             removeFirst()

33

boolean       removeFirstOccurrence(Object o)

34

E             removeLast()

35

boolean       removeLastOccurrence(Object o)

36

E             set(int location, E object)

37

int           size()

38

<T> T[]       toArray(T[] contents)

39

Object[]     toArray()

 

 

 

Stack

繼承圖：

Stack是棧。它的特性是：先進後出(FILO, First In Last Out)。

java工具包中的Stack是繼承於Vector(矢量隊列)的，因爲Vector是經過數組實現的，這就意味着，Stack也是經過數組實現的，而非鏈表。固然，咱們也能夠將LinkedList看成棧來使用！

因爲Stack和繼承於Vector，所以它也包含Vector中的所有API。

其中經常使用的API以下：

 

 

 

5

 

 

 

 

1

             boolean       empty()

2

synchronized E             peek()

3

synchronized E             pop()

4

             E             push(E object)

5

synchronized int           search(Object o)

 

 

List總結

 

1. List 是一個接口，它繼承於Collection的接口。它表明着有序的隊列。
2. AbstractList 是一個抽象類，它繼承於AbstractCollection。AbstractList實現List接口中除size()、get(int location)以外的函數。
3. AbstractSequentialList 是一個抽象類，它繼承於AbstractList，實現了「鏈表中，根據index索引值操做鏈表的所有函數」。
4. ArrayList, LinkedList, Vector, Stack是List的4個實現類。
5. ArrayList 是一個數組隊列，至關於動態數組。它由數組實現，隨機訪問效率高，隨機插入、隨機刪除效率低。
6. LinkedList 是一個雙向鏈表。它也能夠被看成堆棧、隊列或雙端隊列進行操做。LinkedList隨機訪問效率低，但隨機插入、隨機刪除效率低。
7. Vector 是矢量隊列，和ArrayList同樣，它也是一個動態數組，由數組實現。可是ArrayList是非線程安全的，而Vector是線程安全的。
8. Stack 是棧，它繼承於Vector。它的特性是：先進後出(FILO, First In Last Out)。

Set

 

1. Set 是繼承於Collection的接口。它是一個不容許有重複元素的集合。
2. AbstractSet 是一個抽象類，它繼承於AbstractCollection
3. AbstractCollection實現了Set中的絕大部分函數，爲Set的實現類提供了便利。
4. HastSet 和 TreeSet 是Set的兩個實現類。
5. HashSet依賴於HashMap，它其實是經過HashMap實現的。HashSet中的元素是無序的。
6. TreeSet依賴於TreeMap，它其實是經過TreeMap實現的。TreeSet中的元素是有序的。
7. Set都是線程不安全的。

TreeSet

繼承圖

 

1. TreeSet 是一個有序的集合，它的做用是提供有序的Set集合。
2. 它繼承於AbstractSet抽象類，實現了NavigableSet, Cloneable, java.io.Serializable接口。
3. TreeSet 繼承於AbstractSet，因此它是一個Set集合，具備Set的屬性和方法。
4. TreeSet 實現了NavigableSet接口，意味着它支持一系列的導航方法。好比查找與指定目標最匹配項。
5. TreeSet 實現了Cloneable接口，意味着它能被克隆。
6. TreeSet 實現了java.io.Serializable接口，意味着它支持序列化。

在Set中，數據存儲的結構是無序的。TreeSet對Set中的元素排序，因爲TreeSet的有序性，因此TreeSet中不容許有空元素的存在。TreeSet中元素排序的方式有兩種：天然排序和比較器排序。排序的結果的存儲結構使用紅黑樹。

1 天然排序方法要求添加進入set的元素自身實現Comparable接口，重寫compareTo方法。按照compareTo規定的排序規則，來對添加進Set的元素排序。

2 比較器排序的方法就是，編寫一個比較器的對象，在初始化的時候，將其加載到TreeSet的構造函數中。這樣，set中的元素就會按照比較器的規則來將插入set中的元素排序。

下面是TreeSet的API：

 

 

 

26

 

 

 

 

1

boolean                   add(E object)

2

boolean                   addAll(Collection<? extends E> collection)

3

void                      clear()

4

Object                    clone()

5

boolean                   contains(Object object)

6

E                         first()

7

boolean                   isEmpty()

8

E                         last()

9

E                         pollFirst()

10

E                         pollLast()

11

E                         lower(E e)

12

E                         floor(E e)

13

E                         ceiling(E e)

14

E                         higher(E e)

15

boolean                   remove(Object object)

16

int                       size()

17

Comparator<? super E>     comparator()

18

Iterator<E>               iterator()

19

Iterator<E>               descendingIterator()

20

SortedSet<E>              headSet(E end)

21

NavigableSet<E>           descendingSet()

22

NavigableSet<E>           headSet(E end, boolean endInclusive)

23

SortedSet<E>              subSet(E start, E end)

24

NavigableSet<E>           subSet(E start, boolean startInclusive, E end, boolean endInclusive)

25

NavigableSet<E>           tailSet(E start, boolean startInclusive)

26

SortedSet<E>              tailSet(E start)

 

 

 

HashSet

繼承圖：

 

 

1. HashSet 是一個沒有重複元素的集合。
2. 它是由HashMap實現的，不保證元素的順序，並且HashSet容許使用 null 元素。
3. HashSet是非同步的。

HashSet的主要API：

 

 

 

8

 

 

 

 

1

boolean         add(E object)

2

void            clear()

3

Object          clone()

4

boolean         contains(Object object)

5

boolean         isEmpty()

6

Iterator<E>     iterator()

7

boolean         remove(Object object)

8

int             size()

 

 

 

LinkedHashSet

1. LinkedHashSet集合一樣是根據元素的hashCode值來決定元素的存儲位置，可是它同時使用鏈表維護元素的次序。
2. 這樣使得元素看起來像是以插入順序保存的，也就是說，當遍歷該集合時候，LinkedHashSet將會以元素的添加順序訪問集合的元素。
3. 可是實際上，它的保存順序是按照哈希碼保存的。
4. 容許能夠存在空元素，空元素的遍歷順序在最前。

set總結

Set的結構圖以下：

 

1. HashSet是無序的（按照hash順序的，可是Hash是無序的）。
2. Tree是有序的，擁有本身的比較器或者是比較方法。
3. LinkedHashSet在HashSet的基礎上，使用鏈表將HashSet中的元素鏈接起來，遍歷順序添加的順序。

Queue

Queue是一個接口，其下還有Deque、BlockingQueue、AbstractQueue接口。

結構圖：

 

PriorityQueue

1. 非線程安全，該線程安全版本爲PriorityBlockingQueue。
2. 不容許使用非空元素。
3. 其實是一個堆，默認爲最小堆，也能夠添加比較器。
4. 新建對象的時候能夠指定一個初始容量，其容量會自動增長。
5. 不容許使用 null 元素。
6. 對元素採用的是堆排序，迭代器只是對整個數組的依次遍歷。

API以下：

Modifier and Type	Method and Description
boolean	add(E e)將指定的元素插入到此優先級隊列中。
void	clear()今後優先級隊列中刪除全部元素。
Comparator<? super E>	comparator()返回用於爲了在這個隊列中的元素，或比較null若是此隊列根據所述排序natural ordering的元素。
boolean	contains(Object o)若是此隊列包含指定的元素，則返回 true 。
Iterator<E>	iterator()返回此隊列中的元素的迭代器。
boolean	offer(E e)將指定的元素插入到此優先級隊列中。
E	peek()檢索但不刪除此隊列的頭，若是此隊列爲空，則返回 null 。
E	poll()檢索並刪除此隊列的頭，若是此隊列爲空，則返回 null 。
boolean	remove(Object o)從該隊列中刪除指定元素的單個實例（若是存在）。
int	size()返回此集合中的元素數。
Spliterator<E>	spliterator()在此隊列中的元素上建立late-binding和失敗快速 Spliterator 。
Object[]	toArray()返回一個包含此隊列中全部元素的數組。
<T> T[]	toArray(T[] a)返回一個包含此隊列中全部元素的數組; 返回的數組的運行時類型是指定數組的運行時類型。