编程马·菜鸟教程

Appearance

14.4 集合常用方法（增删改查） ​

集合的基本操作 ​

Java 集合框架提供了丰富的方法用于操作集合中的元素，主要包括添加、删除、修改和查询操作。本文将详细介绍这些常用方法的使用。

1. 添加元素方法 ​

1.1 Collection 接口的添加方法 ​

add(E e) ​

功能：向集合中添加元素 返回值：如果元素成功添加到集合中，返回 true；否则返回 false

示例：

java
Collection<String> collection = new ArrayList<>();
boolean added = collection.add("Java");
System.out.println("添加成功: " + added); // true
collection.add("Python");
collection.add("C++");
System.out.println(collection); // [Java, Python, C++]

addAll(Collection<? extends E> c) ​

功能：向集合中添加另一个集合的所有元素 返回值：如果集合发生变化，返回 true；否则返回 false

示例：

java
Collection<String> collection1 = new ArrayList<>();
collection1.add("Java");
collection1.add("Python");

Collection<String> collection2 = new ArrayList<>();
collection2.add("C++");
collection2.add("JavaScript");

boolean added = collection1.addAll(collection2);
System.out.println("添加成功: " + added); // true
System.out.println(collection1); // [Java, Python, C++, JavaScript]

1.2 List 接口的添加方法 ​

add(int index, E element) ​

功能：在指定位置添加元素 参数：

  • index：要添加元素的位置
  • element：要添加的元素

示例：

java
List<String> list = new ArrayList<>();
list.add("Java");
list.add("C++");
list.add(1, "Python"); // 在索引 1 处添加 "Python"
System.out.println(list); // [Java, Python, C++]

addAll(int index, Collection<? extends E> c) ​

功能：在指定位置添加另一个集合的所有元素 参数：

  • index：要添加元素的位置
  • c：要添加的集合

示例：

java
List<String> list1 = new ArrayList<>();
list1.add("Java");
list1.add("C++");

List<String> list2 = new ArrayList<>();
list2.add("Python");
list2.add("JavaScript");

list1.addAll(1, list2); // 在索引 1 处添加 list2 的所有元素
System.out.println(list1); // [Java, Python, JavaScript, C++]

1.3 Set 接口的添加方法 ​

Set 接口继承了 Collection 接口的 add() 和 addAll() 方法，但由于 Set 不允许重复元素，所以添加重复元素时会返回 false。

示例：

java
Set<String> set = new HashSet<>();
boolean added1 = set.add("Java");
System.out.println("添加 Java 成功: " + added1); // true

boolean added2 = set.add("Java"); // 重复元素
System.out.println("添加 Java 成功: " + added2); // false

System.out.println(set); // [Java]

1.4 Map 接口的添加方法 ​

put(K key, V value) ​

功能：向 Map 中添加键值对 返回值：如果键已存在，返回旧值；否则返回 null

示例：

java
Map<String, Integer> map = new HashMap<>();
Integer oldValue = map.put("Java", 95);
System.out.println("旧值: " + oldValue); // null
System.out.println(map); // {Java=95}

oldValue = map.put("Java", 90); // 键已存在，替换值
System.out.println("旧值: " + oldValue); // 95
System.out.println(map); // {Java=90}

putAll(Map<? extends K, ? extends V> m) ​

功能：向 Map 中添加另一个 Map 的所有键值对

示例：

java
Map<String, Integer> map1 = new HashMap<>();
map1.put("Java", 95);
map1.put("Python", 85);

Map<String, Integer> map2 = new HashMap<>();
map2.put("C++", 90);
map2.put("JavaScript", 80);

map1.putAll(map2);
System.out.println(map1); // {Java=95, Python=85, C++=90, JavaScript=80}

2. 删除元素方法 ​

2.1 Collection 接口的删除方法 ​

remove(Object o) ​

功能：从集合中删除指定元素 返回值：如果元素成功删除，返回 true；否则返回 false

示例：

java
Collection<String> collection = new ArrayList<>();
collection.add("Java");
collection.add("Python");
collection.add("C++");

boolean removed = collection.remove("Python");
System.out.println("删除成功: " + removed); // true
System.out.println(collection); // [Java, C++]

removed = collection.remove("JavaScript"); // 元素不存在
System.out.println("删除成功: " + removed); // false

removeAll(Collection<?> c) ​

功能：从集合中删除另一个集合中的所有元素 返回值：如果集合发生变化，返回 true；否则返回 false

