【139期】面试必会之LinkedList源码分析

本人花费半年的时间总结的《Java面试指南》已拿腾讯等大厂offer,已开源在github ,欢迎star!

转载声明:转载请注明出处,本技术博客是本人原创文章

本文GitHub https://github.com/OUYANGSIHAI/JavaInterview 已收录,这是我花了6个月总结的一线大厂Java面试总结,本人已拿大厂offer,欢迎star

原文链接:blog.ouyangsihai.cn >> 【139期】面试必会之LinkedList源码分析

来源:Java知音

注:本文所有方法和示例基于jdk1.8

概述

LinkedList是一种可以在任何位置进行高效地插入和移除操作的有序序列,它是基于双向链表实现的,是线程不安全的,允许元素为null的双向链表。

源码分析

1. 变量


/**
 * 集合元素数量
 **/
transient int size = 0;

/**
 * 指向第一个节点的指针
 * Invariant: (first == null && last == null) ||
 *            (first.prev == null && first.item != null)
 */
transient NodeE first;

/**
 * 指向最后一个节点的指针
 * Invariant: (first == null && last == null) ||
 *            (last.next == null && last.item != null)
 */
transient NodeE last;

2. 构造方法


/**
 * 无参构造方法
 */
public LinkedList() {
}

/**
 * 将集合c所有元素插入链表中
 */
public LinkedList(Collection? extends E c) {
    this();
    addAll(c);
}

3. Node节点


