Java集合源码分析(十一):LinkedList

首先我们知道,LinkedList的底层实现是一个双向链表,链表与数组的差别我们更是清楚,所以LinkedList弥补了ArrayList增删较慢和效率较低的问题了,但是在改和查方面有逊色于ArrayList,所以在使用时要根据业务场景灵活选择。对于这两个使用最频繁的集合类,掌握他们的源码并正确使用,可以让我们的代码更高效。

步入主题,LinkedList既实现了List,又实现了Deque接口,前者使它能够像使用ArrayList一样使用,后者又使它能够承担队列的职责。LinkedList内部结构是一个双向链表,我们在分析ArrayDeque时提到过这个概念,就是扩充单链表的指针域,增加一个指向前一个元素的指针previous。

一、父类AbstractSequentialList

AbstractSequentialList是LinkedList的父级,它继承自AbstractList,并且是一个抽象类,它主要为顺序表的链式实现提供一个骨架:

意思是它的主要作用是提供一个实现List接口的骨架,来减少我们实现基于链式存储的实现类时所需的工作量。AbstractSequentialList并没有做很多特殊的事情,其中最主要的是提供一个方法的默认实现,并将以下方法抽象,以期有更符合场景的实现:

public abstract ListIterator<E> listIterator(int index);

其他的一些方法都利用了这个listIterator方法,我们不在一 一查看了。下面我们来分析一下LinkedList。

二、LinkedList的继承接口

Java集合源码分析(十一):LinkedList_第1张图片

从这个结构图中,我们可以看到。LinkedList也实现了Cloneable、java.io.Serializable等方法,借鉴于ArrayList的经验,我们可以想到它的Clone也是浅克隆,在序列化方法也采用了同样的方式,我们就不再一 一说明了。

二、构造方法与成员变量

在正式你开始之前,我们先说说数据单元Node

在介绍链表结构时提到过,其数据单元分为数据域和指针域,分别存储数据和指向下一个元素的位置,在java中只要定义一个实体类就可以解决了,就像下面这样:

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;
    }
}

成员变量

LinkedList的成员变量主要有三个,而且其用法清晰可见 ,非常简单。

// 记录当前链表的长度
transient int size = 0;

// 第一个节点
transient Node<E> first;

// 最后一个节点
transient Node<E> last;

构造函数

因为链表不会涉及到长度方面的问题,所以不会涉及到扩容等问题,其构造函数也是非常简单和简洁。

public LinkedList() {
     
}

public LinkedList(Collection<? extends E> c) {
     
    this();
    addAll(c);
}

一个默认的构造函数,没有初始化list的大小 ,因为链表不像数组那样,初始化时必须声明其大小或者容量,它通过指针的移动来指向下一个内存地址的分配。
一个有参的构造器,用其他集合初始化,调用了addAll方法。

三、 常用方法

getFirst()和 getLast()
Java集合源码分析(十一):LinkedList_第2张图片
这两个方法就比较简单了,都是先获取对应的节点,然后判空,非空的话,就取出该节点里的值。

removeFirst() 和 removeLast()
Java集合源码分析(十一):LinkedList_第3张图片
Java集合源码分析(十一):LinkedList_第4张图片
这两个方法也是先找到对应的节点,然后将该节点删除,然后在改变前后对应的指针。

addFirst() 和 addLast()
Java集合源码分析(十一):LinkedList_第5张图片
Java集合源码分析(十一):LinkedList_第6张图片
这里也是先找到头节点,然后创建一个新的节点,这个新节点的前缀节点指向null,后缀指向之前的头结点,这个新节点就变成了新的头结点。向末尾添加元素也是一样的,修改对应的指针指向就可。

我们再来看看在某一个节点的前面加一个节点
Java集合源码分析(十一):LinkedList_第7张图片
在succ的节点前面加一个元素e,先定义一个pred来记录succ的前缀节点,然后定义一个新的节点,succ的前缀执行这个前缀,,如果这个之前的pred节点为空,那么这个新节点就位头结点,不是的话,这个pred的后缀就指向这个新的节点。

add() 和 remove()

Java集合源码分析(十一):LinkedList_第8张图片
普通的add方法就是在链表的最后加一个元素,上面已说过,这里就不再重复了;移除某一个元素用到了这个断开链接方法,
Java集合源码分析(十一):LinkedList_第9张图片

