Java容器

1. 介绍

Java的容器用于存储和管理对象的集合，主要包括Collection和Map接口。它们的类层次结构如下所示：

java.lang.Object
├── java.util.Collection
│   ├── java.util.List // 有序集合，允许重复
│   │   ├── java.util.ArrayList // 基于动态数组实现，适合随机访问
│   │   ├── java.util.LinkedList // 基于链表实现，适合频繁插入删除
│   │   ├── java.util.Vector // 同步线程安全的动态数组（废弃）
│   │   └── java.util.Stack // 继承自Vector，实现后进先出（LIFO）（废弃）
│   ├── java.util.Set // 无序集合，不允许重复
│   │   ├── java.util.HashSet // 基于哈希表实现，查询速度快
│   │   ├── java.util.LinkedHashSet // 基于哈希表和链表实现，保留插入顺序
│   │   └── java.util.TreeSet // 基于红黑树实现，元素有序
│   └── java.util.Queue // 用于特定顺序处理元素的场景
│       ├── java.util.PriorityQueue // 基于优先级队列实现，元素按优先级排序
│       └── java.util.Deque // 双端队列，支持在两端插入和删除元素
└── java.util.Map // 键值对映射关系，用于快速查找和更新
    ├── java.util.HashMap // 基于哈希表实现，允许一个null键和多个null值
    ├── java.util.LinkedHashMap // 保留插入顺序的HashMap
    ├── java.util.TreeMap // 基于红黑树实现，键有序
    ├── java.util.Hashtable // 线程安全的哈希表（废弃）
    └── java.util.concurrent.ConcurrentHashMap // 线程安全且高效的哈希表

2. 代码案例

package com.zhilitech.container;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;

public class JavaContainersExample {
    // 定义一个枚举类型，表示一周的天数
    enum Day {MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY}