private static class NodeE {
    // 值
    E item;
    // 后继
    NodeE next;
    // 前驱
    NodeE prev;

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

因为一个Node既有prev也有next,所以证明它是一个双向链表。

4. 添加元素

addAll(Collection c)

将集合c添加到链表,如果不传index,则默认是添加到尾部。如果调用 addAll(int index, Collection? extends E c)方法,则添加到index后面。


/**
 * 将集合添加到链尾
 */
public boolean addAll(Collection? extends E c) {
    return addAll(size, c);
}

/** 
 * 
 */
public boolean addAll(int index, Collection? extends E c) {
    checkPositionIndex(index);

    // 拿到目标集合数组
    Object[] a = c.toArray();
    //新增元素的数量
    int numNew = a.length;
    //如果新增元素数量为0,则不增加,并返回false
    if (numNew == 0)
        return false;

    //定义index节点的前置节点,后置节点
    NodeE pred, succ;
    // 判断是否是链表尾部,如果是:在链表尾部追加数据
    //尾部的后置节点一定是null,前置节点是队尾
    if (index == size) {
        succ = null;
        pred = last;
    } else {
        // 如果不在链表末端(而在中间部位)
        // 取出index节点,并作为后继节点
        succ = node(index);
        // index节点的前节点 作为前驱节点
        pred = succ.prev;
    }

    // 链表批量增加,是靠for循环遍历原数组,依次执行插入节点操作
    for (Object o : a) {
        @SuppressWarnings("unchecked") 
        // 类型转换
        E e = (E) o;
        // 前置节点为pred,后置节点为null,当前节点值为e的节点newNode
        NodeE newNode = new Node(pred, e, null);
        // 如果前置节点为空, 则newNode为头节点,否则为pred的next节点
        if (pred == null)
            first = newNode;
        else
            pred.next = newNode;
        pred = newNode;
    }

    // 循环结束后,如果后置节点是null,说明此时是在队尾追加的
    if (succ == null) {
        // 设置尾节点
        last = pred;
    } else {
    //否则是在队中插入的节点 ,更新前置节点 后置节点
        pred.next = succ;
        succ.prev = pred;
    }

    // 修改数量size
    size += numNew;
    //修改modCount
    modCount++;
    return true;
}

/**
  * 取出index节点
  */ 
NodeE node(int index) {
    // assert isElementIndex(index);

    // 如果index 小于 size/2,则从头部开始找
    if (index  (size  1)) {
        // 把头节点赋值给x
        NodeE x = first;
        for (int i = 0; i  index; i++)
            // x=x的下一个节点
            x = x.next;
        return x;
    } else {
        // 如果index 大与等于 size/2,则从后面开始找
        NodeE x = last;
        for (int i = size - 1; i  index; i--)
            x = x.prev;
        return x;
    }
}


// 检测index位置是否合法
private void checkPositionIndex(int index) {
    if (!isPositionIndex(index))
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

// 检测index位置是否合法
private boolean isPositionIndex(int index) {
    return index = 0 && index = size;
}    

假设我们要在index=2处添加{1,2}到链表中,图解如下:

第一步:拿到index=2的前驱节点 prev=ele1

第二步:遍历集合prev.next=newNode,并实时更新prev节点以便下一次
遍历:prev=newNode

第三步:将index=2的节点ele2接上:prev.next=ele2,ele2.prev=prev

【139期】面试必会之LinkedList源码分析

注意 node(index)方法:寻找处于index的节点,有一个小优化,结点在前半段则从头开始遍历,在后半段则从尾开始遍历,这样就保证了只需要遍历最多一半结点就可以找到指定索引的结点。

addFirst(E e)方法

将e元素添加到链表并设置其为头节点(first)。


public void addFirst(E e) {
    linkFirst(e);
}

//将e链接成列表的第一个元素
private void linkFirst(E e) {

    final NodeE f = first;
    // 前驱为空,值为e,后继为f
    final NodeE newNode = new Node(null, e, f);
    first = newNode;
    //若f为空,则表明列表中还没有元素,last也应该指向newNode
    if (f == null)
        last = newNode;
    else
    //否则,前first的前驱指向newNode
        f.prev = newNode;
    size++;
    modCount++;
}
  • 拿到first节点命名为f
  • 新创建一个节点newNode设置其next节点为f节点
  • 将newNode赋值给first
  • 若f为空,则表明列表中还没有元素,last也应该指向newNode;否则,前first的前驱指向newNode。
  • 图解如下:
  • 新创建一个节点newNode设置其next节点为f节点

    若f为空,则表明列表中还没有元素,last也应该指向newNode;否则,前first的前驱指向newNode。

    addLast(E e)方法

    将e元素添加到链表并设置其为尾节点(last)。

    
    public void addLast(E e) {
        linkLast(e);
    }
    /**
     * 将e链接成列表的last元素
     */
    void linkLast(E e) {
        final NodeE l = last;
        // 前驱为前last,值为e,后继为null
        final NodeE newNode = new Node(l, e, null);
        last = newNode;
        //最后一个节点为空,说明列表中无元素
        if (l == null)
            //first同样指向此节点
            first = newNode;
        else
            //否则,前last的后继指向当前节点
            l.next = newNode;
        size++;
        modCount++;
    }
    

    过程与 linkFirst()方法类似,这里略过。

    add(E e)方法

    在尾部追加元素e。

    
    public boolean add(E e) {
        linkLast(e);
        return true;
    }
    
    void linkLast(E e) {
        final NodeE l = last;
        // 前驱为前last,值为e,后继为null
        final NodeE newNode = new Node(l, e, null);
        last = newNode;
        //最后一个节点为空,说明列表中无元素
        if (l == null)
            //first同样指向此节点
            first = newNode;
        else
            //否则,前last的后继指向当前节点
            l.next = newNode;
        size++;
        modCount++;
    }
    
    add(int index, E element)方法

    在链表的index处添加元素element.

    
    public void add(int index, E element) {
        checkPositionIndex(index);
    
        if (index == size)
            linkLast(element);
        else
            linkBefore(element, node(index));
    }
    /**
     * 在succ节点前增加元素e(succ不能为空)
     */
    void linkBefore(E e, NodeE succ) {
        // assert succ != null;
        // 拿到succ的前驱
        final NodeE pred = succ.prev;
        // 新new节点:前驱为pred,值为e,后继为succ
        final NodeE newNode = new Node(pred, e, succ);
        // 将succ的前驱指向当前节点
        succ.prev = newNode;
        // pred为空,说明此时succ为首节点
        if (pred == null)
            // 指向当前节点
            first = newNode;
        else
            // 否则,将succ之前的前驱的后继指向当前节点
            pred.next = newNode;
        size++;
        modCount++;
    }
    

    linkLast方法上文有讲。
    linkBefore(E e, NodeE succ)方法步骤:

  • 拿到succ的前驱节点
  • 新new节点:前驱为pred,值为e,后继为succ : `Node<>(pred, e, succ);`
  • 将succ的前驱指向当前节点
  • pred为空,说明此时succ为首节点,first指向当前节点;否则,将succ之前的前驱的后继指向当前节点
  • 新new节点:前驱为pred,值为e,后继为succ :  Node&lt;&gt;(pred, e, succ);

    pred为空,说明此时succ为首节点,first指向当前节点;否则,将succ之前的前驱的后继指向当前节点

    5. 获取/查询元素

    get(int index)方法

    根据索引获取链表中的元素。

    
    public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
    }
    