示例：

java
Collection<String> collection1 = new ArrayList<>();
collection1.add("Java");
collection1.add("Python");
collection1.add("C++");
collection1.add("JavaScript");

Collection<String> collection2 = new ArrayList<>();
collection2.add("Python");
collection2.add("C++");

boolean removed = collection1.removeAll(collection2);
System.out.println("删除成功: " + removed); // true
System.out.println(collection1); // [Java, JavaScript]

retainAll(Collection<?> c) ​

功能：保留集合中与另一个集合共有的元素，删除其他元素 返回值：如果集合发生变化，返回 true；否则返回 false

示例：

java
Collection<String> collection1 = new ArrayList<>();
collection1.add("Java");
collection1.add("Python");
collection1.add("C++");
collection1.add("JavaScript");

Collection<String> collection2 = new ArrayList<>();
collection2.add("Python");
collection2.add("C++");

boolean changed = collection1.retainAll(collection2);
System.out.println("集合发生变化: " + changed); // true
System.out.println(collection1); // [Python, C++]

clear() ​

功能：清空集合中的所有元素

示例：

java
Collection<String> collection = new ArrayList<>();
collection.add("Java");
collection.add("Python");
collection.add("C++");

System.out.println("清空前: " + collection); // [Java, Python, C++]
collection.clear();
System.out.println("清空后: " + collection); // []

2.2 List 接口的删除方法 ​

remove(int index) ​

功能：删除指定索引处的元素 返回值：被删除的元素

示例：

java
List<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
list.add("C++");

String removedElement = list.remove(1);
System.out.println("被删除的元素: " + removedElement); // Python
System.out.println(list); // [Java, C++]

2.3 Map 接口的删除方法 ​

remove(Object key) ​

功能：根据键删除键值对 返回值：被删除的键对应的值；如果键不存在，返回 null

示例：

java
Map<String, Integer> map = new HashMap<>();
map.put("Java", 95);
map.put("Python", 85);
map.put("C++", 90);

Integer removedValue = map.remove("Python");
System.out.println("被删除的值: " + removedValue); // 85
System.out.println(map); // {Java=95, C++=90}

removedValue = map.remove("JavaScript"); // 键不存在
System.out.println("被删除的值: " + removedValue); // null

clear() ​

功能：清空 Map 中的所有键值对

示例：

java
Map<String, Integer> map = new HashMap<>();
map.put("Java", 95);
map.put("Python", 85);
map.put("C++", 90);

System.out.println("清空前: " + map); // {Java=95, Python=85, C++=90}
map.clear();
System.out.println("清空后: " + map); // {}

3. 修改元素方法 ​

3.1 List 接口的修改方法 ​

set(int index, E element) ​

功能：修改指定索引处的元素 参数：

  • index：要修改的元素的位置
  • element：新元素 返回值：被替换的旧元素

示例：

java
List<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
list.add("C++");

String oldElement = list.set(1, "JavaScript");
System.out.println("被替换的元素: " + oldElement); // Python
System.out.println(list); // [Java, JavaScript, C++]

3.2 Map 接口的修改方法 ​

Map 接口的 put() 方法既可以添加新的键值对，也可以修改已存在的键值对。

示例：

java
Map<String, Integer> map = new HashMap<>();
map.put("Java", 95);
System.out.println(map); // {Java=95}

// 修改已存在的键值对
map.put("Java", 90);
System.out.println(map); // {Java=90}

4. 查询元素方法 ​

4.1 Collection 接口的查询方法 ​

size() ​

功能：获取集合的大小 返回值：集合中元素的数量

示例：

java
Collection<String> collection = new ArrayList<>();
collection.add("Java");
collection.add("Python");
collection.add("C++");

int size = collection.size();
System.out.println("集合大小: " + size); // 3

isEmpty() ​

功能：检查集合是否为空 返回值：如果集合为空，返回 true；否则返回 false

示例：

java
Collection<String> collection = new ArrayList<>();
System.out.println("集合是否为空: " + collection.isEmpty()); // true

collection.add("Java");
System.out.println("集合是否为空: " + collection.isEmpty()); // false

contains(Object o) ​

功能：检查集合是否包含指定元素 返回值：如果集合包含指定元素，返回 true；否则返回 false

示例：

java
Collection<String> collection = new ArrayList<>();
collection.add("Java");
collection.add("Python");
collection.add("C++");

