Java 容器类详解：架构、实现与使用实践

（2）LinkedList

• 底层数据结构：双向链表（每个节点包含元素、前驱指针、后继指针）。
• 特点：
  • 增删快（只需修改指针，时间复杂度 O(1)）；
  • 查询慢（需遍历链表，时间复杂度 O(n)）；
  • 非线程安全；
  • 同时实现了 Deque 接口，可作为双端队列使用。
• 适用场景：以增删为主，或需要队列 / 栈功能的场景。

import java.util.LinkedList;

public class LinkedListDemo {
    public static void main(String[] args) {
        LinkedList<String> linkedList = new LinkedList<>();
        // 1. 作为 List 使用（增删改查同 ArrayList）
        linkedList.add("A");
        linkedList.add("B");
        // 2. 作为 队列（FIFO）使用
        linkedList.offer("C"); // 入队
        System.out.println("队首元素：" + linkedList.peek()); // 查看队首（不删除）
        System.out.println("出队：" + linkedList.poll()); // 出队（删除队首）
        // 3. 作为 栈（LIFO）使用
        linkedList.push("D"); // 入栈
        System.out.println("栈顶元素：" + linkedList.peek()); // 查看栈顶
        System.out.println("出栈：" + linkedList.pop()); // 出栈（删除栈顶）
        System.out.println("最终链表：" + linkedList);
    }
}

（3）Vector

• 底层数据结构：动态数组（与 ArrayList 类似）。
• 特点：
  • 线程安全（所有方法都加了 synchronized 修饰）；
  • 效率低（同步开销大），已被 CopyOnWriteArrayList 替代。
• 适用场景：已不推荐使用，仅在遗留代码中可见。

Set 接口：无序、不可重复

Set 强调元素的'唯一性'，不允许存储重复元素（通过 equals() 和 hashCode() 方法判断）。常用实现类有三个：

（1）HashSet

• 底层数据结构：哈希表（基于 HashMap 实现，元素作为 HashMap 的 key）。
• 特点：
  • 无序（不保证元素的存储顺序）；
  • 查询、增删效率高（时间复杂度 O(1)）；
  • 非线程安全。
• 适用场景：需要快速去重，且不关心顺序的场景。

import java.util.HashSet;
import java.util.Set;

public class HashSetDemo {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        // 1. 增：添加元素（重复元素会被自动去重）
        set.add("Apple");
        set.add("Banana");
        set.add("Apple"); // 重复，添加失败
        // 2. 删：删除元素
        set.remove("Banana");
        // 3. 查：判断是否包含
        System.out.println("是否包含 Apple：" + set.contains("Apple"));
        // 4. 遍历（增强 for 或迭代器，无索引，不能用普通 for）
        System.out.println("Set 元素：");
        for (String s : set) {
            System.out.println(s);
        }
    }
}

（2）LinkedHashSet

• 底层数据结构：哈希表 + 双向链表（继承自 HashSet，内部使用 LinkedHashMap 实现）。
• 特点：
  • 有序（维护元素的插入顺序）；
  • 性能略低于 HashSet（需维护链表）；
  • 非线程安全。
• 适用场景：需要去重且保持插入顺序的场景。

（3）TreeSet

• 底层数据结构：红黑树（基于 TreeMap 实现）。
• 特点：
  • 可排序（支持自然排序或定制排序，通过 Comparable 或 Comparator 接口实现）；
  • 查询、增删效率较高（时间复杂度 O(log n)）；
  • 非线程安全。
• 适用场景：需要对元素进行排序的场景。

import java.util.TreeSet;

public class TreeSetDemo {
    public static void main(String[] args) {
        // 1. 自然排序（元素需实现 Comparable 接口，如 String、Integer）
        TreeSet<Integer> treeSet1 = new TreeSet<>();
        treeSet1.add(5);
        treeSet1.add(2);
        treeSet1.add(8);
        System.out.println("自然排序（升序）：" + treeSet1); // 输出 [2, 5, 8]
        // 2. 定制排序（通过 Comparator 接口指定排序规则）
        TreeSet<String> treeSet2 = new TreeSet<>((o1, o2) -> o2.compareTo(o1)); // 降序
        treeSet2.add("Banana");
        treeSet2.add("Apple");
        treeSet2.add("Cherry");
        System.out.println("定制排序（降序）：" + treeSet2); // 输出 [Cherry, Banana, Apple]
    }
}

