
---

### 核心概念总览

| 特性 | List（列表） | Set（集合） | Map（映射） |
| :--- | :--- | :--- | :--- |
| **核心接口** | `java.util.List` | `java.util.Set` | `java.util.Map` |
| **继承关系** | 继承自 `Collection` | 继承自 `Collection` | 独立接口，不继承 `Collection` |
| **元素顺序** | **有序**（插入顺序） | 通常**无序**（`LinkedHashSet`等除外） | 通常**无序**（`LinkedHashMap`等除外） |
| **元素唯一性** | **允许重复** | **不允许重复** | **Key 不允许重复**，Value 可以重复 |
| **元素访问** | 通过**索引**（index） | 只能通过**迭代器**或增强 for 循环 | 通过 **Key** 来访问 Value |
| **常见实现类** | `ArrayList`, `LinkedList`, `Vector` | `HashSet`, `LinkedHashSet`, `TreeSet` | `HashMap`, `LinkedHashMap`, `TreeMap`, `Hashtable` |
| **是否允许 null** | 是 | `HashSet` 允许一个 null，`TreeSet` 不允许 | `HashMap` 允许一个 null key，`Hashtable` 不允许 |

---

### 1. List（列表）

List 是一个**有序**的、**允许重复元素**的集合。用户可以精确控制列表中每个元素的插入位置，并且可以通过整数索引（类似于数组下标）来访问元素。

**核心特性：**
*   **有序（Ordered）**：元素按照插入的顺序存储。
*   **可重复（Allows Duplicates）**：可以添加多个相同的元素（包括多个 `null`）。
*   **索引访问（Indexed Access）**：提供了基于下标（从 0 开始）的 `get(int index)` 和 `set(int index, E element)` 方法。

**主要实现类：**

1.  **`ArrayList`**
    *   **底层结构**：基于**动态数组**。
    *   **特点**：
        *   **查询快**：因为实现了 `RandomAccess` 接口，通过索引随机访问元素的速度极快（时间复杂度 O(1)）。
        *   **增删慢**：在列表中间插入或删除元素时，需要移动后续所有元素，性能较差（平均时间复杂度 O(n)）。
    *   **使用场景**：**查询操作远多于增删操作**的场景。这是最常用的 List 实现。

2.  **`LinkedList`**
    *   **底层结构**：基于**双向链表**。
    *   **特点**：
        *   **增删快**：在链表头部或尾部（已知位置）插入/删除元素很快（时间复杂度 O(1)）。在中间位置需要先遍历找到位置。
        *   **查询慢**：按索引查询需要从头或尾开始遍历链表（平均时间复杂度 O(n)）。
        *   实现了 `Deque` 接口，可以被用作**栈**或**队列**。
    *   **使用场景**：需要频繁在列表**首尾进行增删操作**，或者频繁使用栈/队列结构的场景。

3.  **`Vector`（已过时，不推荐使用）**
    *   **底层结构**：基于动态数组，是线程安全的。
    *   **特点**：其所有方法都是 `synchronized` 的，保证了线程安全，但性能开销大。
    *   **替代品**：在需要线程安全时，可以使用 `Collections.synchronizedList(new ArrayList(...))` 或者 `CopyOnWriteArrayList`。

**代码示例：**
```java
List<String> arrayList = new ArrayList<>();
arrayList.add("Apple"); // 索引 0
arrayList.add("Banana"); // 索引 1
arrayList.add("Apple"); // 允许重复
arrayList.add(null); // 允许 null

System.out.println(arrayList); // 输出：[Apple, Banana, Apple, null]
System.out.println(arrayList.get(1)); // 输出：Banana

List<String> linkedList = new LinkedList<>();
linkedList.addFirst("First"); // 在头部添加
linkedList.addLast("Last"); // 在尾部添加
```

---

### 2. Set（集合）

Set 是一个**不允许重复元素**的集合。它模拟了数学上的“集合”概念。最多只能包含一个 `null` 元素。

**核心特性：**
*   **唯一性（Unique Elements）**：集合中不允许存在两个相等的元素。判断相等的依据是 `equals()` 和 `hashCode()` 方法。
*   **通常无序（Generally Unordered）**：大多数实现不保证元素的顺序（但 `LinkedHashSet` 和 `TreeSet` 例外）。

**主要实现类：**

1.  **`HashSet`**
    *   **底层结构**：基于 **HashMap**（本质上是只使用了 HashMap 的 Key）。
    *   **特点**：
        *   **无序**：不保证元素的迭代顺序。
        *   **性能最好**：添加、删除、查找（`contains`）操作的时间复杂度都是 **O(1)**。
    *   **使用场景**：最常用的 Set，用于需要快速查找且不关心顺序的场景。

2.  **`LinkedHashSet`**
    *   **底层结构**：继承自 `HashSet`，但内部使用 **链表** 维护了元素的**插入顺序**。
    *   **特点**：
        *   **有序**：迭代顺序就是元素的插入顺序。
        *   性能略低于 `HashSet`，因为需要维护链表。
    *   **使用场景**：既需要 Set 的**唯一性**，又希望保留元素的**插入顺序**。