boolean contains = collection.contains("Python");
System.out.println("集合是否包含 Python: " + contains); // true

contains = collection.contains("JavaScript");
System.out.println("集合是否包含 JavaScript: " + contains); // false

containsAll(Collection<?> c) ​

功能：检查集合是否包含另一个集合的所有元素 返回值：如果集合包含另一个集合的所有元素，返回 true；否则返回 false

示例：

java
Collection<String> collection1 = new ArrayList<>();
collection1.add("Java");
collection1.add("Python");
collection1.add("C++");

Collection<String> collection2 = new ArrayList<>();
collection2.add("Java");
collection2.add("Python");

boolean containsAll = collection1.containsAll(collection2);
System.out.println("collection1 是否包含 collection2 的所有元素: " + containsAll); // true

collection2.add("JavaScript");
containsAll = collection1.containsAll(collection2);
System.out.println("collection1 是否包含 collection2 的所有元素: " + containsAll); // false

4.2 List 接口的查询方法 ​

get(int index) ​

功能：获取指定索引处的元素 参数：index - 要获取的元素的位置 返回值：指定索引处的元素

示例：

java
List<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
list.add("C++");

String element = list.get(1);
System.out.println("索引 1 处的元素: " + element); // Python

indexOf(Object o) ​

功能：获取指定元素第一次出现的索引 返回值：如果元素存在，返回其第一次出现的索引；否则返回 -1

示例：

java
List<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
list.add("Java");

int index = list.indexOf("Java");
System.out.println("Java 第一次出现的索引: " + index); // 0

index = list.indexOf("JavaScript");
System.out.println("JavaScript 的索引: " + index); // -1

lastIndexOf(Object o) ​

功能：获取指定元素最后一次出现的索引 返回值：如果元素存在，返回其最后一次出现的索引；否则返回 -1

示例：

java
List<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
list.add("Java");

int index = list.lastIndexOf("Java");
System.out.println("Java 最后一次出现的索引: " + index); // 2

4.3 Map 接口的查询方法 ​

get(Object key) ​

功能：根据键获取值 返回值：键对应的值；如果键不存在，返回 null

示例：

java
Map<String, Integer> map = new HashMap<>();
map.put("Java", 95);
map.put("Python", 85);
map.put("C++", 90);

Integer value = map.get("Java");
System.out.println("Java 的值: " + value); // 95

value = map.get("JavaScript");
System.out.println("JavaScript 的值: " + value); // null

containsKey(Object key) ​

功能：检查 Map 是否包含指定的键 返回值：如果 Map 包含指定的键，返回 true；否则返回 false

示例：

java
Map<String, Integer> map = new HashMap<>();
map.put("Java", 95);
map.put("Python", 85);
map.put("C++", 90);

boolean containsKey = map.containsKey("Java");
System.out.println("Map 是否包含键 Java: " + containsKey); // true

containsKey = map.containsKey("JavaScript");
System.out.println("Map 是否包含键 JavaScript: " + containsKey); // false

containsValue(Object value) ​

功能：检查 Map 是否包含指定的值 返回值：如果 Map 包含指定的值，返回 true；否则返回 false

示例：

java
Map<String, Integer> map = new HashMap<>();
map.put("Java", 95);
map.put("Python", 85);
map.put("C++", 90);

boolean containsValue = map.containsValue(95);
System.out.println("Map 是否包含值 95: " + containsValue); // true

containsValue = map.containsValue(100);
System.out.println("Map 是否包含值 100: " + containsValue); // false

size() ​

功能：获取 Map 的大小 返回值：Map 中键值对的数量

示例：

java
Map<String, Integer> map = new HashMap<>();
map.put("Java", 95);
map.put("Python", 85);
map.put("C++", 90);

int size = map.size();
System.out.println("Map 大小: " + size); // 3

isEmpty() ​

功能：检查 Map 是否为空 返回值：如果 Map 为空，返回 true；否则返回 false

示例：

java
Map<String, Integer> map = new HashMap<>();
System.out.println("Map 是否为空: " + map.isEmpty()); // true

map.put("Java", 95);
System.out.println("Map 是否为空: " + map.isEmpty()); // false

5. 集合的遍历方法 ​

5.1 Collection 的遍历 ​

增强 for 循环 ​

java
Collection<String> collection = new ArrayList<>();
collection.add("Java");
collection.add("Python");
collection.add("C++");

