Java 集合框架超详细解析：核心接口、常见实现与原理剖析

Java集合框架（Java Collections Framework）是Java平台的重要组成部分，提供了一组用于存储、操作和处理数据的接口和类。本文将详细介绍集合框架的各个部分，包括其核心接口、常见实现、以及使用示例和背后的实现原理。

1. 集合框架的核心接口

Java集合框架主要包括以下几个核心接口：

Collection：这是所有集合类的根接口。它有三个主要的子接口：List、Set和Queue。
- List：有序集合，允许元素重复。实现包括：
  - ArrayList
  - LinkedList
  - Vector
  - Stack
- Set：不允许元素重复。实现包括：
  - HashSet
  - LinkedHashSet
  - TreeSet
- Queue：用于存储等待处理的元素。实现包括：
  - PriorityQueue
  - LinkedList
  - ArrayDeque
- Map：映射接口，用于存储键值对。实现包括：
  - HashMap
  - LinkedHashMap
  - TreeMap

2. 常见集合的详细解析

List

ArrayList

import java.util.ArrayList;

public class ArrayListExample {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("Apple");
        arrayList.add("Banana");
        arrayList.add("Cherry");

        System.out.println("Element at index 1: " + arrayList.get(1));

        for (String fruit : arrayList) {
            System.out.println(fruit);
        }

        arrayList.remove(1);
        System.out.println("After removal: " + arrayList);

        boolean containsApple = arrayList.contains("Apple");
        System.out.println("Contains Apple: " + containsApple);
    }
}

原理：ArrayList基于动态数组实现，内部使用一个数组来存储元素。当数组满时，会创建一个更大的新数组并将旧数组中的元素复制到新数组中。
优点：支持快速随机访问。
缺点：在中间插入或删除元素时效率较低，因为需要移动数组中的元素。

LinkedList

import java.util.LinkedList;

public class LinkedListExample {
    public static void main(String[] args) {
        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("Dog");
        linkedList.add("Cat");
        linkedList.add("Rabbit");

        System.out.println("First element: " + linkedList.getFirst());
        System.out.println("Last element: " + linkedList.getLast());

        linkedList.addFirst("Hamster");
        System.out.println("After addFirst: " + linkedList);

        linkedList.removeFirst();
        linkedList.removeLast();
        System.out.println("After removeFirst and removeLast: " + linkedList);

        for (String pet : linkedList) {
            System.out.println(pet);
        }
    }
}

原理：LinkedList基于双向链表实现，内部使用节点来存储元素，每个节点包含指向前一个和后一个节点的引用。
优点：在任意位置插入或删除元素时效率较高。
缺点：随机访问速度较慢，需要从头或尾遍历链表。

Set

HashSet

import java.util.HashSet;

public class HashSetExample {
    public static void main(String[] args) {
        HashSet<String> hashSet = new HashSet<>();
        hashSet.add("Red");
        hashSet.add("Green");
        hashSet.add("Blue");

        boolean added = hashSet.add("Red");
        boolean containsBlue = hashSet.contains("Blue");
        System.out.println("Contains Blue: " + containsBlue);

        hashSet.remove("Green");

        for (String color : hashSet) {
            System.out.println(color);
        }

        System.out.println("Set size: " + hashSet.size());
    }
}

原理：HashSet基于哈希表实现，使用哈希函数将元素映射到一个数组位置，不允许重复元素。
优点：操作（如添加、删除、查找）效率高，平均时间复杂度为O(1)。
缺点：元素无序，不能保证元素的插入顺序。

TreeSet

import java.util.TreeSet;

public class TreeSetExample {
    public static void main(String[] args) {
        TreeSet<String> treeSet = new TreeSet<>();
        treeSet.add("Orange");
        treeSet.add("Apple");
        treeSet.add("Banana");

        for (String fruit : treeSet) {
            System.out.println(fruit);
        }

        System.out.println("First element: " + treeSet.first());
        System.out.println("Last element: " + treeSet.last());

        treeSet.remove("Banana");
        System.out.println("After removal: " + treeSet);
    }
}

原理：TreeSet基于红黑树实现，自动对元素进行排序。
优点：支持排序和范围查询，所有操作的时间复杂度为O(log n)。
缺点：操作复杂度较高，内存开销较大。

Queue

PriorityQueue

import java.util.PriorityQueue;

public class PriorityQueueExample {
    public static void main(String[] args) {
        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
        priorityQueue.add(20);
        priorityQueue.add(15);
        priorityQueue.add(30);

        System.out.println("Peek: " + priorityQueue.peek());
        System.out.println("Poll: " + priorityQueue.poll());
        System.out.println("Peek after poll: " + priorityQueue.peek());

        for (Integer number : priorityQueue) {
            System.out.println(number);
        }
    }
}

原理：PriorityQueue基于优先级堆实现，元素根据优先级自动排序。
优点：支持根据优先级排序的操作。
缺点：不支持队列的FIFO顺序，只按优先级排序。

ArrayDeque

import java.util.ArrayDeque;

public class ArrayDequeExample {
    public static void main(String[] args) {
        ArrayDeque<String> deque = new ArrayDeque<>();
        deque.add("First");
        deque.addLast("Second");
        deque.addFirst("Third");

        System.out.println("Deque: " + deque);

        deque.removeFirst();
        deque.removeLast();
        System.out.println("After removal: " + deque);

        for (String element : deque) {
            System.out.println(element);
        }
    }
}

原理：ArrayDeque基于数组实现，是一个双端队列，支持双端操作。
优点：支持高效的双端操作，可以作为栈或队列使用。
缺点：不支持容量限制的Deque操作。

Map

HashMap

import java.util.HashMap;

public class HashMapExample {
    public static void main(String[] args) {
        HashMap<String, Integer> hashMap = new HashMap<>();
        hashMap.put("Apple", 3);
        hashMap.put("Banana", 2);
        hashMap.put("Cherry", 5);

        int appleCount = hashMap.get("Apple");
        System.out.println("Apple count: " + appleCount);

        boolean hasBanana = hashMap.containsKey("Banana");
        System.out.println("Has Banana: " + hasBanana);

        hashMap.remove("Banana");

        for (HashMap.Entry<String, Integer> entry : hashMap.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }

        System.out.println("Map size: " + hashMap.size());
    }
}

原理：HashMap基于哈希表实现，使用哈希函数将键映射到数组位置。
优点：支持O(1)的查找、插入和删除操作。
缺点：不保证顺序，可能存在哈希冲突。

TreeMap

import java.util.TreeMap;

public class TreeMapExample {
    public static void main(String[] args) {
        TreeMap<String, Integer> treeMap = new TreeMap<>();
        treeMap.put("Orange", 10);
        treeMap.put("Apple", 5);
        treeMap.put("Banana", 7);

        for (String key : treeMap.keySet()) {
            System.out.println(key + ": " + treeMap.get(key));
        }

        System.out.println("First key: " + treeMap.firstKey());
        System.out.println("Last key: " + treeMap.lastKey());

        treeMap.remove("Banana");
        System.out.println("After removal: " + treeMap);
    }
}