LinkedList源码分析

昨天大概看了ArrayList的源码实现,其实还是比较简单的。主要就是操作内部的数组,而用的也比较多的就是今天要看的LinkedList了,它相对于ArrayList具有更高的增加/删除效率,适合作为经常变动的列表使用,其读取的时间复杂度为O(n)。而ArrayList的读取时间复杂度为O(1),变动多的话经常会导致数组的复制操作,所以更适合作为不经常变动的列表。

源码分析

不得不提的Node节点

/**
 * 作为整个链表实现的核心封装,Node节点作为一个静态内部类使用,每一个插入的数据元素都被Node节点包裹着
 */
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的操作其实都是关于Node的操作,理解Node节点就是理解LinkedList的基础,接下来我们还是从基本的类定义开始看。

public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
AbstractSequentialList :为实现序列访问的数据储存结构的提供了所需要的最小化的接口实现(这接口主要是说明他是希望实现者通过顺序访问的)
Deque:双向列表(就是支持链表两头操作的意思)

接口不是讲解的重点,只有在需要的时候我才会去解读接口中的具体方法含义,如果一个一个接口跟进去的内容比较繁琐,而且意义也不大

属性值

//transient 关键字表示在序列化的时候并不会随着链表序列化为二进制数存储,可以这么做是因为即使反序列化后没有这些值,
//但是在改变链表结构的时候这些值又会重新生成,减少了不必要的字段也就减少了序列化的开销。
//源码编写者确实很精打细算。非常细微的地方都考虑到了
    transient int size = 0; //链表长度
    transient Node<E> first; //链表头节点
    transient Node<E> last; //链表尾节点

构造函数

/**
 * 其中空的构造函数我就不说了。。这个构造函数就是直接将Collection中的数据插入到链表中
 */
public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
    }
public boolean addAll(Collection<? extends E> c) {
        return addAll(size, c);
    }
public boolean addAll(int index, Collection<? extends E> c) {
        checkPositionIndex(index); //插入位置必须在[0,size]之间
        //为了便利方便所以转换为数组
        Object[] a = c.toArray();
        int numNew = a.length;
        if (numNew == 0)
            return false;
        //succ:index所在位置的Node引用,pred:index所在位置的前一个Node引用
        Node<E> pred, succ;
        if (index == size) { //如果插入的位置就是链表末尾的话那就可以直接插入而不用移动元素
            succ = null;
            pred = last;
        } else {
            succ = node(index);
            pred = succ.prev;
        }

        for (Object o : a) {
            @SuppressWarnings("unchecked") E e = (E) o;
            Node<E> newNode = new Node<>(pred, e, null);
            if (pred == null) //说明插入的位置是头节点位置(原始的链表为空)
                first = newNode;
            else //上一句已经将newNode的前节点指向pred,这次要将pred的后节点指向newNode了(注意是双向认定)
                pred.next = newNode;
            pred = newNode;//节点后移
        }

        if (succ == null) {
            last = pred; //注意经过移动之后现在pred已经指向了新链表末尾的Node节点
        } else { //因为是在succ这个节点原来的位置进行插入的,所以现在succ其实已经抛离整个链表了,需要跟新的前段链表重新连接一下
            pred.next = succ;
            succ.prev = pred;
        }

        size += numNew;
        modCount++; //作用与ArrayList中的modCount一样
        return true;
    }
/**
 * 即使一个简单的取下标的方法都很精致,考虑的前半段还是后半段(返回节点一定非空)
 */
    Node<E> node(int index) {
        if (index < (size >> 1)) { //如果index在链表的前半段就从头部开始查找,这里不用size/2是因为移位操作更快
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else { //如果index在链表的后半段就从尾部开始查找
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }

基本方法

public boolean add(E e) {
        linkLast(e);
        return true;
}
void linkLast(E e) {
        final Node<E> oldTail = last;
        final Node<E> newNode = new Node<>(oldTail , e, null);
        last = newNode; //这里其实只要注意一下原来的链表是不是空链表就行
        if (oldTail  == null)
            first = newNode;
        else
            oldTail.next = newNode; //没有if判断的话这里就报NPE了
        size++;
        modCount++;
    }
因为linkFirst跟linkLast一模一样,所以我就不看了。

void linkBefore(E e, Node<E> succ) {
        // 因为这是一个内部调用的方法,所以已经保证succ不为null
        final Node<E> pred = succ.prev;
        final Node<E> newNode = new Node<>(pred, e, succ);
        succ.prev = newNode;
        if (pred == null)//如果succ是头结点
            first = newNode;
        else
            pred.next = newNode;
        size++;
        modCount++;
    }

private E unlinkFirst(Node<E> f) {
        final E element = f.item;
        final Node<E> next = f.next;
        f.item = null;
        f.next = null; // 是f没有其他的引用链,促进垃圾回收
        first = next;
        if (next == null) //如果原来链表只有一个节点的话
            last = null;
        else
            next.prev = null;
        size--;
        modCount++;
        return element;
    }

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) { //如果x节点是头结点
            first = next;
        } else {
            prev.next = next;
            x.prev = null;
        }
        if (next == null) { //如果x节点是尾节点
            last = prev;
        } else {
            next.prev = prev;
            x.next = null; //取消x节点对于前后节点的引用
        }
        x.item = null;//还是使用置空的方式促进GC
        size--;
        modCount++;
        return element;
    }
