JAVA集合面试分享一：JAVA集合框架详解之List-阶段（一）

之乎者也·

已于 2023-12-02 16:56:57 修改

阅读量32

点赞数

分类专栏： Java 集合内容分享文章标签： java 开发语言

于 2023-11-04 16:15:21 首次发布

本文链接：https://blog.csdn.net/qq_45038038/article/details/134216854

版权

Java 集合内容分享专栏收录该内容

17 篇文章 0 订阅

订阅专栏

1、Java LinkedList 的实现方式

2、Java LinkedList 的内部结构

3、Java LinkedList 的常用方法

五、CopyOnWriteArrayList

工作原理

使用场景

先给大家看一张图，有个大致了解：

再来看下集合类的继承关系：

今天先讲一下List下的有哪些实现：

一、ArrayList

是数组实现的队列，它是一个动态数组；它也不是线程安全的，只适用于单线程。

原理

ArrayList使用动态数组实现，它内部维护一个Object[]数组来存储元素。这种实现方式使得ArrayList在随机访问时效率更高，可以通过索引直接访问元素，时间复杂度为O(1)。LinkedList使用双向链表实现，每个节点都包含前后指针以及存储的元素。这种实现方式使得LinkedList在插入和删除操作上更加高效，对于任意位置的插入和删除操作只需修改相邻节点的指针，时间复杂度为O(1)。

private transient Object[] elementData;  
private int size;

ArryList初始化时，elementData数组大小默认为10；

每次add（）时，先调用ensureCapacity（）保证数组不会溢出，如果此时已满，会扩展为数组length的1.5倍+1，然后用array.copy的方法，将原数组拷贝到新的数组中；

ArrayList线程不安全，Vector方法是同步的，线程安全；

ArrayList 可以使用三方方式遍历：for循环+下标、foreach、使用迭代器

ArrayList底层是使用数组来存储元素的，由于其底层是一段连续空间，当在 ArrayList 任意位置插入或者删除元素时，就需要将后序元素整体往前或者往后搬移，时间复杂度为 O(n) ，效率比较低，因此 ArrayList 不适合做任意位置插入和删除比较多的场景。而且，在扩容之后，可能会带来空间的浪费。 ArrayList适合在给定了下标位置的情况下进行查找元素，此时时间复杂度可以达到O(1)。因此： java 集合中又引入了 LinkedList ，即链表结构。

二、LinkedList

是双向链表实现的双端队列；它不是线程安全的，只适用于单线程。

原理介绍

链表（LinkedList）是一种常见的基础数据结构，是一种线性表，但是不会按线性的顺序存储数据，而是在每一个节点里面存储下一节点的地址。

链表可以分为单项列表和双向链表，单向链表包含两个值：当前节点的值和下一节点的链接。一个双向链表有三个整数值: 数值、向后的节点链接、向前的节点链接。下图就是介绍单向链表和双向链表。

1、Java LinkedList 的实现方式

Java LinkedList 的实现方式是基于双向链表的动态列表，它在内部维护了一个节点类 Node，用于存储列表中的元素。每个节点都包含一个前驱指针 prev 和一个后继指针 next，用于指向前一个节点和后一个节点。在初始化时，LinkedList 会创建一个空的链表，即头尾节点都为 null。在添加元素时，LinkedList 会创建一个新的节点，并将它插入到链表的末尾。在删除元素时，LinkedList 会将指定节点的前驱指针和后继指针分别指向彼此，从而完成节点的删除。

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
    // 链表的头节点
    transient Node<E> first;

    // 链表的尾节点
    transient Node<E> last;

    // 链表中元素的数量
    transient int size;

    // 构造函数
    public LinkedList() {
    }

    // 添加元素到链表末尾
    public boolean add(E e) {
        linkLast(e);
        return true;
    }

    // 添加元素到链表指定位置
    public void add(int index, E element) {
        checkPositionIndex(index);

        if (index == size)
            linkLast(element);
        else
            linkBefore(element, node(index));
    }

    // 删除指定位置的元素
    public E remove(int index) {
        checkElementIndex(index);
        return unlink(node(index));
    }

    // 链接节点到链表末尾
    void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
    }

    // 链接节点到指定位置的前面
    void linkBefore(E e, Node<E> succ) {
        final Node<E> pred = succ.prev;
        final Node<E> newNode = new Node<>(pred, e, succ);
        succ.prev = newNode;
        if (pred == null)
            first = newNode;
        else
            pred.next = newNode;
        size++;
    }

    // 删除指定节点
    E unlink(Node<E> x) {
        final E element = x.item;
        final Node<E> next = x.next;
        final Node<E> prev = x.prev;

        if (prev == null) {
            first = next;
        } else {
            prev.next = next;
            x.prev = null;
        }

        if (next == null) {
            last = prev;
        } else {
            next.prev = prev;
            x.next = null;
        }

        x.item = null;
        size--;
        return element;
    }
}