    // 检测index合法性
    private void checkElementIndex(int index) {
        if (!isElementIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
    
    // 根据index 获取元素
    NodeE node(int index) {
        // assert isElementIndex(index);
    
        if (index  (size  1)) {
            NodeE x = first;
            for (int i = 0; i  index; i++)
                x = x.next;
            return x;
        } else {
            NodeE x = last;
            for (int i = size - 1; i  index; i--)
                x = x.prev;
            return x;
        }
    }
    

    node方法上文有详细讲解,这里不做介绍。

    getFirst()方法

    获取头节点。

    
    public E getFirst() {
        final NodeE f = first;
        if (f == null)
            throw new NoSuchElementException();
        return f.item;
    }
    
    getLast()方法

    获取尾节点。

    
    public E getLast() {
        final NodeE l = last;
        if (l == null)
            throw new NoSuchElementException();
        return l.item;
    }
    

    6. 删除元素

    remove(Object o)

    根据Object对象删除元素。

    
    public boolean remove(Object o) {
        // 如果o是空
        if (o == null) {
            // 遍历链表查找 item==null 并执行unlink(x)方法删除
            for (NodeE x = first; x != null; x = x.next) {
                if (x.item == null) {
                    unlink(x);
                    return true;
                }
            }
        } else {
            for (NodeE x = first; x != null; x = x.next) {
                if (o.equals(x.item)) {
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
    }
    
    E unlink(NodeE x) {
        // assert x != null;
        // 保存x的元素值
        final E element = x.item;
        //保存x的后继
        final NodeE next = x.next;
        //保存x的前驱
        final NodeE prev = x.prev;
    
        //如果前驱为null,说明x为首节点,first指向x的后继
        if (prev == null) {
            first = next;
        } else {
            //x的前驱的后继指向x的后继,即略过了x
            prev.next = next;
            // x.prev已无用处,置空引用
            x.prev = null;
        }
    
        // 后继为null,说明x为尾节点
        if (next == null) {
            // last指向x的前驱
            last = prev;
        } else {
            // x的后继的前驱指向x的前驱,即略过了x
            next.prev = prev;
            // x.next已无用处,置空引用
            x.next = null;
        }
        // 引用置空
        x.item = null;
        size--;
        modCount++;
        // 返回所删除的节点的元素值
        return element;
    }
    
  • 遍历链表查找 item==null 并执行unlink(x)方法删除
  • 如果前驱为null,说明x为首节点,first指向x的后继,x的前驱的后继指向x的后继,即略过了x.
  • 如果后继为null,说明x为尾节点,last指向x的前驱;否则x的后继的前驱指向x的前驱,即略过了x,置空x.next
  • 引用置空:`x.item = null`
  • 图解:
  • 如果前驱为null,说明x为首节点,first指向x的后继,x的前驱的后继指向x的后继,即略过了x.

    引用置空: x.item = null

    remove(int index)方法

    根据链表的索引删除元素。

    
    public E remove(int index) {
        checkElementIndex(index);
        //node(index)会返回index对应的元素
        return unlink(node(index));
    }
    
    E unlink(NodeE x)  方法上文有详解。
    
    removeFirst()方法

    删除头节点。

    
    public E removeFirst() {
        final NodeE f = first;
        if (f == null)
            throw new NoSuchElementException();
        return unlinkFirst(f);
    }
    
    private E unlinkFirst(NodeE f) {
        // assert f == first && f != null;
        //取出首节点中的元素
        final E element = f.item;
        //取出首节点中的后继
        final NodeE next = f.next;
        f.item = null;
        f.next = null; // help GC
        // first指向前first的后继,也就是列表中的2号位
        first = next;
        //如果此时2号位为空,那么列表中此时已无节点
        if (next == null)
            //last指向null
            last = null;
        else
            // 首节点无前驱 
            next.prev = null;
        size--;
        modCount++;
        return element;
    }
    

    原理与添加头节点类似。

    removeLast()方法

    删除尾节点(last)

    
    public E removeLast() {
        final NodeE l = last;
        if (l == null)
            throw new NoSuchElementException();
        return unlinkLast(l);
    }
    
    private E unlinkLast(NodeE l) {
        // assert l == last && l != null;
        // 取出尾节点中的元素
        final E element = l.item;
        // 取出尾节点中的后继
        final NodeE prev = l.prev;
        l.item = null;
        l.prev = null; // help GC
        // last指向前last的前驱,也就是列表中的倒数2号位
        last = prev;
        // 如果此时倒数2号位为空,那么列表中已无节点
        if (prev == null)
            // first指向null
            first = null;
        else
            // 尾节点无后继
            prev.next = null;
        size--;
        modCount++;
        // 返回尾节点保存的元素值
        return element;
    }
    

    7. 修改元素

    修改元素比较简单,先找到index对应节点,然后对值进行修改。

    
    public E set(int index, E element) {
        checkElementIndex(index);
        // 获取到需要修改元素的节点
        NodeE x = node(index);
        // 保存之前的值
        E oldVal = x.item;
        // 执行修改
        x.item = element;
        // 返回旧值
        return oldVal;
    }
    

    8. 与ArrayList的对比

    优点:

  • 不需要扩容和预留空间,空间效率高
  • 增删效率高
  • 增删效率高

    缺点:

  • 随机访问时间效率低
  • 改查效率低
  • 改查效率低

    与其在网上拼命找题?** 不如马上关注我们~**

    【139期】面试必会之LinkedList源码分析

    原文始发于微信公众号(Java面试题精选):

    本人花费半年的时间总结的《Java面试指南》已拿腾讯等大厂offer,已开源在github ,欢迎star!

    转载声明:转载请注明出处,本技术博客是本人原创文章

    本文GitHub https://github.com/OUYANGSIHAI/JavaInterview 已收录,这是我花了6个月总结的一线大厂Java面试总结,本人已拿大厂offer,欢迎star

    原文链接:blog.ouyangsihai.cn >> 【139期】面试必会之LinkedList源码分析


     上一篇
    【138期】面试官——谈谈常用的Iterator中hasNext()、next()、remove()方法吧 【138期】面试官——谈谈常用的Iterator中hasNext()、next()、remove()方法吧
    点击上方“Java面试题精选”,关注公众号 面试刷图,查缺补漏 号外:往期面试题,10篇为一个单位归置到本公众号菜单栏-面试题,有需要的欢迎翻阅 阶段汇总集合: 一、Iterator的API关于Iterator主要有三个方法:hasNext
    2021-04-05
    下一篇 
    【140期】Spring的Controller是单例还是多例,怎么保证并发的安全 【140期】Spring的Controller是单例还是多例,怎么保证并发的安全
    点击上方“Java面试题精选”,关注公众号 面试刷图,查缺补漏 号外:往期面试题,10篇为一个单位归置到本公众号菜单栏-面试题,有需要的欢迎翻阅 阶段汇总集合: 答案: controller默认是单例的,不要使用非静态的成员变量,否则会
    2021-04-05