📌 目录

  1. 什么是 Java 集合框架？
  2. 集合框架的核心接口
    • 2.1 Collection 接口
    • 2.2 List 接口
    • 2.3 Set 接口
    • 2.4 Queue 接口
    • 2.5 Map 接口
  3. 常见的集合类实现
    • 3.1 ArrayList
    • 3.2 LinkedList
    • 3.3 HashSet
    • 3.4 TreeSet
    • 3.5 HashMap
    • 3.6 TreeMap
  4. 集合框架的特性
  5. 集合的操作
  6. 迭代器
  7. 线程安全的集合
  8. 参考资料
  9. 出站链接

1. 什么是 Java 集合框架？

Java 集合框架是一个包含了许多接口和类的集合，用于存储、检索和操作数据。Java 集合框架提供了一种统一的方式来操作数据，使得 Java 开发者能够更加高效地进行数据操作。集合框架支持多种数据结构（如列表、集合、映射等），并且为不同类型的集合提供了丰富的实现和操作方法。

集合框架是 Java 标准库的一部分，包括了多个接口和类。集合框架提供了 List、Set、Queue 和 Map 等接口，以及它们的具体实现类。

2. 集合框架的核心接口

Java 集合框架有五个核心接口，它们分别是：Collection、List、Set、Queue 和 Map。每个接口有不同的特性和用途。

2.1 Collection 接口

Collection 是集合框架中最基本的接口，定义了集合的通用操作，如添加、删除、清空等。List、Set 和 Queue 都继承自 Collection 接口。

常见方法：

  • add(E e)
  • remove(Object o)
  • size()
  • isEmpty()
  • clear()

2.2 List 接口

List 是 Collection 的子接口，表示有序的集合，允许重复元素。List 的实现类如 ArrayList 和 LinkedList。

常见方法：

  • add(int index, E element)
  • get(int index)
  • remove(int index)
  • set(int index, E element)

2.3 Set 接口

Set 是 Collection 的子接口，表示不允许重复元素的集合，通常用于存储唯一元素。常见实现类包括 HashSet 和 TreeSet。

常见方法：

  • add(E e)
  • remove(Object o)
  • size()
  • contains(Object o)

2.4 Queue 接口

Queue 是 Collection 的子接口，表示按先进先出（FIFO）原则存储元素的集合。常见实现类包括 LinkedList 和 PriorityQueue。

常见方法：

  • offer(E e)
  • poll()
  • peek()
  • remove()

2.5 Map 接口

Map 是一种键值对映射结构，包含唯一的键和对应的值。它不继承自 Collection 接口，但集合框架的一部分。常见实现类包括 HashMap 和 TreeMap。

常见方法：

  • put(K key, V value)
  • get(Object key)
  • remove(Object key)
  • containsKey(Object key)

3. 常见的集合类实现

3.1 ArrayList

ArrayList 是一个实现了 List 接口的可变大小的数组。它是 Java 中最常用的列表实现。

特点：

  • 按索引访问：可以通过索引快速访问元素，时间复杂度为 O(1)。
  • 动态扩展：当数组元素过多时，会自动扩展其容量。
import java.util.ArrayList;
import java.util.List;

public class ArrayListExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Java");
        list.add("Python");
        list.add("C++");
        
        System.out.println(list.get(0));  // 输出: Java
    }
}

3.2 LinkedList

LinkedList 是一个双向链表的实现。相比 ArrayList，LinkedList 在插入和删除操作上更高效。

特点：

  • 插入/删除操作高效：在列表的开始和中间插入或删除元素时，时间复杂度为 O(1)。
  • 按索引访问慢：获取元素的时间复杂度为 O(n)，因为需要遍历链表。
import java.util.LinkedList;
import java.util.List;

public class LinkedListExample {
    public static void main(String[] args) {
        List<String> list = new LinkedList<>();
        list.add("Java");
        list.add("Python");
        
        System.out.println(list.get(0));  // 输出: Java
    }
}

3.3 HashSet

HashSet 是实现了 Set 接口的集合，基于哈希表实现，元素不允许重复。

特点：

  • 不允许重复元素：元素在集合中唯一。
  • 无序存储：元素的存储顺序不一定和插入顺序相同。
import java.util.HashSet;
import java.util.Set;

public class HashSetExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("Java");
        set.add("Python");
        set.add("Java");  // 重复元素将被忽略
        
        System.out.println(set);  // 输出: [Java, Python]
    }
}

3.4 TreeSet

TreeSet 是基于红黑树实现的 Set 接口的实现，元素是排序的，支持顺序操作。

特点：

  • 自动排序：元素会按照自然顺序或指定的比较器进行排序。
  • 不允许重复元素：和 HashSet 一样，元素在集合中是唯一的。
import java.util.TreeSet;
import java.util.Set;

public class TreeSetExample {
    public static void main(String[] args) {
        Set<String> set = new TreeSet<>();
        set.add("Java");
        set.add("Python");
        set.add("C++");
        
        System.out.println(set);  // 输出: [C++, Java, Python]
    }
}

3.5 HashMap

HashMap 是实现了 Map 接口的哈希表，它存储键值对。键是唯一的，而值可以重复。

特点：

  • 基于哈希表实现：提供 O(1) 的查找速度。
  • 键值对存储：每个元素都是一个键值对。
import java.util.HashMap;
import java.util.Map;

public class HashMapExample {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("Java", "Programming Language");
        map.put("Python", "Scripting Language");
        
        System.out.println(map.get("Java"));  // 输出: Programming Language
    }
}

3.6 TreeMap

TreeMap 是一个有序的 Map 实现，基于红黑树，它会按照键的自然顺序或自定义的比较器对键进行排序。

特点：

  • 自动排序：键会按升序排序。
  • 不允许键重复：每个键只能映射到一个值。
import java.util.TreeMap;
import java.util.Map;

public class TreeMapExample {
    public static void main(String[] args) {
        Map<String, String> map = new TreeMap<>();
        map.put("Java", "Programming Language");
        map.put("Python", "Scripting Language");
        
        System.out.println(map);  // 输出: {Java=Programming Language, Python=Scripting Language}
    }
}

4. 集合框架的特性

  • 动态大小：大多数集合类（如 ArrayList 和 HashSet）具有动态大小，可以根据需要自动扩展。
  • 元素唯一性：Set 不允许重复元素，而 List 允许重复。
  • 排序：TreeSet 和 TreeMap 自动对元素进行排序，HashSet 和 HashMap 无序存储。
  • 线程安全性：默认情况下，集合类不是线程安全的，若需要线程安全的集合，可以使用 Collections.synchronizedCollection 或者使用 Concurrent 包中的集合类。

5. 集合的操作

Java 集合框架提供了多种集合操作，如：

  • 添加元素：add()
  • 删除元素：remove()
  • 判断是否包含元素：contains()
  • 遍历集合：for-each 循环或使用迭代器。

6. 迭代器

迭代器（Iterator）是 Java 中用于遍历集合元素的接口，集合框架中的所有集合类都实现了该接口。通过迭代器可以安全地遍历集合并执行删除操作。

import java.util.ArrayList;
import java.util.Iterator;

public class IteratorExample {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Java");
        list.add("Python");
        list.add("C++");
        
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

7. 线程安全的集合

Java 提供了线程安全的集合类，常见的有：

  • Vector：线程安全的动态数组。
  • Hashtable：线程安全的哈希表。
  • ConcurrentHashMap：线程安全的哈希映射，适用于高并发环境。

8. 参考资料

9. 出站链接