Java集合框架概述 #

一、集合框架概述 #

集合框架是Java提供的一套用于存储和操作对象的标准API。

1.1 集合框架优点 #

统一的API
高性能实现
减少编程工作量

1.2 集合框架体系 #

text

Iterable
└── Collection
    ├── List（有序、可重复）
    │   ├── ArrayList
    │   ├── LinkedList
    │   └── Vector
    ├── Set（无序、不可重复）
    │   ├── HashSet
    │   ├── LinkedHashSet
    │   └── TreeSet
    └── Queue（队列）
        ├── LinkedList
        └── PriorityQueue

Map（键值对）
├── HashMap
├── LinkedHashMap
├── TreeMap
└── Hashtable

二、Collection接口 #

2.1 基本方法 #

java

public interface Collection<E> {
    // 添加
    boolean add(E e);
    boolean addAll(Collection<? extends E> c);
    
    // 删除
    boolean remove(Object o);
    boolean removeAll(Collection<?> c);
    void clear();
    
    // 查询
    boolean contains(Object o);
    boolean containsAll(Collection<?> c);
    boolean isEmpty();
    int size();
    
    // 转换
    Object[] toArray();
    <T> T[] toArray(T[] a);
    
    // 遍历
    Iterator<E> iterator();
}

2.2 使用示例 #

java

Collection<String> collection = new ArrayList<>();

// 添加元素
collection.add("A");
collection.add("B");
collection.add("C");

// 判断
System.out.println(collection.size());      // 3
System.out.println(collection.isEmpty());   // false
System.out.println(collection.contains("A")); // true

// 删除
collection.remove("B");
System.out.println(collection);  // [A, C]

// 清空
collection.clear();
System.out.println(collection.size());  // 0

三、List接口 #

3.1 特点 #

有序（按插入顺序）
可重复
可通过索引访问

3.2 常用方法 #

java

public interface List<E> extends Collection<E> {
    // 按索引操作
    void add(int index, E element);
    E get(int index);
    E set(int index, E element);
    E remove(int index);
    
    // 查找
    int indexOf(Object o);
    int lastIndexOf(Object o);
    
    // 子列表
    List<E> subList(int fromIndex, int toIndex);
}

3.3 实现类对比 #

实现类	底层结构	线程安全	适用场景
ArrayList	数组	不安全	随机访问多
LinkedList	链表	不安全	增删操作多
Vector	数组	安全	多线程环境

四、Set接口 #

4.1 特点 #

不可重复
最多一个null元素

4.2 实现类对比 #

实现类	底层结构	排序	适用场景
HashSet	哈希表	无序	快速查找
LinkedHashSet	哈希表+链表	插入顺序	需要保持顺序
TreeSet	红黑树	自然排序	需要排序

五、Map接口 #

5.1 特点 #

存储键值对
键不可重复
值可重复

5.2 常用方法 #

java

public interface Map<K, V> {
    // 基本操作
    V put(K key, V value);
    V get(Object key);
    V remove(Object key);
    boolean containsKey(Object key);
    boolean containsValue(Object value);
    int size();
    boolean isEmpty();
    void clear();
    
    // 视图
    Set<K> keySet();
    Collection<V> values();
    Set<Map.Entry<K, V>> entrySet();
}

5.3 实现类对比 #

实现类	底层结构	线程安全	null键/值
HashMap	哈希表	不安全	允许
LinkedHashMap	哈希表+链表	不安全	允许
TreeMap	红黑树	不安全	键不允许null
Hashtable	哈希表	安全	不允许

六、Queue接口 #

6.1 特点 #

先进先出（FIFO）
用于排队处理

6.2 常用方法 #

java

public interface Queue<E> extends Collection<E> {
    // 添加（失败抛异常）
    boolean add(E e);
    
    // 添加（失败返回false）
    boolean offer(E e);
    
    // 获取并删除队首（空抛异常）
    E remove();
    
    // 获取并删除队首（空返回null）
    E poll();
    
    // 获取队首（空抛异常）
    E element();
    
    // 获取队首（空返回null）
    E peek();
}

七、集合选择 #

7.1 List选择 #

java

// 随机访问多 → ArrayList
List<String> list1 = new ArrayList<>();

// 增删操作多 → LinkedList
List<String> list2 = new LinkedList<>();

// 多线程 → Vector或CopyOnWriteArrayList
List<String> list3 = new CopyOnWriteArrayList<>();

7.2 Set选择 #

java

// 快速查找，不关心顺序 → HashSet
Set<String> set1 = new HashSet<>();

// 保持插入顺序 → LinkedHashSet
Set<String> set2 = new LinkedHashSet<>();

// 需要排序 → TreeSet
Set<String> set3 = new TreeSet<>();

7.3 Map选择 #

java

// 快速查找，不关心顺序 → HashMap
Map<String, Integer> map1 = new HashMap<>();

// 保持插入顺序 → LinkedHashMap
Map<String, Integer> map2 = new LinkedHashMap<>();

// 需要按键排序 → TreeMap
Map<String, Integer> map3 = new TreeMap<>();

// 多线程 → ConcurrentHashMap
Map<String, Integer> map4 = new ConcurrentHashMap<>();

八、总结 #

集合类型	特点	主要实现
List	有序、可重复	ArrayList, LinkedList
Set	不可重复	HashSet, TreeSet
Map	键值对	HashMap, TreeMap
Queue	先进先出	LinkedList, PriorityQueue

集合框架要点：

List有序可重复
Set不可重复
Map存储键值对
根据场景选择合适的实现类