Java 提供了功能强大的集合框架（Collection Framework），它极大地方便了数据的存储、操作和管理。在日常开发和面试中，集合类是高频考点。本文将系统介绍 Java 常见的集合类及其特点。
一、Java 集合框架体系结构
Java 集合大致可以分为两大类：
Collection 接口：存储单个元素的集合，常见子接口有
List：有序，可重复
Set：无序，不可重复
Queue：队列，支持先进先出或优先级排序
Map 接口：存储键值对（key-value），key 不允许重复，value 可重复
集合框架图解
Collection ├── List │ ├── ArrayList │ ├── LinkedList │ └── Vector / Stack │ ├── Set │ ├── HashSet │ ├── LinkedHashSet │ └── TreeSet │ └── Queue ├── PriorityQueue └── ArrayDeque Map ├── HashMap ├── LinkedHashMap ├── TreeMap └── ConcurrentHashMap
二、常见的 List 实现类
1. ArrayList
底层结构：动态数组
特点：
有序，可重复
支持随机访问（get、set O(1)）
插入、删除效率低（需要移动元素）
应用场景：查询多、增删少的场景
例子：
List<String> list = new ArrayList<>(); list.add("Java"); list.add("Python"); System.out.println(list.get(0));
2. LinkedList
底层结构：双向链表
特点：
有序，可重复
插入、删除效率高（只需修改指针）
随机访问效率低（O(n)）
应用场景：增删多，查询少的场景
例子：
List<Integer> linkedList = new LinkedList<>(); linkedList.add(1); linkedList.add(2); linkedList.remove(0);
3. Vector / Stack
Vector：线程安全版的 ArrayList（通过 synchronized 实现），但性能较差，已较少使用
Stack：继承自 Vector，后进先出（LIFO）
Stack<Integer> stack = new Stack<>(); stack.push(1); stack.push(2); System.out.println(stack.pop()); // 2
三、常见的 Set 实现类
1. HashSet
底层结构：基于 HashMap 实现
特点：
无序，不重复
元素存放顺序与 hash 值相关
应用场景：去重、快速查找
例子：
Set<String> set = new HashSet<>(); set.add("Java"); set.add("Python"); set.add("Java"); // 不会重复
2. LinkedHashSet
底层结构：HashSet + 双向链表
特点：
保证元素插入顺序
适合需要去重又保留顺序的场景
3. TreeSet
底层结构：红黑树
特点：
元素有序（自然顺序或自定义 Comparator）
查询性能 O(log n)
应用场景：需要排序的集合
例子：
Set<Integer> treeSet = new TreeSet<>(); treeSet.add(3); treeSet.add(1); treeSet.add(2); System.out.println(treeSet); // [1, 2, 3]
四、常见的 Queue / Deque 实现类
1. PriorityQueue
底层结构：小顶堆（默认）
特点：
元素出队时按优先级排序
默认自然排序，可以自定义 Comparator
应用场景：任务调度、优先级队列
例子：
PriorityQueue<Integer> pq = new PriorityQueue<>(); pq.offer(5); pq.offer(1); pq.offer(3); System.out.println(pq.poll()); // 1
2. ArrayDeque
底层结构：可变长数组实现的双端队列
特点：
可作为队列（FIFO）或栈（LIFO）
比 Stack、LinkedList 更高效
例子：
Deque<String> deque = new ArrayDeque<>(); deque.addFirst("A"); deque.addLast("B"); System.out.println(deque.pollFirst()); // A
五、常见的 Map 实现类
1. HashMap
底层结构：数组 + 链表 + 红黑树（JDK1.8 之后）
特点：
key 无序，不重复，允许一个 null key
value 可重复，允许多个 null value
应用场景：最常用的键值对存储
2. LinkedHashMap
底层结构：HashMap + 双向链表
特点：
保证插入顺序或访问顺序
常用于实现 LRU 缓存
例子（LRU 实现）：
LinkedHashMap<Integer, String> lru = new LinkedHashMap<>(16, 0.75f, true); lru.put(1, "A"); lru.put(2, "B"); lru.get(1); // 访问 1
3. TreeMap
底层结构：红黑树
特点：
key 有序（自然顺序或自定义 Comparator）
查询、插入、删除时间复杂度 O(log n)
应用场景：需要排序的 Map
4. ConcurrentHashMap
底层结构：
JDK1.7：Segment + HashEntry（分段锁）
JDK1.8：Node 数组 + CAS + synchronized
特点：
线程安全，高性能
key、value 都不允许为 null
应用场景：并发环境下的缓存、计数器
六、集合类对比总结
| 类名 | 底层结构 | 是否有序 | 是否允许重复 | 是否线程安全 | 适用场景 |
|---|---|---|---|---|---|
| ArrayList | 动态数组 | 有序 | ✅ | ❌ | 查询多 |
| LinkedList | 双向链表 | 有序 | ✅ | ❌ | 插入/删除多 |
| HashSet | HashMap | 无序 | ❌ | ❌ | 去重 |
| LinkedHashSet | HashMap+链表 | 插入顺序 | ❌ | ❌ | 去重+保持顺序 |
| TreeSet | 红黑树 | 排序 | ❌ | ❌ | 有序集合 |
| HashMap | 数组+链表+红黑树 | 无序 | key ❌，value ✅ | ❌ | 常用 Map |
| LinkedHashMap | HashMap+链表 | 插入/访问顺序 | key ❌，value ✅ | ❌ | LRU 缓存 |
| TreeMap | 红黑树 | 排序 | key ❌，value ✅ | ❌ | 有序 Map |
| ConcurrentHashMap | Node 数组+CAS | 无序 | key ❌，value ✅ | ✅ | 并发场景 |
七、总结
List：有序可重复，常见的 ArrayList、LinkedList。
Set：无序不可重复，常见的 HashSet、TreeSet。
Queue：先进先出或优先级，常见的 PriorityQueue、ArrayDeque。
Map：键值对存储，常见的 HashMap、LinkedHashMap、TreeMap、ConcurrentHashMap。
掌握集合类不仅要会使用，还要理解其 底层原理与适用场景，这样在面试和开发中才能灵活应用。
一句话总结：集合类是 Java 的“数据结构工具箱”，选择合适的集合，能让代码既高效又简洁。