Java的Collection 集合体系详解

在 Java 开发中，集合框架是处理数据容器的核心工具。它提供了一系列接口和类，帮助我们高效地存储、操作和管理对象集合。本文将聚焦Collection 集合体系，深入解析其核心接口与实现类。

一、集合框架概述

Java 集合框架主要分为两大体系：

Collection 体系 ：存储单个元素的集合，包括 List（有序可重复）、Set（无序不可重复）、Queue（队列）。
Map 体系：存储 ** 键值对（Key-Value）** 的集合，如 HashMap、TreeMap 等。

今天我们先深入学习Collection 体系。

二、Collection 接口：集合的根接口

java.util.Collection是所有单列集合的根接口，它定义了集合的通用行为，包括增删改查、遍历等操作。

1. Collection 常用方法

java 复制代码

public class CollectionDemo {
    public static void main(String[] args) {
        Collection<String> coll = new ArrayList<>();
        
        // 添加元素
        coll.add("Java");
        coll.add("Python");
        coll.add("C++");
        
        // 判断是否包含元素
        System.out.println(coll.contains("Java")); // true
        
        // 删除元素
        coll.remove("C++");
        
        // 元素个数
        System.out.println(coll.size()); // 2
        
        // 转数组
        Object[] arr = coll.toArray();
        for (Object o : arr) {
            System.out.println(o);
        }
        
        // 清空集合
        coll.clear();
        System.out.println(coll.isEmpty()); // true
    }
}

三、List 接口：有序可重复的集合

List接口继承自Collection，特点是元素有序、可重复 ，且支持通过索引操作元素。常用实现类有ArrayList、LinkedList、Vector。

1. ArrayList：基于数组的动态列表

底层结构：数组，查询快（随机访问）、增删慢（需移动元素）。
适用场景：读多写少的场景。

java 复制代码

public class ArrayListDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");
        
        // 按索引访问
        System.out.println(list.get(1)); // Banana
        
        // 按索引修改
        list.set(1, "Grape");
        System.out.println(list); // [Apple, Grape, Cherry]
        
        // 插入元素
        list.add(1, "Pear");
        System.out.println(list); // [Apple, Pear, Grape, Cherry]
    }
}

2. LinkedList：基于链表的双向列表

底层结构：双向链表，查询慢（需遍历）、增删快（只需修改指针）。
额外功能 ：实现了Deque接口，支持队列、栈的操作（如push、pop、offer、poll）。

java 复制代码

public class LinkedListDemo {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();
        list.add("A");
        list.add("B");
        list.add("C");
        
        // 栈操作（先进后出）
        list.push("Top");
        System.out.println(list.pop()); // Top
        
        // 队列操作（先进先出）
        list.offer("Last");
        System.out.println(list.poll()); // A
    }
}

3. Vector：线程安全的动态列表（已过时）

特点：方法加了synchronized锁，线程安全但性能低。
替代方案 ：优先用ArrayList，多线程场景可结合Collections.synchronizedList()。

四、Set 接口：无序不可重复的集合

Set接口继承自Collection，特点是元素无序、不可重复 （通过equals()和hashCode()保证唯一性）。常用实现类有HashSet、LinkedHashSet、TreeSet。

1. HashSet：基于哈希表的 Set

底层结构：哈希表（数组 + 链表 / 红黑树），元素无序、唯一。
去重原理 ：先比较hashCode，再比较equals()。

java 复制代码

public class HashSetDemo {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("Java");
        set.add("Java"); // 重复元素，添加失败
        set.add("Python");
        
        System.out.println(set); // [Python, Java]（无序）
    }
}

2. LinkedHashSet：有序的 HashSet

底层结构 ：哈希表 + 链表，元素有序（插入顺序）、唯一。
适用场景：需要保证插入顺序的去重场景。

java 复制代码

public class LinkedHashSetDemo {
    public static void main(String[] args) {
        Set<String> set = new LinkedHashSet<>();
        set.add("A");
        set.add("B");
        set.add("A");
        
        System.out.println(set); // [A, B]（保持插入顺序）
    }
}

3. TreeSet：可排序的 Set

底层结构 ：红黑树，元素可排序（自然排序或自定义比较器）、唯一。
排序方式 ：元素需实现Comparable接口，或创建TreeSet时传入Comparator。

java 复制代码

public class TreeSetDemo {
    public static void main(String[] args) {
        // 自然排序（Integer实现了Comparable）
        Set<Integer> set = new TreeSet<>();
        set.add(3);
        set.add(1);
        set.add(2);
        System.out.println(set); // [1, 2, 3]（自动排序）
        
        // 自定义比较器（降序）
        Set<String> strSet = new TreeSet<>((s1, s2) -> s2.compareTo(s1));
        strSet.add("C");
        strSet.add("A");
        strSet.add("B");
        System.out.println(strSet); // [C, B, A]
    }
}

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

Queue接口继承自Collection，是先进先出的队列结构，常用实现类有LinkedList（同时实现了 List 和 Queue）、PriorityQueue（优先队列）。

java 复制代码

public class QueueDemo {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();
        queue.offer("Task1"); // 入队
        queue.offer("Task2");
        queue.offer("Task3");
        
        System.out.println(queue.poll()); // Task1（出队）
        System.out.println(queue.peek()); // Task2（查看队首，不出队）
        System.out.println(queue); // [Task2, Task3]
    }
}

总结

Collection 体系是 Java 集合的基础，其中：

List ：有序可重复，选ArrayList（读多写少）或LinkedList（增删多）。
Set ：无序不可重复，选HashSet（性能优）、LinkedHashSet（需插入顺序）或TreeSet（需排序）。
Queue ：先进先出，选LinkedList或PriorityQueue（优先队列）。