Java 集合常用API

1. Collection 接口常用方法

方法	描述
size()	返回集合中的元素数量
clear()	清空集合中的所有元素
isEmpty()	检查集合是否为空
add(Object e)	添加单个元素 e
remove(Object o)	删除指定元素 o
contains(Object o)	检查是否包含元素 o
addAll(Collection c)	添加集合 c 中的所有元素
containsAll(Collection c)	检查集合中是否包含集合 c 的所有元素
removeAll(Collection c)	删除集合中包含在集合 c 中的所有元素

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

public class CollectionMethodsExample {
    public static void main(String[] args) {
        // 创建一个ArrayList集合
        List<String> list = new ArrayList<>();
        
        // 添加元素到集合中
        list.add("Java"); // 使用add方法添加单个元素
        list.add("Python");

        // 获取集合的元素数量
        int size = list.size(); // 使用size方法获取集合中的元素数量
        System.out.println("集合中的元素数量: " + size);

        // 检查集合是否为空
        boolean isEmpty = list.isEmpty(); // 使用isEmpty方法检查集合是否为空
        System.out.println("集合是否为空: " + isEmpty);

        // 检查集合中是否包含指定元素
        boolean contains = list.contains("Python"); // 使用contains方法检查集合中是否包含指定元素
        System.out.println("集合中是否包含 'Python': " + contains);

        // 移除指定的元素
        list.remove("Python"); // 使用remove方法移除指定元素
        System.out.println("移除元素后的集合: " + list);

        // 创建另一个集合
        List<String> anotherList = new ArrayList<>();
        anotherList.add("Java");
        anotherList.add("C++");

        // 添加另一个集合的所有元素
        list.addAll(anotherList); // 使用addAll方法添加另一个集合中的所有元素
        System.out.println("合并后的集合: " + list);

        // 检查当前集合是否包含另一个集合的所有元素
        boolean containsAll = list.containsAll(anotherList); // 使用containsAll方法检查是否包含另一个集合的所有元素
        System.out.println("集合是否包含另一个集合的所有元素: " + containsAll);

        // 移除当前集合中包含在另一个集合中的元素
        list.removeAll(anotherList); // 使用removeAll方法移除另一个集合中的所有元素
        System.out.println("移除元素后的集合: " + list);

        // 清空集合中的所有元素
        list.clear(); // 使用clear方法清空集合
        System.out.println("清空后的集合: " + list);
    }
}

2. List 接口的常用方法

方法	描述
add(int index, Object ele)	在索引 index 处添加元素 ele
addAll(int index, Collection eles)	从索引 index 开始，添加 eles 集合的所有元素
get(int index)	获取索引 index 处的元素
indexOf(Object obj)	查找 obj 的首次出现位置
lastIndexOf(Object obj)	查找 obj 的最后出现位置
remove(int index)	移除索引 index 处的元素
set(int index, Object ele)	将索引 index 处的元素替换为 ele
subList(int fromIndex, int toIndex)	获取从 fromIndex 到 toIndex 的子列表

List 接口的主要实现类包括：

• ArrayList：动态数组，支持快速随机访问，常用于顺序读取和追加元素的场景。
• LinkedList：双向链表，适合频繁插入和删除操作，支持队列和栈的操作。
• Vector：线程安全的动态数组实现，常用于需要同步的场景。
• Stack：继承自 Vector，实现了栈的 LIFO（后进先出）操作。

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