for (String element : collection) {
    System.out.println(element);
}

迭代器 ​

java
Collection<String> collection = new ArrayList<>();
collection.add("Java");
collection.add("Python");
collection.add("C++");

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

forEach 方法（Java 8+） ​

java
Collection<String> collection = new ArrayList<>();
collection.add("Java");
collection.add("Python");
collection.add("C++");

collection.forEach(element -> System.out.println(element));

5.2 List 的遍历 ​

索引遍历 ​

java
List<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
list.add("C++");

for (int i = 0; i < list.size(); i++) {
    String element = list.get(i);
    System.out.println(element);
}

增强 for 循环 ​

java
List<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
list.add("C++");

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

迭代器 ​

java
List<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
list.add("C++");

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

ListIterator ​

java
List<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
list.add("C++");

ListIterator<String> listIterator = list.listIterator();
while (listIterator.hasNext()) {
    String element = listIterator.next();
    System.out.println(element);
}

// 反向遍历
while (listIterator.hasPrevious()) {
    String element = listIterator.previous();
    System.out.println(element);
}

5.3 Map 的遍历 ​

遍历键 ​

java
Map<String, Integer> map = new HashMap<>();
map.put("Java", 95);
map.put("Python", 85);
map.put("C++", 90);

for (String key : map.keySet()) {
    System.out.println("Key: " + key);
}

遍历值 ​

java
Map<String, Integer> map = new HashMap<>();
map.put("Java", 95);
map.put("Python", 85);
map.put("C++", 90);

for (int value : map.values()) {
    System.out.println("Value: " + value);
}

遍历键值对 ​

java
Map<String, Integer> map = new HashMap<>();
map.put("Java", 95);
map.put("Python", 85);
map.put("C++", 90);

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

forEach 方法（Java 8+） ​

java
Map<String, Integer> map = new HashMap<>();
map.put("Java", 95);
map.put("Python", 85);
map.put("C++", 90);

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

示例：集合常用方法综合使用 ​

示例 1：学生管理系统 ​

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

class Student {
    private String name;
    private int age;
    private String id;
    
    public Student(String name, int age, String id) {
        this.name = name;
        this.age = age;
        this.id = id;
    }
    
    public String getName() {
        return name;
    }
    
    public int getAge() {
        return age;
    }
    
    public String getId() {
        return id;
    }
    
    @Override
    public String toString() {
        return "Student{name='" + name + "', age=" + age + ", id='" + id + "'}";
    }
}

public class StudentManagementSystem {
    private List<Student> students;
    
    public StudentManagementSystem() {
        students = new ArrayList<>();
    }
    
    // 添加学生
    public void addStudent(Student student) {
        students.add(student);
        System.out.println("学生添加成功: " + student);
    }
    
    // 删除学生
    public void removeStudent(String id) {
        for (int i = 0; i < students.size(); i++) {
            if (students.get(i).getId().equals(id)) {
                Student removedStudent = students.remove(i);
                System.out.println("学生删除成功: " + removedStudent);
                return;
            }
        }
        System.out.println("未找到 ID 为 " + id + " 的学生");
    }
    
    // 修改学生信息
    public void updateStudent(String id, String newName, int newAge) {
        for (int i = 0; i < students.size(); i++) {
            Student student = students.get(i);
            if (student.getId().equals(id)) {
                Student updatedStudent = new Student(newName, newAge, id);
                students.set(i, updatedStudent);
                System.out.println("学生信息更新成功: " + updatedStudent);
                return;
            }
        }
        System.out.println("未找到 ID 为 " + id + " 的学生");
    }
    
    // 查询所有学生
    public void getAllStudents() {
        if (students.isEmpty()) {
            System.out.println("暂无学生信息");
            return;
        }
        System.out.println("所有学生信息:");
        for (Student student : students) {
            System.out.println(student);
        }
    }
    
    // 根据 ID 查询学生
    public void getStudentById(String id) {
        for (Student student : students) {
            if (student.getId().equals(id)) {
                System.out.println("查询到学生: " + student);
                return;
            }
        }
        System.out.println("未找到 ID 为 " + id + " 的学生");
    }
    