传进来一个参数,这个参数为一个节点x,将x这个节点里面的值取出来,将该节点的前缀节点和后缀节点都先记录,如果前缀节点为空的话,也就是说删除的节点为首节点,那就直接把x节点设为头结点就行了,如果不是头结点的情况,x的前缀节点指向x节点的后缀节点就行,x的后缀也指向空;如果x节点时尾结点的话,那就将它的前缀节点设置为尾结点就行,x的后缀节点的前缀指向它的前缀节点就行,最后再将值设为空,size-1。

我们再来看看在指定的地方增加和删除元素

add(int index, E element) 和 remove(int index)
Java集合源码分析(十一):LinkedList_第10张图片
Java集合源码分析(十一):LinkedList_第11张图片
Java集合源码分析(十一):LinkedList_第12张图片

首先判断index下标是否越界,是否正确,如果下标为size大小,则增加的节点为尾结点,直接linkLast方法,上面讲过,这里就不说明了。如果不是的话,就调用linkBefore方法:
Java集合源码分析(十一):LinkedList_第13张图片
先把要插入的这个位置之前的节点找到,也就是succ,在找到他的前缀节点,定义一个新的节点,succ的前缀就指向这个新节点,这里和上面所讲的都差不多,就不做多的说明了

移除的话,也是先判断index是否合法,然后用unlink方法移除。

可以看到,LinkedList提供了一系列方法用来插入和删除,但是却没有在实现一个方法来进行查询,因为对链表的查询是比较慢的,所以他是通过其他的方法来实现的,我们来一起看一看:

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

//可以说尽力了
Node<E> node(int index) {
     
    // assert isElementIndex(index);
    
    //size>>1就是取一半的意思
    //折半,将遍历次数减少一半
    if (index < (size >> 1)) {
     
        Node<E> x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {
     
        Node<E> x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

最后,我们看下它如何对应那些继承来的方法:

//引用了node方法,需要遍历
public E set(int index, E element) {
     
    checkElementIndex(index);
    Node<E> x = node(index);
    E oldVal = x.item;
    x.item = element;
    return oldVal;
}

//也可能需要遍历
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));
}

public E peek() {
     
    final Node<E> f = first;
    return (f == null) ? null : f.item;
}

public E element() {
     
    return getFirst();
}

public E poll() {
     
    final Node<E> f = first;
    return (f == null) ? null : unlinkFirst(f);
}

public E remove() {
     
    return removeFirst();
}

public boolean offer(E e) {
     
    return add(e);
}

public boolean offerFirst(E e) {
     
    addFirst(e);
    return true;
}

//...

四、 关于遍历LinkedList

1、for循环

package collectionTest;

import java.util.LinkedList;

/**
 * @program: juc
 * @description
 * @author: 不会编程的派大星
 * @create: 2021-05-17 09:14
 **/
public class LinkedListTest {
     

    public static void main(String[] args) {
     

        LinkedList<Object> linkedList = new LinkedList<>();

        linkedList.add("a");
        linkedList.add("b");
        linkedList.add("c");
        linkedList.add("d");
        linkedList.add("e");


        for (int i = 0; i < linkedList.size(); i++) {
     
            System.out.println(linkedList.get(i));
        }
    }
}

这里每找一个元素,都要从第一个元素a开始找,所以找第n个元素,相当于要遍历N次,所以提供了nod
e方法 ,折半查找。但效率是真的低,这里不推荐使用for循环。

2、Iterator迭代器

public class LinkedListTest {
     

    public static void main(String[] args) {
     

        LinkedList<Object> linkedList = new LinkedList<>();

        linkedList.add("a");
        linkedList.add("b");
        linkedList.add("c");
        linkedList.add("d");
        linkedList.add("e");


        /**
          for (int i = 0; i < linkedList.size(); i++) {
            System.out.println(linkedList.get(i));
        }
         */

        Iterator<Object> iterator = linkedList.descendingIterator();
        while(iterator.hasNext()){
     
            System.out.println(iterator.next());
        }
    }
}

这里用Iterator的next()则是顺着链表节点顺序读取数据的效率就很高,而不是像for那样每次都要从头开始找。

五、LinkedList总结

1、 LinkedList非常适合大量数据的插入与删除,但其对处于中间位置的元素,无论是增删还是改查都需要折半遍历,这在数据量大时会十分影响性能。在使用时,尽量不要涉及查询与在中间插入数据,另外如果要遍历,也最好使用foreach,也就是Iterator提供的方式。

2、 LinkedList 集合实现了一个 Deque 接口,这是一个双向队列接口,双向队列就是两端都可以进行增加和删除操作,可以模拟队列操作。

3、 LinkedList 实现了 Cloneable 接口和 Serializable 接口,分别用来支持克隆以及支持序列化。

你可能感兴趣的:(Java集合源码,java,队列,链表,数据结构,集合)