Queue 接口：队列（先进先出）

Queue 用于模拟'队列'数据结构，遵循'先进先出'（FIFO）原则。常用实现类有三个：

（1）LinkedList

• 如前所述，LinkedList 实现了 Deque 接口，可作为双端队列使用（支持从两端插入 / 删除元素）。

（2）ArrayDeque

• 底层数据结构：动态数组（循环数组）。
• 特点：
  • 双端队列（可从两端操作元素）；
  • 性能优于 LinkedList（无链表节点开销）；
  • 非线程安全。
• 适用场景：需要双端队列功能的场景（如栈、队列）。

import java.util.ArrayDeque;

public class ArrayDequeDemo {
    public static void main(String[] args) {
        ArrayDeque<String> deque = new ArrayDeque<>();
        // 1. 双端队列：两端都可增删
        deque.addFirst("A"); // 队首添加
        deque.addLast("B"); // 队尾添加
        deque.offerFirst("C"); // 队首添加（返回 boolean）
        deque.offerLast("D"); // 队尾添加（返回 boolean）
        System.out.println("双端队列：" + deque); // 输出 [C, A, B, D]
        // 2. 查看元素
        System.out.println("队首：" + deque.getFirst()); // 队首（抛异常）
        System.out.println("队尾：" + deque.peekLast()); // 队尾（返回 null）
        // 3. 删除元素
        deque.removeFirst(); // 删除队首（抛异常）
        deque.pollLast(); // 删除队尾（返回 null）
        System.out.println("删除后：" + deque); // 输出 [A, B]
    }
}

（3）PriorityQueue

• 底层数据结构：二叉堆（默认小顶堆，可通过 Comparator 定制）。
• 特点：
  • 元素按优先级排序（而非插入顺序）；
  • 非线程安全。
• 适用场景：需要按优先级处理元素的场景（如任务调度）。

import java.util.PriorityQueue;

public class PriorityQueueDemo {
    public static void main(String[] args) {
        // 1. 默认小顶堆（元素自然排序，最小的在队首）
        PriorityQueue<Integer> pq1 = new PriorityQueue<>();
        pq1.offer(5);
        pq1.offer(2);
        pq1.offer(8);
        System.out.println("小顶堆出队：");
        while (!pq1.isEmpty()) {
            System.out.println(pq1.poll()); // 输出 2, 5, 8
        }
        // 2. 定制大顶堆（通过 Comparator 指定）
        PriorityQueue<Integer> pq2 = new PriorityQueue<>((o1, o2) -> o2 - o1);
        pq2.offer(5);
        pq2.offer(2);
        pq2.offer(8);
        System.out.println("\n大顶堆出队：");
        while (!pq2.isEmpty()) {
            System.out.println(pq2.poll()); // 输出 8, 5, 2
        }
    }
}

Map 接口：键值对存储

Map 用于存储'键值对'（key-value），其中 key 不可重复，value 可重复。常用实现类有四个：

（1）HashMap

• 底层数据结构：哈希表（JDK 1.8 前：数组 + 链表；JDK 1.8 后：数组 + 链表 + 红黑树，当链表长度≥8 且数组长度≥64 时，链表转为红黑树）。
• 特点：
  • 无序（不保证键值对的存储顺序）；
  • 查询、增删效率高（时间复杂度 O(1)）；
  • 非线程安全；
  • 允许 key 和 value 为 null（key 只能有一个 null）。