现在为止基本的变更操作已经介绍完了,像removeLast,removeFirst,addFirst,addLast等等这些方法其实只要明白上面操作就完全够了。还有一些poll,take等方法都是基于以上的方法所讲,基本没有其他内容,就是有的报错有的不报错之类的差别。看一下其他典型的方法
public boolean removeLastOccurrence(Object o) {
//这里的核心内容就是判断所移除的对象是不是null,因为是null的话就没法使用equals方法比较
        if (o == null) {
            for (Node<E> x = last; x != null; x = x.prev) {
                if (x.item == null) {
                    unlink(x);
                    return true;
                }
            }
        } else {
            for (Node<E> x = last; x != null; x = x.prev) {
                if (o.equals(x.item)) {
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
    }
//无参的toArray()没啥可看的,就是遍历然后赋值就可以
public <T> T[] toArray(T[] a) {
        if (a.length < size) //如果a转不下链表内容的话就创建一个包含T类型元素的数组
            a = (T[])java.lang.reflect.Array.newInstance(
                                a.getClass().getComponentType(), size);
        int i = 0;
        Object[] result = a;
        for (Node<E> x = first; x != null; x = x.next)
            result[i++] = x.item;

        if (a.length > size) //注意这里的置空操作
            a[size] = null;

        return a;
    }

public Object clone() {
        LinkedList<E> clone = superClone();
        clone.first = clone.last = null;
        clone.size = 0;
        clone.modCount = 0;
       //从这里看到这个克隆还是浅克隆,因为x.item还是原来的地址
        for (Node<E> x = first; x != null; x = x.next)
            clone.add(x.item);
        return clone;
    }

接下来我们看一下Iterator的详细实现,通常遍历有两种方式,一种是通过for循环进行遍历,另外一种就是通过Iterator了,而且Iterator可以在遍历的过程中改变链表节点,但是在for循环过程中改变链表节点的话会有你喜欢的东西出现噢。。

private class ListItr implements ListIterator<E> //内部类ListItr
private Node<E> lastReturned = null; //记录本次操作的目标对象(next()返回是它,删除的话也是它)
private Node<E> next; //下一个遍历出的节点
private int nextIndex; //下一个节点的下标
private int expectedModCount = modCount; //用来判断在遍历过程中有没有节点变更

ListItr(int index) {//初始化的时候从下标为index的位置开始
            next = (index == size) ? null : node(index);
            nextIndex = index;
        }
//下面这两个方法应该是我们最常调用的方法了
public boolean hasNext() {
            return nextIndex < size;
        }
//从这里我们就知道modCount的用途了,如果是for循环的话,循环过程中改变节点会改变modCount.
//因为for循环本质上还是靠Iterator来实现的,所以在遍历过程中发现节点变化就立马报错了
public E next() {
            checkForComodification();
            if (!hasNext())
                throw new NoSuchElementException();
            lastReturned = next; //这个lastReturned主要是用来保存返回结果的
            next = next.next;
            nextIndex++;
            return lastReturned.item;
        }
final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
//这就解释了为什么遍历过程之中Iteraort的remove是可以的
public void remove() {
            checkForComodification(); //操作开始时候的modCount与expectedModCount的相等还是要保证的
            if (lastReturned == null)
                throw new IllegalStateException();
            Node<E> lastNext = lastReturned.next;
            unlink(lastReturned);
//正常情况两者是不会相等的,但是为了保证代码的健壮性我们要考虑这种操作,例如我在多线程情况下进行操作,调用next()方法到了
//第四行时候忽然切到另外一个线程,这时候其实next = lastReturned而且由于next()还没有运行到nextIndex++所以这里也就不用nextIndex--
//虽然LinkedList不是线程安全的,但是在这里尽量去保证其在多线程运行环境下的安全性
            if (next == lastReturned) 
                next = lastNext;
            else
                nextIndex--; //删除了一个next前的元素,nextIndex--是必要的
            lastReturned = null;
            expectedModCount++; //在unlink中modCount++了,所以expectedModCount在这里也自增
        }
public void add(E e) {
            checkForComodification();
            lastReturned = null;
            if (next == null) //如果插入位置在链表末尾的话
                linkLast(e);
            else
                linkBefore(e, next);
            nextIndex++;
            expectedModCount++;
        }

当然LinkedList内部还有一个DescendingIterator作为逆向遍历使用的,因为LinkedList是双向链表,所以不管正向还是逆向其实内部实现都是一样的,不需要再进行过多的关注了。
<strong>到这里其实LinkedList的整个实现都已经讲解清楚了,没有提到的方法往往是因为太过简单或者内容重复,凡是我觉得值得注意的地方我都进行了清晰的注释,如果有哪些大家觉得我理解有误的地方一定要在评论的时候写出来,我会积极参与讨论。</strong>

最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
  • 序言:七十年代末,一起剥皮案震惊了整个滨河市,随后出现的几起案子,更是在滨河造成了极大的恐慌,老刑警刘岩,带你破解...
    沈念sama阅读 148,637评论 1 318
  • 序言:滨河连续发生了三起死亡事件,死亡现场离奇诡异,居然都是意外死亡,警方通过查阅死者的电脑和手机,发现死者居然都...
    沈念sama阅读 63,443评论 1 266
  • 文/潘晓璐 我一进店门,熙熙楼的掌柜王于贵愁眉苦脸地迎上来,“玉大人,你说我怎么就摊上这事。” “怎么了?”我有些...
    开封第一讲书人阅读 99,164评论 0 218
  • 文/不坏的土叔 我叫张陵,是天一观的道长。 经常有香客问我,道长,这世上最难降的妖魔是什么? 我笑而不...
    开封第一讲书人阅读 42,075评论 0 188
  • 正文 为了忘掉前任,我火速办了婚礼,结果婚礼上,老公的妹妹穿的比我还像新娘。我一直安慰自己,他们只是感情好,可当我...
    茶点故事阅读 50,080评论 1 266
  • 文/花漫 我一把揭开白布。 她就那样静静地躺着,像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上,一...
    开封第一讲书人阅读 39,365评论 1 184
  • 那天,我揣着相机与录音,去河边找鬼。 笑死,一个胖子当着我的面吹牛,可吹牛的内容都是我干的。 我是一名探鬼主播,决...
    沈念sama阅读 30,901评论 2 283
  • 文/苍兰香墨 我猛地睁开眼,长吁一口气:“原来是场噩梦啊……” “哼!你这毒妇竟也来了?” 一声冷哼从身侧响起,我...
    开封第一讲书人阅读 29,649评论 0 176
  • 序言:老挝万荣一对情侣失踪,失踪者是张志新(化名)和其女友刘颖,没想到半个月后,有当地人在树林里发现了一具尸体,经...
    沈念sama阅读 33,122评论 0 223
  • 正文 独居荒郊野岭守林人离奇死亡,尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 29,734评论 2 225
  • 正文 我和宋清朗相恋三年,在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 31,093评论 1 236
  • 序言:一个原本活蹦乱跳的男人离奇死亡,死状恐怖,灵堂内的尸体忽然破棺而出,到底是诈尸还是另有隐情,我是刑警宁泽,带...
    沈念sama阅读 27,548评论 2 222
  • 正文 年R本政府宣布,位于F岛的核电站,受9级特大地震影响,放射性物质发生泄漏。R本人自食恶果不足惜,却给世界环境...
    茶点故事阅读 32,028评论 3 216
  • 文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹,春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 25,765评论 0 9
  • 文/苍兰香墨 我抬头看了看天上的太阳。三九已至,却和暖如春,着一层夹袄步出监牢的瞬间,已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 26,291评论 0 178
  • 我被黑心中介骗来泰国打工, 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留,地道东北人。 一个月前我还...
    沈念sama阅读 34,162评论 2 239
  • 正文 我出身青楼,却偏偏与公主长得像,于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子,可洞房花烛夜当晚...
    茶点故事阅读 34,293评论 2 242

推荐阅读更多精彩内容