public class ListMethodsExample {
    public static void main(String[] args) {
        // 创建一个ArrayList集合
        List<String> list = new ArrayList<>();
        list.add("Java");
        list.add("Python");
        list.add("C++");

        // 在索引1处添加元素
        list.add(1, "JavaScript"); // 使用add(int index, Object ele)方法在指定位置添加元素
        System.out.println("在索引1处添加元素后的集合: " + list);

        // 从索引2处开始添加另一个集合的元素
        List<String> anotherList = new ArrayList<>();
        anotherList.add("Go");
        anotherList.add("Rust");
        list.addAll(2, anotherList); // 使用addAll(int index, Collection eles)方法从指定位置开始添加元素
        System.out.println("添加另一个集合的元素后的集合: " + list);

        // 获取索引2处的元素
        String element = list.get(2); // 使用get(int index)方法获取指定位置的元素
        System.out.println("索引2处的元素: " + element);

        // 查找元素首次出现的位置
        int index = list.indexOf("Java"); // 使用indexOf(Object obj)方法查找元素首次出现的位置
        System.out.println("元素 'Java' 的首次出现位置: " + index);

        // 查找元素最后出现的位置
        int lastIndex = list.lastIndexOf("Rust"); // 使用lastIndexOf(Object obj)方法查找元素最后出现的位置
        System.out.println("元素 'Rust' 的最后出现位置: " + lastIndex);

        // 移除索引3处的元素
        list.remove(3); // 使用remove(int index)方法移除指定位置的元素
        System.out.println("移除索引3处的元素后的集合: " + list);

        // 替换索引1处的元素
        list.set(1, "TypeScript"); // 使用set(int index, Object ele)方法替换指定位置的元素
        System.out.println("替换索引1处的元素后的集合: " + list);

        // 获取子列表
        List<String> subList = list.subList(1, 3); // 使用subList(int fromIndex, int toIndex)方法获取子列表
        System.out.println("索引1到索引3之间的子列表: " + subList);
    }
}

3. Set 接口的常用方法

方法	描述
boolean add (E e)	添加元素，但重复元素不会被添加成功
void clear ()	清空集合
boolean contains (Object o)	判断集合中是否包含指定元素
Iterator<E> iterator ()	返回迭代器
boolean remove (Object o)	删除集合中的指定元素
int size()	返回集合中的元素个数
boolean isEmpty()	判断集合是否为空，空返回 true，否则返回 false
Object[] toArray()	将集合中的元素转换为数组返回
boolean containsAll(Collection<?> c)	判断集合中是否包含另一个集合的所有元素
boolean addAll(Collection<? extends E> c)	将另一个集合的元素添加到当前集合中，可以达到去重效果

Set 接口的主要实现类包括：

• HashSet：无序集合，基于哈希表实现，不允许重复元素。
• LinkedHashSet：有序集合，基于哈希表和链表实现，保留插入顺序。
• TreeSet：有序集合，基于红黑树实现，元素按自然顺序排序。

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class SetMethodsExample {
    public static void main(String[] args) {
        // 创建一个HashSet集合
        Set<String> set = new HashSet<>();
        
        // 添加元素到集合中
        set.add("Java"); // 使用add方法添加元素
        set.add("Python");
        set.add("C++");

        // 使用迭代器遍历集合
        Iterator<String> iterator = set.iterator(); // 使用iterator方法获取迭代器
        while (iterator.hasNext()) {
            String element = iterator.next();
            System.out.println("遍历元素: " + element);
        }

        // 判断集合中是否包含指定元素
        boolean contains = set.contains("Python"); // 使用contains方法判断集合中是否包含指定元素
        System.out.println("集合中是否包含 'Python': " + contains);

        // 移除指定元素
        set.remove("C++"); // 使用remove方法移除指定元素
        System.out.println("移除元素后的集合: " + set);

        // 获取集合的元素个数
        int size = set.size(); // 使用size方法获取集合中的元素数量
        System.out.println("集合中的元素个数: " + size);

        // 检查集合是否为空
        boolean isEmpty = set.isEmpty(); // 使用isEmpty方法检查集合是否为空
        System.out.println("集合是否为空: "

 + isEmpty);

        // 将集合转换为数组
        Object[] array = set.toArray(); // 使用toArray方法将集合转换为数组
        System.out.println("集合转换为数组后的结果: ");
        for (Object obj : array) {
            System.out.println(obj);
        }

        // 清空集合中的所有元素
        set.clear(); // 使用clear方法清空集合
        System.out.println("清空后的集合: " + set);
    }
}

4. Queue 接口的常用方法

普通队列操作

操作	抛出异常方法	返回特殊值方法
入队列	add(e)	offer(e)
出队列	remove()	poll()
查看队首元素	element()	peek()

Queue 接口的主要实现类包括：

