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是否线程安全	非线程安全

1、LinkedHashMap可以认为是HashMap+LinkedList，即它既使用HashMap操作数据结构，又使用LinkedList维护插入元素的先后顺序。

2、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)返回一个包含此队列中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。