当前位置：首页 > article >正文

Java基础终章篇（10）容器类与集合操作

article 2024/11/22 9:06:28

1.前言

2.容器类与集合操作

2.2.1层次结构

2.2collection框架

2.2.1List接口及其实现类

ArrayList：

LinkedList：

2.2.2Set接口及其实现类

HashSet：

LinkedHashSet：

treeset：

2.2.3Queue接口及其实现类

PriorityQueue

2.3Map接口

HashMap

TreeMap

3.小结

1.前言

哈喽大家好吖，安排到这里该讲述Java中非常重要的容器类和集合操作嘞，Java基础的学习很快接近了尾声，往后博主将继续学习JavaEE，MySQL以及spring的相关内容，本文将以凝练的语言与方式将容器类和集合操作总结在一起，奉上正文~

2.容器类与集合操作

Java容器类主要是指java.util包中的类，它们用于存储数据集合。这些容器类可以分为两大类：容器类（Collections）和工具类（Tools）。容器类主要包括List、Set、Map三种接口及其实现类，而工具类则包括Collections和Arrays等。

2.2.1层次结构

1. 顶层接口

Iterable：这是集合框架的顶层接口，Collection接口继承了Iterable。实现了Iterable接口的类可以使用增强型for循环（for-each）。

2. Collection接口层

Collection：是所有集合类的根接口，定义了集合的基本操作方法，比如add()、remove()、size()等。
主要子接口包括：List、Set和Queue。

3. Collection接口的子接口

List：有序的集合，允许重复元素。List接口定义了根据索引操作元素的方法。
主要实现类：ArrayList、LinkedList、Vector。
Set：不允许重复元素的集合，主要用于存储唯一值。Set接口不保证元素的顺序。
主要实现类：HashSet、LinkedHashSet、TreeSet。
Queue：先进先出的集合接口，常用于处理队列和任务。
主要实现类：LinkedList（也实现了List接口）、PriorityQueue。
Deque：双端队列接口，支持从两端插入和移除元素。
主要实现类：ArrayDeque、LinkedList。

4. Map接口层

Map：键值对集合接口，存储键值映射关系，键不能重复。
主要实现类：HashMap、TreeMap、LinkedHashMap、Hashtable。

下面用一张图来更加形象的展现出它们之间的层级关系：
                 ┌─────────────────────┐
                 │     Iterable        │
                 └─────────────────────┘
                            │
                            │
                            │
                 ┌─────────────────────┐
                 │     Collection      │
                 └─────────────────────┘
                  /           |             \
                 /            |              \
                /             |               \
       ┌─────────────┐ ┌─────────────┐ ┌──────────────┐
       │    List     │ │     Set     │ │    Queue     │
       └─────────────┘ └─────────────┘ └──────────────┘
            │               │                  │
  ┌───────────────┐ ┌─────────────┐  ┌──────────────┐
  │ ArrayList     │ │  HashSet    │  │  LinkedList  │
  │ LinkedList    │ │LinkedHashSet│  │ PriorityQueue│
  │ Vector        │ │  TreeSet    │  └──────────────┘
  └───────────────┘ └─────────────┘
                
                 ┌─────────────────────┐
                 │        Map          │
                 └─────────────────────┘
                        /          \
                       /            \
           ┌────────────────┐ ┌─────────────┐
           │    HashMap     │ │  TreeMap    │
           │ LinkedHashMap  │ └─────────────┘
           │   Hashtable    │
           └────────────────┘

2.2collection框架

Collection接口：所有集合类的根接口，定义了一些基本操作方法，如add()、remove()、size()等。Collection接口有三个子接口：List、Set和Queue。

我们接下来主要讲解的是List、Set和Queue子接口以及实现的类：

2.2.1List接口及其实现类

ArrayList：

基本原理：

数组存储：ArrayList 使用一个数组来存储数据，初始容量默认为 10。数组容量不足时，它会创建一个新的数组（通常是当前数组容量的 1.5 倍），并将现有元素复制到新数组中。
扩容机制：当 ArrayList 的容量不足以容纳新元素时，会进行扩容操作。扩容过程通过创建一个更大的数组（一般是原来容量的 1.5 倍）并复制旧数据来完成。