• LinkedList：双向链表实现，既可以作为 Queue，也可以作为 Deque 使用。
• PriorityQueue：优先队列，基于堆实现，元素按优先级排序。
• ArrayDeque：双端队列，支持高效的插入和删除操作，既可以作为栈，也可以作为队列使用。

import java.util.LinkedList;
import java.util.Queue;

public class QueueMethodsExample {
    public static void main(String[] args) {
        // 创建一个LinkedList作为Queue的实现
        Queue<String> queue = new LinkedList<>();

        // 入队列操作
        queue.offer("Java"); // 使用offer方法入队列
        queue.offer("Python");

        // 查看队首元素
        String head = queue.peek(); // 使用peek方法查看队首元素
        System.out.println("队首元素: " + head);

        // 出队列操作
        String removedElement = queue.poll(); // 使用poll方法出队列
        System.out.println("出队列的元素: " + removedElement);

        // 查看队首元素
        head = queue.peek();
        System.out.println("新的队首元素: " + head);

        // 使用add和remove抛出异常的操作
        queue.add("C++"); // 使用add方法入队列，若队列满则抛出异常
        queue.remove(); // 使用remove方法出队列，若队列为空则抛出异常
        System.out.println("最终队列状态: " + queue);
    }
}

5. Deque 接口的常用方法

双端队列操作

操作区域	操作	抛出异常方法	返回特殊值方法
头部入队列	addFirst(e)	offerFirst(e)
尾部入队列	addLast(e)	offerLast(e)
头部出队列	removeFirst()	pollFirst()
尾部出队列	removeLast()	pollLast()
查看头部元素	getFirst()	peekFirst()
查看尾部元素	getLast()	peekLast()

Deque 接口的主要实现类包括：

• LinkedList：双向链表实现，支持在头部和尾部进行高效的插入和删除操作。
• ArrayDeque：基于循环数组实现的双端队列，适合作为栈或队列使用。

import java.util.ArrayDeque;
import java.util.Deque;

public class DequeMethodsExample {
    public static void main(String[] args) {
        // 创建一个ArrayDeque作为Deque的实现
        Deque<String> deque = new ArrayDeque<>();

        // 头部入队列操作
        deque.offerFirst("Java"); // 使用offerFirst方法在头部入队列
        deque.offerFirst("Python");

        // 查看头部元素
        String head = deque.peekFirst(); // 使用peekFirst方法查看头部元素
        System.out.println("头部元素: " + head);

        // 尾部入队列操作
        deque.offerLast("C++"); // 使用offerLast方法在尾部入队列
        System.out.println("Deque状态: " + deque);

        // 头部出队列操作
        String removedElement = deque.pollFirst(); // 使用pollFirst方法在头部出队列
        System.out.println("头部出队列的元素: " + removedElement);

        // 查看尾部元素
        String tail = deque.peekLast(); // 使用peekLast方法查看尾部元素
        System.out.println("尾部元素: " + tail);

        // 尾部出队列操作
        deque.pollLast(); // 使用pollLast方法在尾部出队列
        System.out.println("最终Deque状态: " + deque);
    }
}

6. PriorityQueue 的常用方法

优先级队列操作

方法	描述
boolean offer(E e)	插入元素 e，返回是否插入成功，如果 e 为 null 则抛出异常
E peek()	获取堆顶元素，如果队列为空，返回 null
E poll()	删除并返回堆顶元素，如果队列为空，返回 null
int size()	获取有效元素个数
void clear()	清空队列
boolean isEmpty()	判断队列是否为空

import java.util.PriorityQueue;

