Java集合大调研

一、集合框架的层次结构

1.1.接口介绍

1.1.1.Collection 接口

Collection 接口：是 List、Set和 Queue 接口的父接口，它定义了基本的集合操作，如添加、删除、遍历等。

List接口：有序集合（序列），元素可以重复。常见实现类有ArrayList、LinkedList、Vector（线程安全）。
Set 接口：不包含重复元素的集合。常见实现类有 HashSet、LinkedHashSet、TreeSet。
Queue接口：队列，通常用于存储元素。常见实现类有LinkedList、PriorityQueue。

1.1.2.Map 接口

Map 接口：不继承自Collection，它用于存储键值对（key-value）。键不能重复，每个键最多映射到一个值。常见实现类有HashMap、LinkedHashMap、TreeMap、Hashtable（线程安全）。

1.2.主要实现类

1.2.1.List 接口的实现类

ArrayList：基于动态数组实现，支持随机访问，非线程安全。在需要频繁读取元素时性能较好。
LinkedList：基于双向链表实现，适合频繁的插入和删除操作，同时实现了Deque接口，可以用作队列或双端队列。
Vector：和 ArrayList 类似，但是线程安全的。它的方法大多是同步的。现在较少使用，因为即使需要线程安全，也有其他更好的选择（如使用 Collections.synchronizedList 或 CopyOnWriteArrayList）。

1.2.2.Set 接口的实现类

HashSet：基于哈希表实现，不保证元素的顺序，允许使用 null元素。
LinkedHashSet：具有可预测的迭代顺序，即插入顺序。它通过维护一个运行于所有条目的双向链表来实现。
TreeSet：基于红黑树实现，元素可以按照自然顺序或者自定义的比较器进行排序。

1.2.3.Queue 接口的实现类

LinkedList：实现了Queue接口，可以作为队列使用。
PriorityQueue：基于优先级堆（通常是最小堆）实现，元素按照自然顺序或者比较器顺序出队。

1.2.4.Map接口的实现类

HashMap：基于哈希表实现，允许null键和null值，非线程安全。
LinkedHashMap：保留插入顺序或访问顺序（最近访问的元素可以放在最后，通过构造函数设置）。
TreeMap：基于红黑树实现，键按照自然顺序或比较器顺序排序。
Hashtable ：线程安全的，类似于HashMap，但不允许null键和null值。现在较少使用，因为即使需要线程安全，也有ConcurrentHashMap等更好的选择。

二、代码实现

2.1.Collection接口体系

2.1.1.List 接口（有序、可重复）

复制代码

// ArrayList - 基于动态数组
List<String> arrayList = new ArrayList<>();
arrayList.add("A");
arrayList.add("B");

// LinkedList - 基于双向链表
List<String> linkedList = new LinkedList<>();
linkedList.add("A");
linkedList.addFirst("B"); // 在头部添加

// Vector - 线程安全的动态数组（已过时，不推荐使用）
List<String> vector = new Vector<>();

// Stack - 后进先出（LIFO）
Stack<String> stack = new Stack<>();
stack.push("A");
stack.pop();

2.1.2.Set 接口（无序、不可重复）

复制代码

// HashSet - 基于哈希表，无序
Set<String> hashSet = new HashSet<>();
hashSet.add("A");
hashSet.add("B");

// LinkedHashSet - 保持插入顺序
Set<String> linkedHashSet = new LinkedHashSet<>();
linkedHashSet.add("A");
linkedHashSet.add("B");

// TreeSet - 基于红黑树，有序
Set<String> treeSet = new TreeSet<>();
treeSet.add("C");
treeSet.add("A"); // 自动排序：A, C

2.1.3.Queue 接口（队列）

复制代码

// LinkedList也实现了Queue接口
Queue<String> queue = new LinkedList<>();
queue.offer("A"); // 添加元素
queue.poll();     // 移除并返回头部元素

// PriorityQueue - 优先级队列
Queue<Integer> priorityQueue = new PriorityQueue<>();
priorityQueue.offer(5);
priorityQueue.offer(1); // 按自然顺序排序

// ArrayDeque - 双端队列
Deque<String> deque = new ArrayDeque<>();
deque.addFirst("A");
deque.addLast("B");

2.2.Map 接口体系

复制代码

// HashMap - 基于哈希表，键值对
Map<String, Integer> hashMap = new HashMap<>();
hashMap.put("Apple", 1);
hashMap.put("Banana", 2);

// LinkedHashMap - 保持插入顺序
Map<String, Integer> linkedHashMap = new LinkedHashMap<>();
linkedHashMap.put("Apple", 1);
linkedHashMap.put("Banana", 2);

// TreeMap - 基于红黑树，按键排序
Map<String, Integer> treeMap = new TreeMap<>();
treeMap.put("Banana", 2);
treeMap.put("Apple", 1); // 按键排序：Apple, Banana

// Hashtable - 线程安全（已过时）
Map<String, Integer> hashtable = new Hashtable<>();

// ConcurrentHashMap - 线程安全的HashMap
ConcurrentHashMap<String, Integer> concurrentMap = new ConcurrentHashMap<>();

三、集合比较

3.1.性能比较

|------------|----------|----------|----------|------|------|
| 集合类型 | 获取 | 插入 | 删除 | 顺序 | 线程安全 |
| ArrayList | O(1) | O(n) | O(n) | 插入顺序 | 否 |
| LinkedList | O(n) | O(1) | O(1) | 插入顺序 | 否 |
| HashSet | O(1) | O(1) | O(1) | 无 | 否 |
| TreeSet | O(log n) | O(log n) | O(log n) | 排序 | 否 |
| HashMap | O(1) | O(1) | O(1) | 无 | 否 |
| TreeMap | O(log n) | O(log n) | O(log n) | 按键排序 | 否 |

3.2.选择指南

需要快速 随机访问：ArrayList
频繁插入删除：LinkedList
去重且不关心顺序：HashSet
去重且插入保持顺序：LinkedHashSet
去重且需要排序：TreeSet
键值对存储：HashMap
键值对且插入保持顺序：LinkedHashMap
键值对且按键排序：TreeMap
多线程环境：ConcurrentHashMap、CopyOnWriteArrayList
需要队列功能：LinkedList、ArrayDeque、PriorityQueue