Java 集合框架中的一些常用方法

原创

JQ实验室

发布于 2025-07-30 14:19:07

3300

文章被收录于专栏：java基础教程java基础教程

Java 集合框架提供了丰富的接口和类，支持多种集合类型（如 List、Set、Queue 和 Map）以及各种操作方法。以下是一些常用的集合框架方法，涵盖了不同类型的集合及其常见操作：

1. List 接口常用方法

List 是一个有序的集合，允许重复元素，并提供对元素的索引访问。

添加元素
- add(E e)：在列表末尾添加一个元素。
- add(int index, E element)：在指定位置插入一个元素。
删除元素
- remove(int index)：移除指定位置的元素并返回该元素。
- remove(Object o)：移除列表中第一次出现的指定元素（如果存在）。
获取元素
- get(int index)：返回指定位置的元素。
查找元素
- indexOf(Object o)：返回指定元素第一次出现的索引，如果不存在则返回 -1。
- lastIndexOf(Object o)：返回指定元素最后一次出现的索引，如果不存在则返回 -1。
替换元素
- set(int index, E element)：用指定元素替换指定位置的元素。
子列表
- subList(int fromIndex, int toIndex)：返回从 fromIndex（包含）到 toIndex（不包含）之间的子列表。

2. Set 接口常用方法

Set 是一个无序的集合，不允许重复元素。

添加元素
- add(E e)：如果此集合中尚未包含指定元素，则将其添加到集合中。返回 true 表示成功添加，false 表示集合已包含该元素。
删除元素
- remove(Object o)：移除集合中第一次出现的指定元素（如果存在）。
交集、差集等集合操作
- retainAll(Collection<?> c)：保留此集合中与指定集合共有的元素（交集）。
- removeAll(Collection<?> c)：移除此集合中包含在指定集合中的所有元素（差集）。
- addAll(Collection<? extends E> c)：将指定集合中的所有元素添加到此集合中。

3. Queue 接口常用方法

Queue 是一个先进先出（FIFO）的数据结构。

添加元素
- offer(E e)：将指定元素插入队列末尾。如果队列已满，则返回 false。
- add(E e)：将指定元素插入队列末尾。如果队列已满，则抛出 IllegalStateException。
删除元素
- poll()：检索并移除此队列的头元素，如果队列为空，则返回 null。
- remove()：检索并移除此队列的头元素，如果队列为空，则抛出 NoSuchElementException。
查看元素
- peek()：检索但不移除此队列的头元素，如果队列为空，则返回 null。
- element()：检索但不移除此队列的头元素，如果队列为空，则抛出 NoSuchElementException。

4. Deque 接口常用方法

Deque 是双端队列，可以在两端进行插入和删除操作。

添加元素
- addFirst(E e)：在队列头部插入元素。
- addLast(E e)：在队列尾部插入元素。
- offerFirst(E e)：在队列头部插入元素，如果队列已满，则返回 false。
- offerLast(E e)：在队列尾部插入元素，如果队列已满，则返回 false。
删除元素
- removeFirst()：移除并返回队列的第一个元素，如果队列为空，则抛出 NoSuchElementException。
- removeLast()：移除并返回队列的最后一个元素，如果队列为空，则抛出 NoSuchElementException。
- pollFirst()：移除并返回队列的第一个元素，如果队列为空，则返回 null。
- pollLast()：移除并返回队列的最后一个元素，如果队列为空，则返回 null。

5. Map 接口常用方法

Map 是一种键值对存储结构，不允许键重复。

添加或更新键值对
- put(K key, V value)：将指定键值对放入此映射中。如果键已经存在，则更新其值。
- putAll(Map<? extends K, ? extends V> m)：将指定映射中的所有映射关系复制到此映射中。
删除键值对
- remove(Object key)：移除指定键的映射关系（如果存在）。
获取值
- get(Object key)：返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
- getOrDefault(Object key, V defaultValue)：返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回默认值。
检查键和值
- containsKey(Object key)：如果此映射包含指定键的映射关系，则返回 true。
- containsValue(Object value)：如果此映射将一个或多个键映射到指定值，则返回 true。
遍历键和值
- keySet()：返回此映射中包含的键的 Set 视图。
- values()：返回此映射中包含的值的 Collection 视图。
- entrySet()：返回此映射中包含的映射关系的 Set 视图。

6. 集合操作方法

除了上述特定于集合类型的方法外，还有一些通用的操作方法适用于多个集合类型：

批量操作
- addAll(Collection<? extends E> c)：添加指定集合中的所有元素到此集合中。
- removeAll(Collection<?> c)：从此集合中移除包含在指定集合中的所有元素。
- retainAll(Collection<?> c)：保留此集合中与指定集合共有的元素（交集）。
- clear()：移除此集合中的所有元素。
比较操作
- equals(Object o)：比较此集合与指定对象是否相等。
- hashCode()：返回此集合的哈希码值。
大小和判断
- size()：返回此集合中的元素数。
- isEmpty()：如果此集合不包含任何元素，则返回 true。

7. 迭代器

迭代器是用于遍历集合元素的标准方式。

Iterator<E> iterator()：返回在此集合上进行迭代的迭代器。
使用迭代器遍历集合：Iterator<String> it = list.iterator(); while (it.hasNext()) { String element = it.next(); System.out.println(element); }

示例代码

下面是一个综合使用这些方法的示例代码：

import java.util.*;

public class CollectionMethodsExample {
    public static void main(String[] args) {
        // List 示例
        List<String> list = new ArrayList<>(Arrays.asList("apple", "banana", "cherry"));
        list.add("date");  // 添加元素
        System.out.println("List after adding: " + list);

        list.remove(1);  // 移除索引为1的元素
        System.out.println("List after removing at index 1: " + list);

        System.out.println("Element at index 0: " + list.get(0));  // 获取元素

        // Set 示例
        Set<String> set1 = new HashSet<>(Arrays.asList("apple", "banana", "cherry"));
        Set<String> set2 = new HashSet<>(Arrays.asList("banana", "date", "fig"));

        set1.addAll(set2);  // 合并两个集合
        System.out.println("Set1 after adding all from Set2: " + set1);

        set1.retainAll(set2);  // 保留交集
        System.out.println("Set1 after retainAll with Set2: " + set1);

        // Map 示例
        Map<String, Integer> map = new HashMap<>();
        map.put("apple", 1);
        map.put("banana", 2);
        System.out.println("Map after putting elements: " + map);

        System.out.println("Value for 'apple': " + map.get("apple"));  // 获取值

        map.remove("apple");  // 移除键值对
        System.out.println("Map after removing 'apple': " + map);

        // Queue 示例
        Queue<String> queue = new LinkedList<>(Arrays.asList("apple", "banana", "cherry"));
        System.out.println("Queue after initialization: " + queue);

        String firstElement = queue.poll();  // 检索并移除第一个元素
        System.out.println("First element polled: " + firstElement);
        System.out.println("Queue after polling: " + queue);
    }
}

输出结果

List after adding: [apple, banana, cherry, date]
List after removing at index 1: [apple, cherry, date]
Element at index 0: apple
Set1 after adding all from Set2: [banana, fig, date, apple, cherry]
Set1 after retainAll with Set2: [banana, date]
Map after putting elements: {banana=2, apple=1}
Value for 'apple': 1
Map after removing 'apple': {banana=2}
Queue after initialization: [apple, banana, cherry]
First element polled: apple
Queue after polling: [banana, cherry]