public class PriorityQueueMethodsExample {
    public static void main(String[] args) {
        // 创建一个PriorityQueue
        PriorityQueue<Integer> pq = new PriorityQueue<>();

        // 插入元素到队列
        pq.offer(10); // 使用offer方法插入元素
        pq.offer(20);
        pq.offer(15);

        // 获取堆顶元素
        int top = pq.peek(); // 使用peek方法获取堆顶元素
        System.out.println("堆顶元素: " + top);

        // 删除并获取堆顶元素
        int removed = pq.poll(); // 使用poll方法删除并返回堆顶元素
        System.out.println("删除堆顶元素: " + removed);

        // 查看队列大小
        int size = pq.size(); // 使用size方法获取队列元素数量
        System.out.println("队列大小: " + size);

        // 判断队列是否为空
        boolean isEmpty = pq.isEmpty(); // 使用isEmpty方法判断队列是否为空
        System.out.println("队列是否为空: " + isEmpty);

        // 清空队列
        pq.clear(); // 使用clear方法清空队列
        System.out.println("清空后的队列: " + pq);
    }
}

6. Map 接口和常用方法

方法	描述
V get(Object key)	返回指定 key 对应的 value
V getOrDefault(Object key, V defaultValue)	返回指定 key 对应的 value，如果不存在则返回默认值
V put(K key, V value)	设置指定 key 对应的 value
V remove(Object key)	删除指定 key 的映射关系
Set<K> keySet()	返回所有 key 的不重复集合
Collection<V> values()	返回所有 value 的可重复集合
Set<Map.Entry<K, V>> entrySet()	返回所有的 key-value 映射关系集合
boolean containsKey(Object key)	判断映射中是否包含指定 key
boolean containsValue(Object value)	判断映射中是否包含指定 value
boolean isEmpty()	判断映射是否为空
int size()	获取映射中元素的数量
void clear()	清空映射中的所有元素

Map 接口的主要实现类包括：

1. HashMap：无序键值对映射，基于哈希表实现，允许 null 键和值。
2. LinkedHashMap：有序键值对映射，基于哈希表和链表实现，保留插入顺序。
3. TreeMap：有序键值对映射，基于红黑树实现，按自然顺序或自定义比较器排序。
4. Hashtable：线程安全的键值对映射，不允许 null 键和值。
5. ConcurrentHashMap：线程安全的高效映射，支持并发操作。

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

public class MapMethodsExample {
    public static void main(String[] args) {
        // 创建一个HashMap
        Map<String, Integer> map = new HashMap<>();

        // 添加键值对到映射中
        map.put("Java", 1); // 使用put方法添加键值对
        map.put("Python", 2);
        map.put("C++", 3);

        // 获取指定键对应的值
        int value = map.get("Python"); // 使用get方法获取指定键的值
        System.out.println("键 'Python' 的值: " + value);

        // 获取不存在键的值，指定默认值
        int defaultValue = map.getOrDefault("JavaScript", -1); // 使用getOrDefault方法获取默认值
        System.out.println("键 'JavaScript' 的值: " + defaultValue);

        // 判断映射中是否包含指定键
        boolean containsKey = map.containsKey("Java"); // 使用containsKey方法判断是否包含指定键
        System.out.println("映射中是否包含 'Java': " + containsKey);

        // 判断映射中是否包含指定值
        boolean containsValue = map.containsValue(2); // 使用containsValue方法判断是否包含指定值
        System.out.println("映射中是否包含值 2: " + containsValue);

        // 获取映射中所有键的集合
        Set<String> keys = map.keySet(); // 使用keySet方法获取所有键
        System.out.println("映射中的键: " + keys);

        // 获取映射中所有值的集合


        System.out.println("映射中的值: " + map.values()); // 使用values方法获取所有值

        // 获取映射中所有键值对的集合
        for (Map.Entry<String, Integer> entry : map.entrySet()) { // 使用entrySet方法获取所有键值对
            System.out.println("键: " + entry.getKey() + ", 值: " + entry.getValue());
        }

        // 删除指定键的映射关系
        map.remove("C++"); // 使用remove方法删除键值对
        System.out.println("移除键 'C++' 后的映射: " + map);

        // 获取映射的大小
        int size = map.size(); // 使用size方法获取映射的元素数量
        System.out.println("映射的大小: " + size);

        // 判断映射是否为空
        boolean isEmpty = map.isEmpty(); // 使用isEmpty方法判断映射是否为空
        System.out.println("映射是否为空: " + isEmpty);

        // 清空映射
        map.clear(); // 使用clear方法清空映射
        System.out.println("清空后的映射: " + map);
    }
}