4 java集合类总结

1 接口图谱

Collection
List必须保持元素特定的顺序
Set不能有重复元素
Queue保持队列（先进先出）的顺序
Map
一组成对的“键值对”对象
所有容器类都实现Iterable接口中的iterator()方法，才能使用增强的for循环。（迭代器模式）

2 List接口常用类
1）ArrayList
由可变数组实现，不是同步的（也就是不是线程安全的），快速失败的。
使用Collections.synchronizedList方法将该列表“包装”起来，保证同步访问：
List synchronizedList = Collections.synchronizedList(new ArrayList());
2）LinkedList
由链接列表实现，不是同步的，快速失败的。
使用Collections.synchronizedList方法返回LinkedList的同步（线程安全）列表：
List synchronizedList2 = Collections.synchronizedList(new LinkedList());
3）Vector
由可变数组实现。
Vector类可以实现可增长的对象数组。同步的，快速失败的。

Vector<String> vector = new Vector<>();vector.addElement("Hello");vector.addElement("Vector!");System.out.println(vector.get(0) + " " + vector.get(1));

4）Stack

Stack类表示后进先出的对象堆栈。继承自Vector，同步的，快速失败。

Stack<String> stack = new Stack<>();stack.push("Hello");stack.push("Stack!");String pop = stack.pop();System.out.println(pop); //输出Stack!

5）CopyOnWriteArrayList
在java.util.concurrent包下
ArrayList的一个线程安全的变体，其中所有可变操作（add、set等等）都是通过对底层数组进行一次新的复制来实现的。安全失败。
并发容器，写实复制容器。通俗的理解是当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行Copy，复制出一个新的容器，然后新的容器里添加元素，添加完元素之后，再将原容器的引用指向新的容器。并发读时，不需要加锁。读写分离。
用于读多写少的并发场景。
缺点：
内存占用问题：
数据一致性问题：不能保证数据的实时一致性。

3 Deque接口常用类
一个线性collection,支持在两端插入和移除元素。名称deque是“double ended queue(双端队列)”的缩写，读“deck”。
此接口定义在双端队列两端访问元素的方法。

此接口扩展了Queue接口。

双端队列也可用作LIFO堆栈

1）LinkedList
2）ArrayDeque
由可变数组实现。不是线程安全的，快速失败的。
3）LinkedBlockingDeque
由双向链表实现。
在java.util.concurrent包下。
一个基于已链接节点的、任选范围的阻塞双端队列。

4 Queue接口常用类
1）LinkedList
2）ArrayDeque
3）LinkedBlockingDeque
*阻塞队列
阻塞队列（BlockingQueue）是一个支持两个附加操作的队列。这两个附加的操作是：在队列为空时，获取元素的线程会等待队列变为非空。当队列满时，存储元素的线程会等待队列可用。阻塞队列常用于生产者和消费者的场景，生产者是往队列里添加元素的线程，消费者是从队列里拿元素的线程。阻塞队列就是生产者存放元素的容器，而消费者也只从容器里拿元素。
4）LinkedBlockingQueue
这里写链接内容
在java.util.concurrent包下。
一个基于已链接节点的（单向链表），范围任意（有界）的blocking queue。此队列按先进先出排序元素。
5）ArrayBlockingQueue
这里写链接内容
在java.util.concurrent包下。
一个由数组支持的有界的线程安全的阻塞队列。
有界指ArrayBlockingQueue对应的数组是有界限的。
阻塞队列是指多线程访问竞争资源时，当竞争资源已被某线程获取时，其他要获取该资源的线程需要阻塞等待。
6）ConcurrentLinkedQueue
这里写链接内容
在java.util.concurrent包下。
一个基于链接节点的无界线程安全队列，适用于高并发的场景。
7）PriorityQueue
一个基于优先级堆的无界优先级队列。优先级队列的元素按照其自然顺序进行排序，或者根据构造队列时提供的Comparator进行排序。
此实现不是同步的。
8）PriorityBlockingQueue
在java.util.concurrent包下。
一个无界阻塞队列，它使用与类PriorityQueue相同的顺序规则，并且提供了阻塞获取操作。
9）DelayQueue
在java.util.concurrent包下。
一个无界阻塞队列，只有在延迟期满时才能从中提取元素。
10）SynchronousQueue
在java.util.concurrent包下。
一种阻塞队列，其中每个插入操作必须等待另一个线程的对应删除操作。

5 Map接口常用类
1）HashMap
基于哈希表的实现。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。
不是同步的，快速失败的。
使用Collections.synchronizedMap方法返回同步的HashMap:
Map synchronizedMap = Collections.synchronizedMap(new HashMap());
2）LinkedHashMap
由哈希表和链接列表实现，具有可预支的迭代顺序。按添加的顺序排列。
不是同步的，快速失败的。
使用Collections.synchronizedMap方法返回同步的LinkedHashMap:

Map<String, String> linkedHashMap = Collections.synchronizedMap(new LinkedHashMap<String,String>());linkedHashMap.put("s0", "s0");linkedHashMap.put("a0", "a0");linkedHashMap.put("z1", "z1");linkedHashMap.put("s1", "s1");linkedHashMap.put("e1", "e1");linkedHashMap.put("f1", "f1");linkedHashMap.put("d1", "d1");for(String key : linkedHashMap.keySet()) {    System.out.print(linkedHashMap.get(key) + " ");}//一直输出s0 a0 z1 s1 e1 f1 d1 ，顺序不变

3）TreeMap
基于红黑树的NavigableMap实现。该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的Comparator进行排序，具体取决于使用的构造方法。
此实现不是同步的，快速失败的。
使用Collections.synchronizedSortedMap方法返回同步的TreeMap。

Map<String, String> treeMap = Collections.synchronizedMap(new TreeMap<String,String>());treeMap.put("s0", "s0");treeMap.put("a0", "a0");treeMap.put("z1", "z1");treeMap.put("s1", "s1");treeMap.put("e1", "e1");treeMap.put("f1", "f1");treeMap.put("d1", "d1");for(String key : treeMap.keySet()) {    System.out.print(treeMap.get(key) + " ");}

4）EnumMap
与枚举类型键一起使用的专用Map实现。
不是同步的，安全失败的。
使用Collections.synchronizedMap方法返回同步的EnumMap。

Map<EnumTest, String> m = Collections.synchronizedMap(new EnumMap<EnumTest, String>(EnumTest.class));m.put(EnumTest.TEST2, "Test2");m.put(EnumTest.TEST1, "Test1");m.put(EnumTest.TEST3, "Test3");for(EnumTest key : m.keySet()) {    System.out.print(m.get(key) + " ");}//输出Test1 Test2 Test3 

5）ConcurrentSkipListMap
在java.util.concurrent包下。
可缩放的并发ConcurrentNavigableMap实现。映射可以根据键的自然顺序进行排序，也可以根据创建映射时所提供的Comparator进行排序，具体取决于使用的构造方法。

6）ConcurrentHashMap
在java.util.concurrent包下。
支持获取的完全并发和更新的所期待可调整并发的哈希表。此类遵守与Hashtable相同的功能规范。

7）WeakHashMap
以弱键实现的基于哈希表的Map。在WeakHashMap中，当某个键不再正常使用时，将自动移除其条目。
不是同步的，快速失败的。
可以使用Collections.synchronizedMap方法来构造同步的WeakHashMap。

Map<String, Integer> synchronizedMap = Collections.synchronizedMap(new WeakHashMap<>());

8）HashTable
此类是实现一个哈希表，该哈希表将键映射到相应的值。
同步的，快速失败的。

6 Set接口常用类
1）HashSet
由哈希表（HashMap）实现。不保证set的迭代顺序。
不是同步的，快速失败的。
使用Collections.synchronizedSet方法来包装，返回一个同步的HashSet.
Set synchronizedSet = Collections.synchronizedSet(new HashSet<>());

2）LinkedHashSet
具有可预知迭代顺序的Set接口的哈希表和链接列表实现。按照元素插入到set中的顺序进行迭代。
不是同步的，快速失败的。
使用Collections.synchronizedSet方法包装，返回同步的LinkedHashSet。
Set synchronizedSet2 = Collections.synchronizedSet(new LinkedHashSet<>());

3）TreeSet
基于TreeMap的NavigableSet实现。使用元素的自然顺序对元素进行排序，或者根据创建set时提供的Comparator进行排序，具体取决于使用的构造方法。
不是同步的，快速失败的。
使用Collections.synchronizedSet方法包装，返回同步的TreeSet。
Set synchronizedSet3 = Collections.synchronizedSet(new TreeSet<>());

4）EnumSet
与枚举类型一起使用的专用Set实现。
不是同步的，安全失败的。
使用Collections.synchronizedSet方法包装，返回同步的EnumSet。

Set<MyEnum> synchronizedSet4 = Collections.synchronizedSet(EnumSet.noneOf(MyEnum.class));synchronizedSet4.add(MyEnum.TEST1);System.out.println(synchronizedSet4);//输出[TEST1]

5）ConcurrentSkipListSet
在java.util.concurrent包下。
一个基于ConcurrentSkipListMap的可缩放并发NavigableSet实现。set的元素可以根据它们的自然顺序进行排序，也可以根据创建set时所提供的Comparator进行排序。

6）CopyOnWriteArraySet
在java.util.concurrent包下。
对其所有操作使用内部CopyOnWriteArrayList的Set。
线程安全的，安全失败的。