• 适用场景：以键值对存储为主，且不关心顺序的场景（最常用）。

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class HashMapDemo {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        // 1. 增：添加键值对（Key 重复会覆盖旧 Value）
        map.put("Java", 100);
        map.put("Python", 90);
        map.put("Java", 95); // Key 重复，覆盖 Value 为 95
        // 2. 删：删除键值对
        map.remove("Python");
        // 3. 改：修改 Value（同 put，Key 存在则覆盖）
        map.put("Java", 98);
        // 4. 查：获取 Value
        System.out.println("Java 的分数：" + map.get("Java"));
        System.out.println("是否包含 Key：" + map.containsKey("Java"));
        System.out.println("是否包含 Value：" + map.containsValue(98));
        // 5. 遍历（三种方式）
        System.out.println("\n--- 方式 1：遍历 KeySet（获取所有 Key） ---");
        Set<String> keys = map.keySet();
        for (String key : keys) {
            System.out.println(key + " -> " + map.get(key));
        }
        System.out.println("\n--- 方式 2：遍历 EntrySet（推荐，同时获取 Key 和 Value） ---");
        Set<Map.Entry<String, Integer>> entries = map.entrySet();
        for (Map.Entry<String, Integer> entry : entries) {
            System.out.println(entry.getKey() + " -> " + entry.getValue());
        }
        System.out.println("\n--- 方式 3：遍历 Values（仅获取所有 Value） ---");
        for (Integer value : map.values()) {
            System.out.println(value);
        }
    }
}

（2）LinkedHashMap

• 底层数据结构：哈希表 + 双向链表（继承自 HashMap，内部维护双向链表记录插入顺序）。
• 特点：
  • 有序（维护键值对的插入顺序或访问顺序）；
  • 性能略低于 HashMap（需维护链表）；
  • 非线程安全。
• 适用场景：需要键值对保持插入顺序的场景（如缓存）。

（3）TreeMap

• 底层数据结构：红黑树。
• 特点：
  • 可排序（对 key 进行自然排序或定制排序）；
  • 查询、增删效率较高（时间复杂度 O(log n)）；
  • 非线程安全；
  • key 不能为 null。
• 适用场景：需要对 key 进行排序的场景。

import java.util.TreeMap;

public class TreeMapDemo {
    public static void main(String[] args) {
        // 1. 自然排序（Key 需实现 Comparable 接口）
        TreeMap<Integer, String> treeMap1 = new TreeMap<>();
        treeMap1.put(3, "C");
        treeMap1.put(1, "A");
        treeMap1.put(2, "B");
        System.out.println("自然排序（Key 升序）：" + treeMap1); // 输出 {1=A, 2=B, 3=C}
        // 2. 定制排序（通过 Comparator 指定 Key 排序规则）
        TreeMap<Integer, String> treeMap2 = new TreeMap<>((o1, o2) -> o2 - o1); // Key 降序
        treeMap2.put(3, "C");
        treeMap2.put(1, "A");
        treeMap2.put(2, "B");
        System.out.println("定制排序（Key 降序）：" + treeMap2); // 输出 {3=C, 2=B, 1=A}
    }
}

（4）Hashtable

• 底层数据结构：哈希表（与 HashMap 类似）。
• 特点：
  • 线程安全（所有方法加 synchronized 修饰）；
  • 效率低（同步开销大），已被 ConcurrentHashMap 替代；
  • key 和 value 都不能为 null。
• 适用场景：已不推荐使用，仅在遗留代码中可见。

容器类的核心注意事项

1. 基本类型与包装类

容器类只能存储对象，不能直接存储基本类型（如 int、char）。Java 会通过'自动装箱'将基本类型转换为对应的包装类（如 Integer、Character），反之通过'自动拆箱'转换回基本类型。

2. 线程安全问题

大部分常用容器类（如 ArrayList、HashMap、HashSet）都是非线程安全的，在多线程环境下可能出现并发修改异常（ConcurrentModificationException）。若需要线程安全，可选择：

• 使用 Collections 工具类的同步方法（如 Collections.synchronizedList(new ArrayList<>())）；
• 使用 java.util.concurrent 包下的并发容器（如 ConcurrentHashMap、CopyOnWriteArrayList）。

3. 迭代器与 fail-fast 机制

容器类的迭代器（Iterator）采用'fail-fast'机制：当迭代过程中容器结构被修改（如增删元素），会立即抛出 ConcurrentModificationException。若需在迭代时修改元素，应使用迭代器的 remove() 方法，而非容器自身的 remove() 方法。