3.  **`TreeSet`**
    *   **底层结构**：基于 **红黑树**（一种自平衡的二叉查找树）。
    *   **特点**：
        *   **有序**：元素按照**自然顺序**（如数字从小到大，字符串字典序）或者根据构造时提供的 **Comparator** 进行排序。
        *   添加、删除、查找操作的时间复杂度是 **O(log n)**。
        *   **不允许 `null` 元素**。
    *   **使用场景**：需要元素**自动排序**的场景。

**代码示例：**
```java
Set<String> hashSet = new HashSet<>();
hashSet.add("Apple");
hashSet.add("Banana");
hashSet.add("Apple"); // 这个重复元素不会被添加
hashSet.add(null);

System.out.println(hashSet); // 输出可能是：[null, Apple, Banana] (无序)

Set<String> linkedHashSet = new LinkedHashSet<>();
linkedHashSet.add("Banana");
linkedHashSet.add("Apple");
System.out.println(linkedHashSet); // 输出：[Banana, Apple] (保持插入顺序)

Set<Integer> treeSet = new TreeSet<>();
treeSet.add(3);
treeSet.add(1);
treeSet.add(2);
System.out.println(treeSet); // 输出：[1, 2, 3] (自然排序)
```

---

### 3. Map（映射）

Map 是一个用于存储 **键值对（Key-Value Pairs）** 的集合。每个 Key 映射到一个 Value。Key 不允许重复，但不同的 Key 可以映射到相同的 Value。

**核心特性：**
*   **键值对（Key-Value Pairs）**：数据以 `Key=Value` 的形式存储。
*   **Key 唯一（Unique Keys）**：一个 Map 中不能包含重复的 Key。判断 Key 是否重复的依据是 `equals()` 和 `hashCode()` 方法。
*   **每个 Key 对应一个 Value**：一个 Key 只能映射到一个 Value。

**主要实现类：**

1.  **`HashMap`**
    *   **底层结构**：基于 **数组+链表+红黑树**（JDK 8 以后）。
    *   **特点**：
        *   **无序**：不保证键值对的顺序。
        *   **性能最好**：get 和 put 操作的时间复杂度在理想情况下是 **O(1)**。
        *   **允许 `null` 作为 Key 和 Value**。
    *   **使用场景**：最常用的 Map，适用于绝大多数键值对存储场景。

2.  **`LinkedHashMap`**
    *   **底层结构**：继承自 `HashMap`，并使用**链表**维护了**插入顺序**或**访问顺序**。
    *   **特点**：
        *   **有序**：迭代顺序可以是**插入顺序**或**访问顺序**（最近最少使用的元素在前）。
        *   性能略低于 `HashMap`。
    *   **使用场景**：需要保留键值对的**插入顺序**，或者用它来实现 **LRU（最近最少使用）缓存**。

3.  **`TreeMap`**
    *   **底层结构**：基于 **红黑树**。
    *   **特点**：
        *   **有序**：Key 按照**自然顺序**或指定的 **Comparator** 进行排序。
        *   操作的时间复杂度为 **O(log n)**。
        *   **不允许 `null` Key**。
    *   **使用场景**：需要 Key **自动排序**的场景。

4.  **`Hashtable`（已过时，不推荐使用）**
    *   **底层结构**：类似 `HashMap`，是线程安全的。
    *   **特点**：所有方法都是 `synchronized` 的，性能差。
    *   **不允许 `null` 作为 Key 或 Value**。
    *   **替代品**：使用 `ConcurrentHashMap` 或 `Collections.synchronizedMap(new HashMap(...))`。

**代码示例：**
```java
Map<String, Integer> hashMap = new HashMap<>();
hashMap.put("Alice", 90);
hashMap.put("Bob", 85);
hashMap.put("Alice", 95); // 覆盖 Key "Alice" 原来的值
hashMap.put(null, 100); // 允许 null key

System.out.println(hashMap); // 输出可能是：{null=100, Bob=85, Alice=95}
System.out.println(hashMap.get("Bob")); // 输出：85

Map<String, Integer> linkedHashMap = new LinkedHashMap<>();
linkedHashMap.put("Bob", 85);
linkedHashMap.put("Alice", 95);
System.out.println(linkedHashMap); // 输出：{Bob=85, Alice=95} (插入顺序)

Map<String, Integer> treeMap = new TreeMap<>();
treeMap.put("Orange", 10);
treeMap.put("Apple", 20);
System.out.println(treeMap); // 输出：{Apple=20, Orange=10} (Key的字典序)
```

---

### 总结与选择

*   **需要允许重复且有顺序？** -> 选择 **`List`**
    *   查询多，增删少 -> **`ArrayList`**
    *   增删多，查询少，或需要栈/队列 -> **`LinkedList`**

*   **需要元素唯一，不关心顺序？** -> 选择 **`Set`**
    *   只关心唯一性，追求最高性能 -> **`HashSet`**
    *   需要保留插入顺序 -> **`LinkedHashSet`**
    *   需要元素自动排序 -> **`TreeSet`**

*   **需要通过键（Key）来查找值（Value）？** -> 选择 **`Map`**
    *   绝大多数场景，不关心顺序 -> **`HashMap`**
    *   需要保留键值对的插入顺序或实现LRU -> **`LinkedHashMap`**
    *   需要键自动排序 -> **`TreeMap`**
    *   高并发场景 -> **`ConcurrentHashMap`**