    public static void main(String[] args) {
        StudentManagementSystem sms = new StudentManagementSystem();
        
        // 添加学生
        sms.addStudent(new Student("Alice", 18, "S001"));
        sms.addStudent(new Student("Bob", 19, "S002"));
        sms.addStudent(new Student("Charlie", 20, "S003"));
        
        // 查询所有学生
        sms.getAllStudents();
        
        // 根据 ID 查询学生
        sms.getStudentById("S002");
        
        // 修改学生信息
        sms.updateStudent("S002", "David", 21);
        
        // 删除学生
        sms.removeStudent("S001");
        
        // 查询所有学生
        sms.getAllStudents();
    }
}

示例 2：单词频率统计 ​

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

public class WordFrequency {
    public static void main(String[] args) {
        String text = "Java is a programming language. Java is widely used. Java is popular.";
        
        // 分割文本为单词
        String[] words = text.toLowerCase().split("\\W+");
        
        // 统计单词频率
        Map<String, Integer> frequencyMap = new HashMap<>();
        for (String word : words) {
            if (!word.isEmpty()) {
                frequencyMap.put(word, frequencyMap.getOrDefault(word, 0) + 1);
            }
        }
        
        // 打印单词频率
        System.out.println("单词频率统计:");
        for (Map.Entry<String, Integer> entry : frequencyMap.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

常见问题 ​

1. 集合的类型安全 ​

症状：向集合中添加错误类型的元素，导致运行时异常

解决方案：使用泛型来确保类型安全

示例：

java
// 错误：没有使用泛型
List list = new ArrayList();
list.add("Java");
list.add(123); // 可以添加不同类型的元素

// 正确：使用泛型
List<String> list = new ArrayList<>();
list.add("Java");
// list.add(123); // 编译错误，类型不匹配

2. 集合的并发修改 ​

症状：在迭代过程中修改集合，导致 ConcurrentModificationException

解决方案：使用迭代器的 remove() 方法，或使用 ListIterator 进行修改

示例：

java
List<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
list.add("C++");

// 错误：在增强 for 循环中修改集合
// for (String element : list) {
//     if (element.equals("Python")) {
//         list.remove(element);
//     }
// }

// 正确：使用迭代器
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String element = iterator.next();
    if (element.equals("Python")) {
        iterator.remove(); // 使用迭代器的 remove 方法
    }
}

3. 集合的性能问题 ​

症状：集合操作速度慢

解决方案：根据具体需求选择合适的集合实现

示例：

java
// 需要频繁随机访问元素时，使用 ArrayList
List<String> list = new ArrayList<>();

// 需要频繁插入和删除操作时，使用 LinkedList
List<String> list = new LinkedList<>();

// 需要快速查找元素时，使用 HashSet
Set<String> set = new HashSet<>();

// 需要键值映射时，使用 HashMap
Map<String, Integer> map = new HashMap<>();

4. 集合的线程安全问题 ​

症状：在多线程环境中，集合操作导致数据不一致

解决方案：使用线程安全的集合或同步机制

示例：

java
// 使用线程安全的集合
List<String> list = Collections.synchronizedList(new ArrayList<>());
Set<String> set = Collections.synchronizedSet(new HashSet<>());
Map<String, Integer> map = Collections.synchronizedMap(new HashMap<>());

// 或使用 Concurrent 集合
List<String> list = new CopyOnWriteArrayList<>();
Set<String> set = new ConcurrentHashSet<>();
Map<String, Integer> map = new ConcurrentHashMap<>();

最佳实践 ​

  1. 使用泛型：使用泛型确保类型安全，避免运行时异常

  2. 选择合适的集合：根据具体需求选择合适的集合实现

  3. 注意线程安全：在多线程环境中，使用线程安全的集合或同步机制

  4. 合理使用方法：根据具体需求，选择合适的方法

  5. 避免并发修改：在迭代过程中，使用迭代器的方法进行修改

  6. 注意性能：根据操作类型选择合适的集合实现

  7. 合理使用工具类：使用 Collections 等工具类简化集合操作

总结 ​

Java 集合框架提供了丰富的方法用于操作集合中的元素，主要包括：

  1. 添加元素：add(), addAll(), put() 等
  2. 删除元素：remove(), removeAll(), retainAll(), clear() 等
  3. 修改元素：set(), put() 等
  4. 查询元素：get(), contains(), size(), isEmpty() 等
  5. 遍历元素：使用增强 for 循环、迭代器、forEach 方法等

通过合理使用这些方法，可以有效地操作集合，提高代码的效率和可维护性。

© 2026 编程马·菜鸟教程 版权所有

基于 VitePress 构建