Java集合框架整体分类（完整的集合框架关系）

Java集合框架整体分类

- 完整的集合框架关系
- - [1. Collection接口（单列集合）](#1. Collection接口（单列集合）)
  - [2. Map接口（双列集合）](#2. Map接口（双列集合）)
- 栈和队列在集合框架中的位置
- 使用建议

完整的集合框架关系

text 复制代码

Collection接口
├── List接口（有序可重复）
│   ├── ArrayList
│   ├── LinkedList  
│   └── Vector
│
├── Set接口（无序不可重复）
│   ├── HashSet
│   ├── LinkedHashSet
│   └── TreeSet
│
└── Queue接口（队列）
    ├── LinkedList
    ├── PriorityQueue
    └── Deque接口（双端队列）
        ├── ArrayDeque
        └── LinkedList

Map接口（键值对）
├── HashMap
├── LinkedHashMap
├── TreeMap
└── Hashtable

1. Collection接口（单列集合）

存储单个对象的集合，分为三大类：

List（有序、可重复）

java 复制代码

// ArrayList - 基于数组，查询快，增删慢
List<String> arrayList = new ArrayList<>();
arrayList.add("Java");
arrayList.add("Python");
arrayList.add("Java"); // 可重复

// LinkedList - 基于链表，增删快，查询慢
List<Integer> linkedList = new LinkedList<>();
linkedList.add(1);
linkedList.add(2);

// Vector - 线程安全，已过时
List<String> vector = new Vector<>();

Set（无序、不可重复）

java 复制代码

// HashSet - 基于哈希表，无序
Set<String> hashSet = new HashSet<>();
hashSet.add("Apple");
hashSet.add("Banana");
hashSet.add("Apple"); // 不会重复添加

// LinkedHashSet - 保持插入顺序
Set<Integer> linkedHashSet = new LinkedHashSet<>();
linkedHashSet.add(3);
linkedHashSet.add(1);
linkedHashSet.add(2); // 输出顺序：3,1,2

// TreeSet - 自然排序或定制排序
Set<String> treeSet = new TreeSet<>();
treeSet.add("Orange");
treeSet.add("Apple");
treeSet.add("Banana"); // 输出顺序：Apple, Banana, Orange

Queue（队列）

java 复制代码

// LinkedList 实现队列
Queue<String> queue = new LinkedList<>();
queue.offer("A");
queue.offer("B");
queue.poll(); // A

// PriorityQueue - 优先级队列
Queue<Integer> priorityQueue = new PriorityQueue<>();
priorityQueue.offer(5);
priorityQueue.offer(1); // 1会先出队

// ArrayDeque - 双端队列，也可用作栈
Queue<String> arrayDeque = new ArrayDeque<>();

2. Map接口（双列集合）

存储键值对的集合

java 复制代码

// HashMap - 基于哈希表，无序
Map<String, Integer> hashMap = new HashMap<>();
hashMap.put("Alice", 25);
hashMap.put("Bob", 30);

// LinkedHashMap - 保持插入顺序
Map<String, String> linkedHashMap = new LinkedHashMap<>();
linkedHashMap.put("key1", "value1");
linkedHashMap.put("key2", "value2");

// TreeMap - 按键排序
Map<String, Integer> treeMap = new TreeMap<>();
treeMap.put("Orange", 5);
treeMap.put("Apple", 3); // 按键字母顺序排序

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

栈和队列在集合框架中的位置

栈（Stack）的实现

java 复制代码

// 方式1：使用Stack类（继承自Vector，不推荐）
Stack<Integer> stack1 = new Stack<>();
stack1.push(1);
stack1.pop();

// 方式2：使用Deque接口的实现类（推荐）
Deque<Integer> stack2 = new ArrayDeque<>();  // 或 LinkedList
stack2.push(1);
stack2.push(2);
stack2.pop(); // 2

队列（Queue）的实现

java 复制代码

// LinkedList实现
Queue<String> queue1 = new LinkedList<>();
queue1.offer("A");
queue1.poll();

// ArrayDeque实现  
Queue<Integer> queue2 = new ArrayDeque<>();
queue2.offer(1);
queue2.poll();

双端队列（Deque）的实现

java 复制代码

Deque<String> deque = new ArrayDeque<>();
// 作为栈使用
deque.push("A");
deque.pop();

// 作为队列使用
deque.offer("B");
deque.poll();

// 双端操作
deque.offerFirst("C");
deque.offerLast("D");

使用建议

需要频繁查询 ：使用ArrayList或HashMap
需要频繁增删 ：使用LinkedList
需要去重 ：使用HashSet
需要排序 ：使用TreeSet或TreeMap
需要队列功能 ：使用LinkedList或ArrayDeque
需要栈功能 ：使用ArrayDeque（推荐）或Stack
需要线程安全 ：使用ConcurrentHashMap、CopyOnWriteArrayList等并发集合