常用的方法：

boolean add(E e)：将元素添加到列表末尾。
void add(int index, E element)：在指定位置插入元素。
E get(int index)：返回指定位置的元素。
E set(int index, E element)：替换指定位置的元素。
E remove(int index)：删除指定位置的元素。
boolean remove(Object o)：删除列表中首次出现的指定元素。
int size()：返回列表中元素的个数。
boolean isEmpty()：检查列表是否为空。
boolean contains(Object o)：检查列表是否包含指定元素。
int indexOf(Object o)：返回列表中第一次出现的指定元素的索引。
int lastIndexOf(Object o)：返回列表中最后一次出现的指定元素的索引。
void clear()：清空列表中的所有元素。

代码示例：
public static void main(String[] args) {
        ArrayList <String> student = new ArrayList<>();

        System.out.println(student.add("张三"));//返回值为布尔类型
        student.add(0,"李四");
        System.out.println("列表中元素量:" + student.size());//2

        System.out.println(student.indexOf("李四"));//0
        System.out.println(student.lastIndexOf("张三"));//1
        System.out.println(student.get(0));//李四
        System.out.println(student.get(1));//张三

        student.remove(0);
        System.out.println(student.get(0));//张三
        System.out.println(student.isEmpty());//false

        student.clear();
        System.out.println("列表中元素量:" + student.size());//0
        System.out.println(student.isEmpty());//true
    }
优点

随机访问快：ArrayList 支持通过索引快速访问元素，时间复杂度为 O(1)。
动态扩展：ArrayList 可以根据需要动态扩展，增加了其灵活性。

缺点

插入和删除效率低：在中间位置插入或删除元素时，需要移动后面的元素，时间复杂度为 O(n)。
占用额外内存：为了实现动态扩展，ArrayList 会预留一些空间，这些空闲空间在不使用时会占用内存。

LinkedList：

基本原理：

节点存储结构：LinkedList 的每个元素都存储在一个称为节点（Node）的对象中。每个节点包含当前元素、前驱节点和后继节点的引用。结构如下：
头尾节点引用：LinkedList 使用 first 和 last 引用分别指向链表的头节点和尾节点。

常用方法：

由于其既继承了List接口，又继承了Deque的接口，作为一个双向链表拥有更多的方法

List接口中的方法

add(E e)：将元素添加到链表的末尾。
add(int index, E element)：在指定位置插入元素。
get(int index)：获取指定位置的元素。
set(int index, E element)：修改指定位置的元素。
remove(int index)：删除指定位置的元素。
size()：返回链表中元素的数量。

Deque接口中的方法

addFirst(E e)：在链表的头部添加元素。
addLast(E e)：在链表的尾部添加元素。
getFirst()：返回链表的第一个元素。
getLast()：返回链表的最后一个元素。
removeFirst()：删除并返回链表的第一个元素。
removeLast()：删除并返回链表的最后一个元素。
offer(E e)：将元素添加到队列尾部（等效于 addLast）。
offerFirst(E e)：将元素添加到队列头部。
offerLast(E e)：将元素添加到队列尾部。
poll()：删除并返回链表的第一个元素（等效于 removeFirst）。
pollFirst()：删除并返回链表的第一个元素。
pollLast()：删除并返回链表的最后一个元素。

Queue接口中的方法

peek()：返回第一个元素，但不删除。如果链表为空，返回 null。
poll()：删除并返回第一个元素。如果链表为空，返回 null。

代码示例：
public static void main(String[] args) {
        LinkedList <String> list = new LinkedList<>();

        //List接口中的个方法
        list.add("张三");//在尾部添加
        list.add(1,"李四");
        System.out.println(list.get(0));//张三
        list.set(0,"王五");
        System.out.println(list.get(0));//王五
        System.out.println(list.size());//2

        //Deque接口中的方法
        list.addFirst("孙六");
        list.offerLast("孔七");
        System.out.println(list.getFirst());//孙六
        System.out.println(list.getLast());//孔七

        //Queue接口中的个方法
        System.out.println(list.peek());//孙六
        System.out.println(list.poll());//孙六
        System.out.println(list.poll());//王五
    }
优点

