Java集合框架概述

Java集合框架是Java中用于存储和操作对象集合的架构，它提供了一套性能优良、使用方便的接口和类。Java集合框架主要分为两大体系：Collection和Map。

Collection体系

Collection是单列集合的顶层接口，它继承自Iterable接口，主要存储单个元素。Collection体系主要包括List、Set和Queue三大子接口。

List接口

List是有序、可重复的集合，可以通过索引访问元素。

主要实现类：

1. ArrayList：

   • 基于动态数组实现
   • 随机访问效率高，增删效率低
   • 非线程安全
   • 默认初始容量为10，扩容时为原来的1.5倍

2. LinkedList：

   • 基于双向链表实现
   • 随机访问效率低，增删效率高
   • 非线程安全
   • 可用作队列、栈

3. Vector：

   • 基于动态数组实现
   • 线程安全（使用synchronized修饰方法）
   • 性能较低
   • 默认初始容量为10，扩容时为原来的2倍

4. Stack：

   • 继承自Vector
   • 实现栈结构（后进先出）
   • 线程安全

Set接口

Set是无序、不可重复的集合，不允许存储重复元素。

主要实现类：

1. HashSet：

   • 基于HashMap实现
   • 存储无序，不可重复
   • 非线程安全
   • 允许存储null值
   • 查找、插入、删除的时间复杂度为O(1)

2. LinkedHashSet：

   • 继承自HashSet
   • 基于LinkedHashMap实现
   • 保持插入顺序
   • 非线程安全

3. TreeSet：

   • 基于TreeMap实现
   • 有序（自然排序或自定义排序）
   • 非线程安全
   • 不允许null值

4. EnumSet：

   • 专门为枚举类型设计的集合
   • 内部使用位向量实现
   • 高效且节省内存

Queue接口

Queue是队列接口，遵循先进先出(FIFO)原则。

主要实现类：

1. LinkedList：

   • 实现了Queue接口
   • 可用作双向队列

2. PriorityQueue：

   • 基于优先级堆实现
   • 元素按优先级排序
   • 非线程安全

3. ArrayDeque：

   • 基于可扩容数组实现
   • 高效的双端队列
   • 非线程安全

4. ConcurrentLinkedQueue：

   • 基于链接节点的无界线程安全队列
   • 使用CAS操作实现线程安全

Map体系

Map是双列集合，存储键值对（key-value）映射，键不可重复，值可以重复。

主要实现类：

1. HashMap：

   • 基于哈希表实现（数组+链表/红黑树）
   • 键无序，不可重复
   • 非线程安全
   • 允许null键和null值
   • JDK 1.8后，当链表长度超过8且数组长度超过64时，链表转为红黑树

2. LinkedHashMap：

   • 继承自HashMap
   • 保持插入顺序或访问顺序
   • 非线程安全
   • 可用于实现LRU缓存

3. TreeMap：

   • 基于红黑树实现
   • 键有序（自然排序或自定义排序）
   • 非线程安全
   • 不允许null键

4. Hashtable：

   • 基于哈希表实现
   • 线程安全（使用synchronized修饰方法）
   • 不允许null键和null值
   • 性能较低

5. ConcurrentHashMap：

   • 线程安全的HashMap
   • JDK 1.7使用分段锁实现
   • JDK 1.8使用CAS+synchronized实现
   • 高并发环境下性能优于Hashtable

6. WeakHashMap：

   • 键是弱引用
   • 当键不再被外部引用时，可被GC回收
   • 适用于缓存场景

7. IdentityHashMap：

   • 使用==比较键，而不是equals()
   • 用于特殊场景，如对象序列化

集合框架结构图

集合框架特性对比

List实现类对比

Set实现类对比

Map实现类对比

集合框架使用示例

ArrayList示例

import java.util.ArrayList;
import java.util.List;

public class ArrayListExample {
    public static void main(String[] args) {
        // 创建ArrayList
        List<String> list = new ArrayList<>();
        
        // 添加元素
        list.add("Apple");
        list.add("Banana");
        list.add("Orange");
        
        // 访问元素
        String first = list.get(0);  // "Apple"
        
        // 修改元素
        list.set(1, "Blueberry");
        
        // 删除元素
        list.remove(2);
        
        // 遍历
        for (String fruit : list) {
            System.out.println(fruit);
        }
    }
}

HashSet示例

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

public class HashSetExample {
    public static void main(String[] args) {
        // 创建HashSet
        Set<String> set = new HashSet<>();
        
        // 添加元素
        set.add("Apple");
        set.add("Banana");
        set.add("Orange");
        set.add("Apple");  // 重复元素不会被添加
        
        // 检查元素是否存在
        boolean hasBanana = set.contains("Banana");  // true
        
        // 删除元素
        set.remove("Orange");
        
        // 遍历
        for (String fruit : set) {
            System.out.println(fruit);
        }
    }
}

HashMap示例

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

public class HashMapExample {
    public static void main(String[] args) {
        // 创建HashMap
        Map<String, Integer> map = new HashMap<>();
        
        // 添加键值对
        map.put("Apple", 10);
        map.put("Banana", 20);
        map.put("Orange", 30);
        
        // 获取值
        int appleCount = map.get("Apple");  // 10
        
        // 修改值
        map.put("Banana", 25);
        
        // 删除键值对
        map.remove("Orange");
        
        // 遍历键值对
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

集合框架选择指南

选择合适的集合实现类需要考虑多个因素：

1. 是否需要有序：

   • 需要按插入顺序：LinkedHashSet、LinkedHashMap
   • 需要排序：TreeSet、TreeMap
   • 不需要顺序：HashSet、HashMap

2. 是否允许重复：

   • 允许重复：List
   • 不允许重复：Set

3. 线程安全需求：

   • 需要线程安全：Vector、Hashtable、ConcurrentHashMap、ConcurrentLinkedQueue
   • 不需要线程安全：ArrayList、LinkedList、HashSet、HashMap等

4. 性能需求：

   • 频繁随机访问：ArrayList
   • 频繁增删：LinkedList
   • 快速查找：HashSet、HashMap
   • 需要排序：TreeSet、TreeMap

5. 特殊需求：

   • 键值对：Map
   • 队列操作：Queue
   • 栈操作：Stack
   • 枚举类型：EnumSet
   • 弱引用：WeakHashMap

集合框架的最佳实践

1. 接口优先原则：

   • 优先使用接口类型声明变量，如List、Set、Map
   • 只在创建实例时指定具体实现类

2. 初始化容量：

   • 对于已知大小的集合，初始化时指定容量，避免扩容开销

   List<String> list = new ArrayList<>(100);
   Map<String, String> map = new HashMap<>(100);
   

3. 使用for-each循环：

   • 优先使用for-each循环遍历集合，代码更简洁

   for (String item : list) {
       // 处理item
   }
   

4. 避免在循环中删除元素：

   • 使用Iterator的remove方法删除元素

   Iterator<String> iterator = list.iterator();
   while (iterator.hasNext()) {
       String item = iterator.next();
       if (shouldRemove(item)) {
           iterator.remove();
       }
   }
   

5. 重写equals和hashCode：

   • 自定义对象作为集合元素时，确保正确重写equals和hashCode方法
   • 特别是作为HashMap的键或HashSet的元素时

6. 使用泛型：

   • 使用泛型确保类型安全

   List<String> list = new ArrayList<>();  // 而不是 List list = new ArrayList();
   

7. 考虑使用Java 8+的新特性：

   • 使用Stream API进行集合操作

   List<String> filtered = list.stream()
                              .filter(s -> s.startsWith("A"))
                              .collect(Collectors.toList());