    public static void main(String[] args) {
        // 创建和操作 List
        List<String> arrayList = new ArrayList<>(Arrays.asList("Apple", "Banana", "Cherry", "Date", "Cherry"));
        List<String> linkedList = new LinkedList<>(arrayList);

        // 输出 List
        System.out.println("ArrayList: " + arrayList);
        // 输出: ArrayList: [Apple, Banana, Cherry, Date, Cherry]
        System.out.println("LinkedList: " + linkedList);
        // 输出: LinkedList: [Apple, Banana, Cherry, Date, Cherry]

        // 在 ArrayList 中添加和删除元素
        arrayList.add("Elderberry"); // 添加元素
        arrayList.remove("Banana"); // 删除元素
        System.out.println("ArrayList after add and remove: " + arrayList);
        // 输出: ArrayList after add and remove: [Apple, Cherry, Date, Cherry, Elderberry]

        // 使用 Collections.sort 方法对 List 进行排序
        Collections.sort(arrayList);
        System.out.println("Sorted ArrayList: " + arrayList);
        // 输出: Sorted ArrayList: [Apple, Cherry, Cherry, Date, Elderberry]

        // 创建不可修改的 List
        List<String> unmodifiableList = Collections.unmodifiableList(arrayList);
        System.out.println("UnmodifiableList ArrayList: " + unmodifiableList);
        // 输出: UnmodifiableList ArrayList: [Apple, Cherry, Cherry, Date, Elderberry]

        // 创建和操作 Set
        Set<String> hashSet = new HashSet<>(arrayList); // 基于哈希表实现的集合
        Set<String> linkedHashSet = new LinkedHashSet<>(arrayList); // 保留插入顺序的集合
        Set<String> treeSet = new TreeSet<>(arrayList); // 元素有序的集合

        // 输出 Set
        System.out.println("HashSet: " + hashSet);
        // 输出: HashSet: [Apple, Cherry, Date, Elderberry]
        System.out.println("LinkedHashSet: " + linkedHashSet);
        // 输出: LinkedHashSet: [Apple, Cherry, Date, Elderberry]
        System.out.println("TreeSet: " + treeSet);
        // 输出: TreeSet: [Apple, Cherry, Date, Elderberry]

        // 创建和操作 Queue
        Queue<String> priorityQueue = new PriorityQueue<>(arrayList); // 优先级队列
        Queue<String> linkedListQueue = new LinkedList<>(arrayList); // LinkedList实现的队列
        ArrayDeque<String> arrayDeQueue = new ArrayDeque<>(arrayList); // 双端队列

        // 输出 Queue
        System.out.println("PriorityQueue (natural order): " + priorityQueue);
        // 输出: PriorityQueue (natural order): [Apple, Cherry, Cherry, Date, Elderberry]
        System.out.println("LinkedList as Queue: " + linkedListQueue);
        // 输出: LinkedList as Queue: [Apple, Cherry, Cherry, Date, Elderberry]

        // 从 PriorityQueue 中移除元素
        priorityQueue.poll(); // 移除优先级队列中的第一个元素
        System.out.println("PriorityQueue after poll: " + priorityQueue);
        // 输出: PriorityQueue after poll: [Cherry, Date, Cherry, Elderberry]

        // 在双端队列中添加元素
        arrayDeQueue.addFirst("Michael"); // 在队头添加元素
        arrayDeQueue.addLast("Wang"); // 在队尾添加元素
        System.out.println("ArrayDeQueue after additions: " + arrayDeQueue);
        // 输出: ArrayDeQueue after additions: [Michael, Apple, Cherry, Cherry, Date, Elderberry, Wang]

        // 创建和操作 Map
        Map<String, Integer> hashMap = new HashMap<>(); // 创建 HashMap
        hashMap.put("Apple", 1); // 添加键值对
        hashMap.put("Banana", 2);
        hashMap.put("Cherry", 3);

        // 创建 LinkedHashMap 和 TreeMap
        Map<String, Integer> linkedHashMap = new LinkedHashMap<>(hashMap); // 保留插入顺序的 Map
        Map<String, Integer> treeMap = new TreeMap<>(hashMap); // 键有序的 Map

        // 输出 Map
        System.out.println("HashMap: " + hashMap);
        // 输出: HashMap: {Apple=1, Banana=2, Cherry=3}
        System.out.println("LinkedHashMap: " + linkedHashMap);
        // 输出: LinkedHashMap: {Apple=1, Banana=2, Cherry=3}
        System.out.println("TreeMap: " + treeMap);
        // 输出: TreeMap: {Apple=1, Banana=2, Cherry=3}

        // 更新 HashMap 中的值
        hashMap.put("Apple", 10); // 修改键“Apple”的值
        System.out.println("Updated HashMap: " + hashMap);
        // 输出: Updated HashMap: {Apple=10, Banana=2, Cherry=3}

        // 创建线程安全的集合
        List<String> copyOnWriteList = new CopyOnWriteArrayList<>(arrayList); // 线程安全的 ArrayList
        Map<String, Integer> concurrentHashMap = new ConcurrentHashMap<>(hashMap); // 线程安全的 HashMap

        // 输出线程安全的集合
        System.out.println("CopyOnWriteArrayList: " + copyOnWriteList);
        // 输出: CopyOnWriteArrayList: [Apple, Cherry, Date, Elderberry]
        System.out.println("ConcurrentHashMap: " + concurrentHashMap);
        // 输出: ConcurrentHashMap: {Apple=10, Banana=2, Cherry=3}

        // 使用 CopyOnWriteArrayList 进行并发修改（示例）
        copyOnWriteList.add("Fig"); // 添加新元素
        System.out.println("CopyOnWriteArrayList after modification: " + copyOnWriteList);
        // 输出: CopyOnWriteArrayList after modification: [Apple, Cherry, Date, Elderberry, Fig]

        // 使用 ConcurrentHashMap 进行并发更新（示例）
        concurrentHashMap.put("Fig", 4); // 添加新元素
        System.out.println("ConcurrentHashMap after update: " + concurrentHashMap);
        // 输出: ConcurrentHashMap after update: {Apple=10, Banana=2, Cherry=3, Fig=4}

        // 创建和操作 EnumSet
        EnumSet<Day> enumSet = EnumSet.allOf(Day.class); // 创建包含所有天的 EnumSet
        System.out.println("Initial EnumSet: " + enumSet);
        // 输出: Initial EnumSet: [MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY]

        // 删除元素
        enumSet.remove(Day.SUNDAY); // 删除“周日”
        System.out

.println("EnumSet after removal: " + enumSet);
        // 输出: EnumSet after removal: [MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY]

        // 清空 EnumSet
        enumSet.clear(); // 清空集合
        System.out.println("EnumSet after clear: " + enumSet);
        // 输出: EnumSet after clear: []

        // 重新初始化 EnumSet
        enumSet = EnumSet.of(Day.MONDAY, Day.WEDNESDAY, Day.FRIDAY); // 重新创建 EnumSet
        // 迭代 EnumSet
        System.out.print("EnumSet iteration: ");
        for (Day day : enumSet) {
            System.out.print(day + " "); // 输出每个元素
        }
        System.out.println();
        // 输出: EnumSet iteration: MONDAY WEDNESDAY FRIDAY

        // 创建和操作 EnumMap
        EnumMap<Day, String> enumMap = new EnumMap<>(Day.class); // 创建 EnumMap
        enumMap.put(Day.MONDAY, "Work"); // 添加键值对
        enumMap.put(Day.SATURDAY, "Rest");
        enumMap.put(Day.SUNDAY, "Relax");
        System.out.println("Initial EnumMap: " + enumMap);
        // 输出: Initial EnumMap: {MONDAY=Work, SATURDAY=Rest, SUNDAY=Relax}

        // 删除元素
        enumMap.remove(Day.SUNDAY); // 删除“周日”
        System.out.println("EnumMap after removal: " + enumMap);
        // 输出: EnumMap after removal: {MONDAY=Work, SATURDAY=Rest}

        // 清空 EnumMap
        enumMap.clear(); // 清空集合
        System.out.println("EnumMap after clear: " + enumMap);
        // 输出: EnumMap after clear: {}

        // 重新初始化 EnumMap
        enumMap.put(Day.TUESDAY, "Meeting"); // 重新添加元素
        enumMap.put(Day.THURSDAY, "Training");
        enumMap.put(Day.FRIDAY, "Report");
        // 迭代 EnumMap
        System.out.print("EnumMap iteration: ");
        for (Map.Entry<Day, String> entry : enumMap.entrySet()) {
            System.out.print(entry.getKey() + "=" + entry.getValue() + " "); // 输出每个键值对
        }
        System.out.println();
        // 输出: EnumMap iteration: TUESDAY=Meeting THURSDAY=Training FRIDAY=Report
    }
}