MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Java集合框架的核心接口解析

2024-08-221.6k 阅读

Java集合框架概述

Java集合框架（Java Collection Framework）是Java提供的一组用于存储和操作对象集合的类和接口。它提供了丰富的数据结构和算法，使得开发人员可以方便地处理各种类型的集合，如列表、集合、映射等。Java集合框架的核心接口包括Collection、List、Set、Queue和Map，这些接口定义了集合的基本行为和操作。

Collection接口

Collection接口是Java集合框架中最基本的接口，它定义了一组用于操作集合的方法，如添加元素、删除元素、查询元素等。所有其他集合接口都继承自Collection接口。

Collection接口的主要方法

  1. 添加元素：
    • boolean add(E e)：将指定元素添加到集合中，如果集合因调用而发生更改，则返回true。
    • boolean addAll(Collection<? extends E> c)：将指定集合中的所有元素添加到此集合中，如果此集合因调用而发生更改，则返回true。
  2. 删除元素：
    • boolean remove(Object o)：从此集合中移除指定元素的单个实例（如果存在），如果集合因调用而发生更改，则返回true。
    • boolean removeAll(Collection<?> c)：从此集合中移除指定集合中包含的所有元素，如果集合因调用而发生更改，则返回true。
    • boolean retainAll(Collection<?> c)：仅保留此集合中包含在指定集合中的元素，即从此集合中移除所有未包含在指定集合中的元素，如果集合因调用而发生更改，则返回true。
  3. 查询元素：
    • int size()：返回此集合中的元素数。
    • boolean isEmpty()：如果此集合不包含元素，则返回true。
    • boolean contains(Object o)：如果此集合包含指定元素，则返回true。
    • boolean containsAll(Collection<?> c)：如果此集合包含指定集合中的所有元素，则返回true。
    • Iterator<E> iterator()：返回在此集合中的元素上进行迭代的迭代器。

代码示例

import java.util.ArrayList;
import java.util.Collection;

public class CollectionExample {
    public static void main(String[] args) {
        Collection<String> collection = new ArrayList<>();

        // 添加元素
        collection.add("Apple");
        collection.add("Banana");
        collection.add("Cherry");

        // 输出集合大小
        System.out.println("集合大小: " + collection.size());

        // 检查集合是否包含指定元素
        System.out.println("集合是否包含Banana: " + collection.contains("Banana"));

        // 删除元素
        collection.remove("Cherry");
        System.out.println("删除Cherry后集合大小: " + collection.size());

        // 使用迭代器遍历集合
        System.out.println("遍历集合:");
        for (String element : collection) {
            System.out.println(element);
        }
    }
}

List接口

List接口继承自Collection接口，它表示一个有序的集合，允许元素重复。List接口提供了额外的方法来操作列表中的元素，如根据索引访问元素、插入元素等。

List接口的主要方法

  1. 根据索引访问元素：
    • E get(int index)：返回列表中指定位置的元素。
    • E set(int index, E element)：用指定元素替换列表中指定位置的元素，并返回被替换的元素。
  2. 插入元素：
    • void add(int index, E element)：在列表的指定位置插入指定元素。
    • boolean addAll(int index, Collection<? extends E> c)：将指定集合中的所有元素插入到此列表中的指定位置。
  3. 删除元素：
    • E remove(int index)：移除列表中指定位置的元素，并返回被移除的元素。
  4. 查找元素索引：
    • int indexOf(Object o)：返回此列表中第一次出现的指定元素的索引，如果此列表不包含该元素，则返回 -1。
    • int lastIndexOf(Object o)：返回此列表中最后一次出现的指定元素的索引，如果此列表不包含该元素，则返回 -1。

代码示例

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

public class ListExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        // 添加元素
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");

        // 根据索引访问元素
        System.out.println("索引1处的元素: " + list.get(1));

        // 插入元素
        list.add(1, "Date");
        System.out.println("插入Date后的列表: " + list);

        // 删除元素
        list.remove(2);
        System.out.println("删除索引2处元素后的列表: " + list);

        // 查找元素索引
        System.out.println("Banana的索引: " + list.indexOf("Banana"));
    }
}

Set接口

Set接口继承自Collection接口，它表示一个不包含重复元素的集合。Set接口的实现类通常会提供高效的元素查找和唯一性保证。

Set接口的特点

  1. 唯一性：Set集合中不允许有重复的元素。当试图向Set集合中添加一个已经存在的元素时，添加操作将失败（add方法返回false）。
  2. 无序性：Set集合中的元素通常是无序的，即元素的存储顺序和遍历顺序可能不一致。不过，SortedSet接口的实现类（如TreeSet）会对元素进行排序。

代码示例

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

public class SetExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();

        // 添加元素
        set.add("Apple");
        set.add("Banana");
        set.add("Apple"); // 重复元素，添加失败

        // 输出集合大小
        System.out.println("集合大小: " + set.size());

        // 遍历集合
        System.out.println("遍历集合:");
        for (String element : set) {
            System.out.println(element);
        }
    }
}

Queue接口

Queue接口继承自Collection接口，它表示一个队列，用于存储等待处理的元素。队列通常遵循先进先出（FIFO，First-In-First-Out）的原则。

