Java集合框架详解

原创

艾伦耶格尔

发布于 2025-08-05 17:32:41

5520

集合框架（Collection Framework）是Java中一个非常重要和常用的部分，它提供了一系列用于存储和处理对象集合的接口和类。集合框架的主要目的是提供一种统一的方式来处理对象的集合，简化编程工作，提高代码的可读性和可维护性。

核心接口

Collection：最基本的集合接口，它是一个序列，可以包含重复的元素。
List：继承自Collection，表示一个有序的集合，可以包含重复的元素，支持元素的插入、删除、访问和搜索。
Set：继承自Collection，表示一个不允许重复的集合，不保证集合的顺序，主要用于确保集合中元素的唯一性。
Map：与Collection不同，Map存储的是键值对（key-value pairs），每个键最多只能映射到一个值。
核心实现类
ArrayList：List接口的实现，基于动态数组实现，支持快速随机访问。
LinkedList：List接口的实现，基于双向链表实现，支持快速的插入和删除操作。
HashSet：Set接口的实现，基于哈希表实现，不保证元素顺序，提供快速查找。
LinkedHashSet：继承自HashSet，内部使用链表维护元素的插入顺序。
TreeSet：Set接口的实现，基于红黑树实现，可以按照自然顺序或自定义顺序对元素进行排序。
HashMap：Map接口的实现，基于哈希表实现，不保证映射的顺序。
LinkedHashMap：继承自HashMap，内部使用链表维护键值对的插入顺序。
TreeMap：Map接口的实现，基于红黑树实现，可以按照自然顺序或自定义顺序对键进行排序。

迭代器（Iterator）

迭代器是集合框架中用于遍历集合元素的对象。它提供了一种统一的方法来遍历集合中的元素，而不需要关心集合的具体实现。

1. List 接口

`List` 接口是一个有序集合，它允许存储重复的元素，并且能够通过索引来访问元素。`List` 接口的常见实现有 `ArrayList` 和 `LinkedList`。

1.1 ArrayList

`ArrayList` 是 `List` 接口的一个实现，基于动态数组。它支持高效的随机访问，但是在插入和删除操作时效率较低。

特性：

- 支持快速随机访问。

- 插入和删除操作可能比较慢，特别是在数组中间位置操作时。

- 允许存储重复的元素。

- 保持元素的插入顺序。

常用方法：

- `add(E e)`：将元素添加到列表的末尾。

- `add(int index, E element)`：在指定位置插入元素。

- `get(int index)`：获取指定位置的元素。

- `remove(int index)`：移除指定位置的元素。

- `size()`：返回列表中的元素个数。

- `contains(Object o)`：检查列表是否包含指定的元素。

- `clear()`：清空列表。

示例代码：

import java.util.ArrayList;
 
public class ArrayListExample {
    public static void main(String[] args) {
        // 创建 ArrayList 对象
        ArrayList<String> list = new ArrayList<>();
        
        // 添加元素
        list.add("Java");
        list.add("Python");
        list.add("C++");
 
        // 在指定位置插入元素
        list.add(1, "JavaScript");
 
        // 获取并打印元素
        System.out.println("元素在索引 1 的位置: " + list.get(1));
 
        // 移除元素
        list.remove(2);
 
        // 打印所有元素
        System.out.println("列表内容:");
        for (String language : list) {
            System.out.println(language);
        }
 
        // 清空列表
        list.clear();
        System.out.println("列表是否为空: " + list.isEmpty());
    }
}

1.2 LinkedList

`LinkedList` 是 `List` 接口的另一个实现，基于双向链表。它在插入和删除操作时更高效，但是随机访问的效率较低。

特性：

- 插入和删除操作比较高效。

- 随机访问性能较差。

- 允许存储重复的元素。

- 保持元素的插入顺序。

常用方法：

- `add(E e)`：将元素添加到列表的末尾。

- `add(int index, E element)`：在指定位置插入元素。

- `get(int index)`：获取指定位置的元素。

- `remove(int index)`：移除指定位置的元素。

- `size()`：返回列表中的元素个数。

- `contains(Object o)`：检查列表是否包含指定的元素。

- `clear()`：清空列表。

- `addFirst(E e)`：在列表的开头添加元素。

- `addLast(E e)`：在列表的末尾添加元素。

- `removeFirst()`：移除并返回列表的第一个元素。

- `removeLast()`：移除并返回列表的最后一个元素。

示例代码：

import java.util.LinkedList;
 