2、Java LinkedList 的内部结构

Java LinkedList 内部维护了一个 Node 类型的双向链表，用于存储列表中的元素。每个节点都包含一个前驱指针 prev 和一个后继指针 next，用于指向前一个节点和后一个节点。在添加元素时，LinkedList 会创建一个新的节点，并将它插入到链表的末尾。在删除元素时，LinkedList 会将指定节点的前驱指针和后继指针分别指向彼此，从而完成节点的删除。

private static class Node<E> {
    E item;
    Node<E> next;
    Node<E> prev;

    Node(Node<E> prev, E element, Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

3、Java LinkedList 的常用方法

Java LinkedList 提供了许多常用方法，如添加元素、删除元素、获取元素等。下面将介绍其中的几个重要的方法。

add(E e)：添加元素
add() 方法用于在列表的末尾添加元素。该方法会创建一个新的节点，并将它插入到链表的末尾。该方法返回一个 boolean 类型的值，表示是否添加成功。

public boolean add(E e) {
    linkLast(e);
    return true;
}

add(int index, E element)：添加元素到指定位置
add() 方法还提供了一个可以将元素添加到指定位置的重载版本。该方法会在指定位置前插入一个新的节点，并将该节点的前驱指针和后继指针分别指向前一个节点和后一个节点。

public void add(int index, E element) {
    checkPositionIndex(index);

    if (index == size)
        linkLast(element);
    else
        linkBefore(element, node(index));
}

remove(int index)：删除指定位置的元素
remove() 方法用于删除指定位置的元素。该方法会将指定节点的前驱指针和后继指针分别指向彼此，从而完成节点的删除。该方法返回被删除的元素。

public E remove(int index) {
    checkElementIndex(index);
    return unlink(node(index));
}

get(int index)：获取指定位置的元素
get() 方法用于获取指定位置的元素。该方法会遍历链表，找到指定位置的节点，并返回该节点的元素。

public E get(int index) {
    checkElementIndex(index);
    return node(index).item;
}

三、Vector

是数组实现的矢量队列，它也一个动态数组；不过和ArrayList不同的是，Vector是线程安全的，它支持并发。

原理

Vector 是矢量队列，它是JDK1.0版本添加的类。继承于AbstractList，实现了List, RandomAccess, Cloneable这些接口。
Vector 继承了AbstractList，实现了List；所以，它是一个队列，支持相关的添加、删除、修改、遍历等功能。
Vector 实现了RandmoAccess接口，即提供了随机访问功能。RandmoAccess是java中用来被List实现，为List提供快速访问功能的。在Vector中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访问。
Vector 实现了Cloneable接口，即实现clone()函数。它能被克隆。

1、Vector实际上是通过一个数组去保存数据的。当我们构造Vecotr时；若使用默认构造函数，则Vector的默认容量大小是10。
2、当Vector容量不足以容纳全部元素时，Vector的容量会增加。若容量增加系数 >0，则将容量的值增加“容量增加系数”；否则，将容量大小增加一倍。
3、Vector的克隆函数，即是将全部元素克隆到一个数组中。

Vector遍历方式

Vector支持4种遍历方式。建议使用下面的第二种去遍历Vector，因为效率问题。

第一种，通过迭代器遍历。即通过Iterator去遍历。

Iterator<String> it = vec.iterator();


while(it.hasNext()) {

System.out.println(it.next());

}

第二种，随机访问，通过索引值去遍历。
由于Vector实现了RandomAccess接口，它支持通过索引值去随机访问元素。

Integer value = null;

int size = vec.size();

for (int i=0; i<size; i++) {

value = (Integer)vec.get(i);

}

第三种，另一种for循环。如下：

Integer value = null;

for (Integer integ:vec) {

value = integ;

}

(04) 第四种，Enumeration遍历。如下：

Integer value = null;

Enumeration enu = vec.elements();

while (enu.hasMoreElements()) {

value = (Integer)enu.nextElement();

}

四、Stack

是Vector实现的栈；和Vector一样，它也是线程安全的。

原理

只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(FirstIn First Out) 入队列：进行插入操作的一端称为队尾（Tail/Rear）出队列：进行删除操作的一端称为队头（Head/Front）。

栈的几种主要基本操作：

void push(int data)：入栈（将数据data插入到栈中）
int pop()：出栈（删除并返回最后一个插入栈的元素）
int top()：返回最后一个插入栈的元素，但不删除
int size()：返回存储在栈中的元素个数
boolean isEmpty()：返回栈是否是空栈
boolean isFull()：返回是否是满栈
void Clear()：清除整个栈

栈的应用：

符号匹配
HTML和XML文件中的标签匹配（实质还是符号匹配）
实现函数调用
文本编辑器中的撤销
网页浏览器中已访问页面的历史记录
作为一个算法的辅助数据结构

栈的几种实现方式:

基于简单数组的实现方式
基于动态数组的实现方式
基于链表的实现方式
基于队列的实现方式

五、CopyOnWriteArrayList

是ArrayList的一个的变体，其中所有可变操作（add、set等等）都是通过对底层数组进行一次新的复制来实现的。

工作原理

CopyOnWriteArrayList 的主要工作原理就是 "写时复制" （Copy-On-Write）。这意味着所有的修改操作（如：add、set 和 remove）都是在底层的数组的一个副本上进行的。这个原理帮助我们解决了并发环境下的修改冲突问题。

具体来说，当我们调用一个修改操作时，CopyOnWriteArrayList 会首先锁定它的内部锁，然后复制底层的数组，接着在新的数组副本上进行修改，最后再将引用从原来的数组切换到新的数组。由于所有的修改操作都是在数组的副本上进行的，所以读操作完全不需要锁定，可以直接读取。这样就大大提高了并发读的性能。

然而，由于每次修改都需要复制整个数组，所以写操作的性能和内存开销都比较大。尤其是当数组的大小非常大时，写操作的开销就变得更加显著。这也是为什么我们通常只在读操作远多于写操作的场景中使用 CopyOnWriteArrayList。

很多时候，我们的系统应对的都是读多写少的并发场景。CopyOnWriteArrayList容器允许并发读，读操作是无锁的，性能较高。至于写操作，比如向容器中添加一个元素，则首先将当前容器复制一份，然后在新副本上执行写操作，结束之后再将原容器的引用指向新容器。

线程安全的，多线程环境下可以直接使用，无需加锁；
通过锁 + 数组拷贝 + volatile 关键字保证了线程安全；
每次数组操作，都会把数组拷贝一份出来，在新数组上进行操作，操作成功之后再赋值回去。

从整体架构上来说，CopyOnWriteArrayList 数据结构和 ArrayList 是一致的，底层是个数组，只不过 CopyOnWriteArrayList 在对数组进行操作的时候，基本会分四步走：

加锁；
从原数组中拷贝出新数组；
在新数组上进行操作，并把新数组赋值给数组容器；
解锁

除了加锁之外，CopyOnWriteArrayList 的底层数组还被 volatile 关键字修饰，意思是一旦数组被修改，其它线程立马能够感知到，代码如下：

private transient volatile Object[] array;

整体上来说，CopyOnWriteArrayList 就是利用锁 + 数组拷贝 + volatile 关键字保证了 List 的线程安全。

优点
读操作（不加锁）性能很高，因为无需任何同步措施，比较适用于读多写少的并发场景。Java的list在遍历时，若中途有别的线程对list容器进行修改，则会抛ConcurrentModificationException异常。而CopyOnWriteArrayList由于其"读写分离"的思想，遍历和修改操作分别作用在不同的list容器，所以在使用迭代器进行遍历时候，也就不会抛出ConcurrentModificationException异常了。

缺点
一是内存占用问题，毕竟每次执行写操作都要将原容器拷贝一份。数据量大时，对内存压力较大，可能会引起频繁GC；

二是无法保证实时性，因为CopyOnWrite的写时复制机制，所以在进行写操作的时候，内存里会同时驻扎两个对象的内存，旧的对象和新写入的对象（注意：在复制的时候只是复制容器里的引用，只是在写的时候会创建新对象添加到新容器里，而旧容器的对象还在使用，所以有两份对象内存）。

使用场景

由于 CopyOnWriteArrayList 的特性——读取高效、写入时复制整个底层数组，因此它非常适用于读操作远多于写操作的场景。例如，实时读取系统配置信息的场景。系统配置通常只在系统启动或管理员修改时更新，而在系统运行时，可能会有大量的读取操作，此时使用 CopyOnWriteArrayList 能够提供很高的性能。

再比如，对于事件监听器的管理，我们通常会在应用启动时添加大部分监听器，而在运行过程中，这些监听器的列表很少改动，大部分操作是遍历这个列表来通知所有监听器。这种场景下，CopyOnWriteArrayList 也是非常合适的。

之乎者也·

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
JAVA集合面试分享一：JAVA集合框架详解之List-阶段（一）

链表（LinkedList）是一种常见的基础数据结构，是一种线性表，但是不会按线性的顺序存储数据，而是在每一个节点里面存储下一节点的地址。链表可以分为单项列表和双向链表，单向链表包含两个值：当前节点的值和下一节点的链接。一个双向链表有三个整数值: 数值、向后的节点链接、向前的节点链接。下图就是介绍单向链表和双向链表。
复制链接

扫一扫