插入和删除效率高：在链表的头部、尾部或中间位置插入和删除元素的效率较高，适合频繁插入和删除操作的场景。
实现双端队列：LinkedList 同时实现了 Deque 接口，支持从两端插入和删除元素。

缺点

随机访问效率低：访问链表中的某个元素需要遍历整个链表，因此随机访问效率较低。
内存消耗大：链表的每个节点都需要存储前后引用，增加了内存开销。

这里对比一下ArrayList和LinkedList的特点，以便有更深的理解：

特性	LinkedList	ArrayList
实现结构	双向链表	动态数组
随机访问	慢 (O(n))	快 (O(1))
插入/删除	头尾插入删除快 (O(1))，中间插入删除慢	中间插入删除慢（O(n)），尾部快 (O(1))
内存开销	大，每个节点需额外存储两个引用	较小，主要存储元素本身
适合的使用场景	频繁插入/删除操作	频繁访问操作，较少插入/删除

2.2.2Set接口及其实现类

Set 接口是 Java 集合框架中的一个接口，表示一个不允许包含重复元素的集合。它继承了 Collection 接口，主要用于存储唯一的元素。Set 的实现类主要包括 HashSet、LinkedHashSet 和 TreeSet，每种实现类的特性和应用场景各不相同。

`HashSet：`

基本原理：

HashSet 底层依赖 HashMap 实现，所有元素都作为 HashMap 的键值对中的键存储，值统一使用一个固定的占位对象（private static final Object PRESENT = new Object();）。
由于 HashMap 的键是唯一的，因此 HashSet 也只能存储唯一元素。

常用方法：

boolean add(E e)：添加元素 e 到集合中，若已存在返回 false。
boolean remove(Object o)：移除指定元素 o，成功移除返回 true。
boolean contains(Object o)：检查集合是否包含指定元素 o，存在返回 true。
int size()：返回集合中的元素数量。
boolean isEmpty()：检查集合是否为空，空则返回 true。
void clear()：清空集合中的所有元素。
Iterator<E> iterator()：返回一个用于遍历集合的迭代器。
Object[] toArray()：将集合中的所有元素以数组形式返回。
<T> T[] toArray(T[] a)：将集合中的元素以指定类型的数组返回。
boolean containsAll(Collection<?> c)：检查集合是否包含指定集合 c 中的所有元素。

特点：

无序性：HashSet 中的元素没有特定顺序，因为其内部基于哈希表。
唯一性：HashSet 中不允许有重复元素。如果试图添加重复元素，添加操作会失败。
允许空值：HashSet 允许最多有一个 null 元素。

代码示例：
public static void main(String[] args) {
        String str1 = new String("Hello");
        String str2 = new String("Hello");
        System.out.println(str1 == str2);
        System.out.println(str1.equals(str2));

        HashSet<String> set = new HashSet<>();
        set.add(str1);
        System.out.println(set.contains("Hello"));
        System.out.println(set.contains(str2));
        set.add(str2);
        System.out.println(set.size());
        set.remove(str1);
        set.clear();
        System.out.println(set.isEmpty());
    }

`LinkedHashSet：`

基本原理：

LinkedHashSet 是 Java 集合框架中基于哈希表和双向链表实现的一个集合类，它是 HashSet 的子类，具有以下特点：

保证了 插入顺序（相较于 HashSet 的无序性）。
继承了 HashSet 的所有功能，同时提供了更高的遍历顺序可控性。
适用于需要高效去重且维持插入顺序的场景。

常用方法：

由于是HashSet子类，大部分常用的方法一致，这里不过多列举

特点：

顺序性：LinkedHashSet 内部维护了一个双向链表，用于记录元素的插入顺序，因此其迭代顺序与插入顺序一致。
唯一性：与 HashSet 类似，LinkedHashSet 不允许存储重复元素。

代码演示：
public static void main(String[] args) {
        LinkedHashSet<Integer> set = new LinkedHashSet<>();
        set.add(2);
        set.add(3);
        set.add(1);
        System.out.println(set);
        for (Integer x:set){
            System.out.print(x + " ");
        }
        System.out.println();
        System.out.println(set.isEmpty());
        System.out.println(set.size());
        set.remove(2);
        System.out.println(set);
    }