public class LinkedListExample {
    public static void main(String[] args) {
        // 创建 LinkedList 对象
        LinkedList<String> list = new LinkedList<>();
        
        // 添加元素
        list.add("Java");
        list.add("Python");
        list.add("C++");
 
        // 在指定位置插入元素
        list.add(1, "JavaScript");
 
        // 在开头添加元素
        list.addFirst("HTML");
 
        // 在末尾添加元素
        list.addLast("CSS");
 
        // 获取并打印元素
        System.out.println("元素在索引 1 的位置: " + list.get(1));
 
        // 移除元素
        list.remove(2);
 
        // 打印所有元素
        System.out.println("列表内容:");
        for (String language : list) {
            System.out.println(language);
        }
 
        // 移除第一个和最后一个元素
        System.out.println("移除的第一个元素: " + list.removeFirst());
        System.out.println("移除的最后一个元素: " + list.removeLast());
 
        // 清空列表
        list.clear();
        System.out.println("列表是否为空: " + list.isEmpty());
    }
}

2. Set 接口

`Set` 接口是一个不允许存储重复元素的集合。常见的实现包括 `HashSet` 和 `TreeSet`。

2.1 HashSet

`HashSet` 是基于哈希表实现的 `Set` 接口的实现，它不保证集合的顺序。

特性：

- 不允许重复的元素。

- 不保证元素的顺序。

- 适合用于快速查找元素。

常用方法：

- `add(E e)`：添加元素。

- `remove(Object o)`：移除元素。

- `contains(Object o)`：检查集合是否包含指定的元素。

- `size()`：返回集合中的元素个数。

- `clear()`：清空集合。

示例代码：

import java.util.HashSet;
 
public class HashSetExample {
    public static void main(String[] args) {
        // 创建 HashSet 对象
        HashSet<String> set = new HashSet<>();
        
        // 添加元素
        set.add("Java");
        set.add("Python");
        set.add("C++");
        set.add("Java"); // 重复的元素将被忽略
 
        // 检查集合中是否包含指定元素
        System.out.println("集合是否包含 'Python': " + set.contains("Python"));
 
        // 打印所有元素
        System.out.println("集合内容:");
        for (String language : set) {
            System.out.println(language);
        }
 
        // 移除元素
        set.remove("C++");
 
        // 打印所有元素
        System.out.println("更新后的集合内容:");
        for (String language : set) {
            System.out.println(language);
        }
 
        // 清空集合
        set.clear();
        System.out.println("集合是否为空: " + set.isEmpty());
    }
}

2.2 TreeSet

`TreeSet` 是基于红黑树实现的 `Set` 接口的实现，它会按照元素的自然顺序进行排序。

**特性：**

- 不允许重复的元素。

- 元素按自然顺序排序。

- 适合需要有序集合的场景。

**常用方法：**

- `add(E e)`：添加元素。

- `remove(Object o)`：移除元素。

- `contains(Object o)`：检查集合是否包含指定的元素。

- `size()`：返回集合中的元素个数。

- `clear()`：清空集合。

示例代码：

import java.util.TreeSet;
 
public class TreeSetExample {
    public static void main(String[] args) {
        // 创建 TreeSet 对象
        TreeSet<String> set = new TreeSet<>();
        
        // 添加元素
        set.add("Java");
        set.add("Python");
        set.add("C++");
        set.add("JavaScript");
 
        // 打印所有元素（按自然顺序）
        System.out.println("集合内容（按自然顺序）:");
        for (String language : set) {
            System.out.println(language);
        }
 
        // 检查集合中是否包含指定元素
        System.out.println("集合是否包含 'Python': " + set.contains("Python"));
 
        // 移除元素
        set.remove("C++");
 
        // 打印所有元素
        System.out.println("更新后的集合内容（按自然顺序）:");
        for (String language : set) {
            System.out.println(language);
        }
 
        // 清空集合
        set.clear();
        System.out.println("集合是否为空: " + set.isEmpty());
    }
}

3. Map 接口

Map 接口用于存储键值对，键是唯一的。常见的实现包括 `HashMap` 和 `TreeMap`。

3.1 HashMap

`HashMap` 是基于哈希表实现的 `Map` 接口的实现。它不保证键值对的顺序。

特性：

- 键值对的存储没有顺序。

- 键是唯一的，但值可以重复。

- 高效的插入、删除和查找操作。

常用方法：

- `put(K key, V value)`：将键值对添加到映射中。

- `get(Object key)`：获取指定键的值。

- `remove(Object key)`：移除指定键的键值对。

- `containsKey(Object key)`：检查映射中是否包含指定的键。

- `size()`：返回映射中的键值对个数。

- `clear()`：清空映射。

示例代码：

import java.util.HashMap;
 