Queue接口的主要方法

  1. 添加元素：
    • boolean add(E e)：将指定元素插入此队列中，如果队列已满，则抛出IllegalStateException。
    • boolean offer(E e)：将指定元素插入此队列中，如果队列已满，则返回false。
  2. 删除元素：
    • E remove()：检索并移除队列的头部元素，如果队列为空，则抛出NoSuchElementException。
    • E poll()：检索并移除队列的头部元素，如果队列为空，则返回null。
  3. 查询元素：
    • E element()：检索但不移除队列的头部元素，如果队列为空，则抛出NoSuchElementException。
    • E peek()：检索但不移除队列的头部元素，如果队列为空，则返回null。

代码示例

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

public class QueueExample {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();

        // 添加元素
        queue.add("Apple");
        queue.offer("Banana");

        // 删除元素
        System.out.println("移除的元素: " + queue.remove());
        System.out.println("移除的元素: " + queue.poll());

        // 查询元素
        System.out.println("队列头部元素: " + queue.element());
        System.out.println("队列头部元素: " + queue.peek());
    }
}

Deque接口

Deque（双端队列，Double - ended Queue）接口继承自Queue接口，它允许在队列的两端进行插入和删除操作。Deque接口提供了更灵活的队列操作方式。

Deque接口的主要方法

  1. 在两端添加元素：
    • void addFirst(E e)：将指定元素插入此双端队列的开头，如果双端队列已满，则抛出IllegalStateException。
    • void addLast(E e)：将指定元素插入此双端队列的末尾，如果双端队列已满，则抛出IllegalStateException。
    • boolean offerFirst(E e)：将指定元素插入此双端队列的开头，如果双端队列已满，则返回false。
    • boolean offerLast(E e)：将指定元素插入此双端队列的末尾，如果双端队列已满，则返回false。
  2. 在两端删除元素：
    • E removeFirst()：检索并移除此双端队列的第一个元素，如果双端队列为空，则抛出NoSuchElementException。
    • E removeLast()：检索并移除此双端队列的最后一个元素，如果双端队列为空，则抛出NoSuchElementException。
    • E pollFirst()：检索并移除此双端队列的第一个元素，如果双端队列为空，则返回null。
    • E pollLast()：检索并移除此双端队列的最后一个元素，如果双端队列为空，则返回null。
  3. 在两端查询元素：
    • E getFirst()：检索但不移除此双端队列的第一个元素，如果双端队列为空，则抛出NoSuchElementException。
    • E getLast()：检索但不移除此双端队列的最后一个元素，如果双端队列为空，则抛出NoSuchElementException。
    • E peekFirst()：检索但不移除此双端队列的第一个元素，如果双端队列为空，则返回null。
    • E peekLast()：检索但不移除此双端队列的最后一个元素，如果双端队列为空，则返回null。

代码示例

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

public class DequeExample {
    public static void main(String[] args) {
        Deque<String> deque = new ArrayDeque<>();

        // 在两端添加元素
        deque.addFirst("Apple");
        deque.addLast("Banana");

        // 在两端删除元素
        System.out.println("移除的第一个元素: " + deque.removeFirst());
        System.out.println("移除的最后一个元素: " + deque.removeLast());

        // 在两端查询元素
        deque.offerFirst("Cherry");
        deque.offerLast("Date");
        System.out.println("第一个元素: " + deque.getFirst());
        System.out.println("最后一个元素: " + deque.getLast());
    }
}

Map接口

Map接口不是继承自Collection接口，它表示一个键值对（key - value）的集合。Map中的每个键最多映射到一个值。

Map接口的主要方法

  1. 添加键值对：
    • V put(K key, V value)：将指定的值与指定的键相关联。如果该键已经存在，则替换其对应的值，并返回旧值；如果该键不存在，则返回null。
    • void putAll(Map<? extends K,? extends V> m)：将指定映射中的所有映射关系复制到此映射中。
  2. 删除键值对：
    • V remove(Object key)：如果存在一个键的映射关系，则将其从此映射中移除，并返回该键所对应的值；如果该键不存在，则返回null。
  3. 查询键值对：
    • V get(Object key)：返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回null。
    • boolean containsKey(Object key)：如果此映射包含指定键的映射关系，则返回true。
    • boolean containsValue(Object value)：如果此映射将一个或多个键映射到指定值，则返回true。
    • int size()：返回此映射中的键值对数量。
    • boolean isEmpty()：如果此映射不包含键值对映射关系，则返回true。
  4. 获取视图：
    • Set<K> keySet()：返回此映射中包含的键的Set视图。
    • Collection<V> values()：返回此映射中包含的值的Collection视图。
    • Set<Map.Entry<K, V>> entrySet()：返回此映射中包含的键值对的Set视图。

代码示例

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

public class MapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();

        // 添加键值对
        map.put("Apple", 1);
        map.put("Banana", 2);

        // 查询键值对
        System.out.println("Apple的值: " + map.get("Apple"));

        // 删除键值对
        map.remove("Banana");
        System.out.println("删除Banana后集合大小: " + map.size());

        // 获取视图
        System.out.println("键的集合: " + map.keySet());
        System.out.println("值的集合: " + map.values());
        System.out.println("键值对的集合: " + map.entrySet());
    }
}

总结

Java集合框架的核心接口Collection、List、Set、Queue、Deque和Map为开发人员提供了丰富的工具来处理各种类型的集合。Collection接口是基础，其他接口在其之上扩展了不同的功能特性。List用于有序且允许重复元素的集合，Set确保元素唯一性，Queue和Deque提供了队列相关的操作，Map则用于处理键值对数据。理解这些核心接口的特性、方法以及如何在实际编程中选择合适的接口和实现类，对于编写高效、健壮的Java程序至关重要。通过不断实践和深入理解，开发人员能够更好地利用Java集合框架的强大功能，提升编程效率和代码质量。