public class HashMapExample {
    public static void main(String[] args) {
        // 创建 HashMap 对象
        HashMap<String, String> map = new HashMap<>();
        
        // 添加键值对
        map.put("Java", "Programming Language");
        map.put("Python", "Scripting Language");
        map.put("C++", "Programming Language");
 
        // 获取并打印值
        System.out.println("Java 的定义: " + map.get("Java"));
 
        // 打印所有键值对
        System.out.println("所有键值对:");
        for (String key : map.keySet()) {
            System.out.println(key + ": " + map.get(key));
        }
 
        // 移除键值对
        map.remove("C++");
 
        // 打印更新后的键值对
        System.out.println("更新后的所有键值对:");
        for (String key : map.keySet()) {
            System.out.println(key + ": " + map.get(key));
        }
 
        // 清空映射
        map.clear();
        System.out.println("映射是否为空: " + map.isEmpty());
    }
}

3.2 TreeMap

`TreeMap` 是基于红黑树实现的 `Map` 接口的实现，键按照自然顺序或指定的比较器排序。

特性：

- 键值对的存储是有序的。

- 键是唯一的，但值可以重复。

- 适合需要有序映射的场景。

常用方法：

- `put(K key, V value)`：将键值对添加到映射中。

- `get(Object key)`：获取指定键的值。

- `remove(Object key)`：移除指定键的键值对。

- `containsKey(Object key)`：检查映射中是否包含指定的键。

- `size()`：返回映射中的键值对个数。

- `clear()`：清空映射。

示例代码：

import java.util.TreeMap;
 
public class TreeMapExample {
    public static void main(String[] args) {
        // 创建 TreeMap 对象
        TreeMap<String, String> map = new TreeMap<>();
        
        // 添加键值对
        map.put("Java", "Programming Language");
        map.put("Python", "Scripting Language");
        map.put("C++", "Programming Language");
 
        // 获取并打印值
        System.out.println("Java 的定义: " + map.get("Java"));
 
        // 打印所有键值对（按自然顺序）
        System.out.println("所有键值对（按自然顺序）:");
        for (String key : map.keySet()) {
            System.out.println(key + ": " + map.get(key));
        }
 
        // 移除键值对
        map.remove("C++");
 
        // 打印更新后的键值对
        System.out.println("更新后的所有键值对（按自然顺序）:");
        for (String key : map.keySet()) {
            System.out.println(key + ": " + map.get(key));
        }
 
        // 清空映射
        map.clear();
        System.out.println("映射是否为空: " + map.isEmpty());
    }
}

4.遍历方式

在Java集合框架中，遍历集合是一种常见的操作，用于访问集合中的每个元素。以下是List、Set和Map接口及其实现类的详细遍历方式：

List接口

1). ArrayList

ArrayList 基于动态数组实现，支持快速随机访问。

使用for循环：

List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Cherry");
 
for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}

使用迭代器（Iterator）：

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

使用增强for循环（For-Each Loop）：

for (String item : list) {
    System.out.println(item);
}

使用Java 8 Stream API（后面会讲到Stream API 哦！）：

list.stream().forEach(System.out::println);

2). LinkedList

LinkedList 基于双向链表实现，支持高效的插入和删除操作。

遍历方式与ArrayList相同，因为LinkedList实现了List接口。

Set接口

1). HashSet

HashSet 不允许重复元素，基于哈希表实现。

使用迭代器（Iterator）：

Set<String> set = new HashSet<>();
set.add("Apple");
set.add("Banana");
set.add("Cherry");
 
Iterator<String> iterator = set.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

使用增强for循环（For-Each Loop）：

for (String item : set) {
    System.out.println(item);
}

使用Java 8 Stream API：

set.stream().forEach(System.out::println);

2). TreeSet

TreeSet 元素按自然顺序排序。

遍历方式与HashSet相同，因为TreeSet实现了Set接口。

Map接口

1). HashMap

HashMap 键值对映射，不保证顺序。

使用键集遍历：

Map<String, String> map = new HashMap<>();
map.put("Apple", "Green");
map.put("Banana", "Yellow");
map.put("Cherry", "Red");
 
for (String key : map.keySet()) {
    System.out.println(key + " -> " + map.get(key));
}

使用值集遍历：

for (String value : map.values()) {
    System.out.println(value);
}

使用条目集遍历：

for (Map.Entry<String, String> entry : map.entrySet()) {
    System.out.println(entry.getKey() + " -> " + entry.getValue());
}

使用Java 8 Stream API：

map.forEach((key, value) -> System.out.println(key + " -> " + value));

2). TreeMap

TreeMap 按键的自然顺序排序。

遍历方式与HashMap相同，因为TreeMap实现了Map接口。

各种遍历方式的异同：迭代器提供了一种安全的方式来遍历集合，即使在遍历时修改集合也不会抛出ConcurrentModificationException。增强for循环提供了一种简洁的方式来遍历集合，而Stream API则提供了一种更高级的方式来处理集合，支持并行处理和复杂的操作。每种遍历方式都有其适用场景，选择合适的遍历方式可以提高代码的可读性和性能。

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

学习笔记