LinkedList源码解析（JDK1.8）

最新推荐文章于 2021-09-20 09:38:33 发布

小白写程序

最新推荐文章于 2021-09-20 09:38:33 发布

阅读量186

点赞数

分类专栏： java List 文章标签： LinkedList

本文链接：https://blog.csdn.net/qq_41030039/article/details/101832866

版权

java 同时被 2 个专栏收录

33 篇文章 0 订阅

订阅专栏

List

4 篇文章 1 订阅

订阅专栏

一、LinkedList简介

LinkedList是通过双链表来实现的，本身实现了List接口和Deque接口，并且实现了所有可选的列表操作，并且允许包含所有元素（包括null）。
在这里插入图片描述

继承了AbstractSequentialList抽象类： 遍历LinkedList的时候，官方推荐使用顺序访问，就是使用迭代器，相当于直接遍历一个链表。***（虽然LinkedList提供了get（index）方法，但不推荐使用此方法进行遍历，因为每次调用get方法时，都需要从链表的头部或尾部重新遍历一遍，每一遍都是O（index），虽然官方对遍历有优化：通过判断索引index更接近头部还是尾部，来选择开始遍历的方向）***
实现了List接口，提供List接口的所有方法的实现。
实现了Cloneable接口，支持克隆（浅），底层实现：LinkedList节点并没有被克隆，只是通过Object的clone（）方法得到的Object对象强制转化为LinkedList，然后把它内部的实例域都置空，然后把被拷贝的LinkedList节点中的每一个值都拷贝到clone中。
实现了Deque接口，实现了Deque所有的可选的操作。
实现了Serializable接口，支持序列化。（和ArrayList一样，底层都提供了两个方法：readObject（ObjectInputStream o）、writeObject（ObjectOutputStream o），用于实现序列化，底层只序列化节点的个数和节点的值）。

二、LinkedList总结

1）LinkedList底层是一个双向链表，是一个直线型的链表结构。
2）LinkedList内部实现了6种核心的辅助方法：void linkFirst(E e)、void linkLast(E e)、linkBefore(E e, Node<E> succ)、E unlinkFirst(Node<E> f)、E unlinkLast(Node<E> l)、E unlink(Node<E> x) 都是private修饰或没有修饰符，为LinkedList的其他方法提供服务，是LinkedList的核心方法。

三、核心源码解析

1、元素Node的存储结构：
Node 类是LinkedList中的私有内部类，LinkedList中就是通过Node来存储集合中的元素。
E ：节点的值。
Node next：当前节点的后一个节点的引用（可以理解为指向当前节点的后一个节点的指针）
Node prev:当前节点的前一个节点的引用（可以理解为指向当前节点的前一个节点的指针）

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

2、LinkedList类的结构
size：用来记录LinkedList的大小
Node first：用来表示LinkedList的头节点。
Node last：用来表示LinkedList的尾节点。

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
    transient int size = 0;

    /**
     * Pointer to first node.
     * Invariant: (first == null && last == null) ||
     *            (first.prev == null && first.item != null)
     */
    transient Node<E> first;

    /**
     * Pointer to last node.
     * Invariant: (first == null && last == null) ||
     *            (last.next == null && last.item != null)
     */
    transient Node<E> last;
 }

3、LinkedList提供了两个构造器：
①空构造器：

    public LinkedList() {
    }

②传入一个集合作为参数初始化LinkedList的构造器：

// 首先调用一下空的构造器。
//然后调用addAll(c)方法。
  public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
    }

核心方法addAll（int index, Collection c）：

//通过调用addAll(int index, Collection<? extends E> c) 完成集合的添加。
  public boolean addAll(Collection<? extends E> c) {
        return addAll(size, c); //在原有size的后面添加集合所有元素
    }
//几乎所有的涉及到在指定位置添加或者删除或修改操作都需要判断传进来的参数是否合法。
// checkPositionIndex(index)方法就起这个作用。该方法后面会介绍。  
    public boolean addAll(int index, Collection<? extends E> c) {
        checkPositionIndex(index);
//先把集合转化为数组，然后为该数组添加一个新的引用（Objext[] a）。
        Object[] a = c.toArray();
//新建一个变量存储数组的长度。
        int numNew = a.length;
//如果待添加的集合为空，直接返回，无需进行后面的步骤。后面都是用来把集合中的元素添加到
//LinkedList中。
        if (numNew == 0)
            return false;
//这里定义了两个节点：（读这里的程序的时候，强烈建议自己画一个图，辅助你理解这个过程）。
//Node<E> succ：指代待添加节点的位置。
//Node<E> pred：指代待添加节点的前一个节点。
//下面的代码是依据新添加的元素的位置分为两个分支：
//①新添加的元素的位置位于LinkedList最后一个元素的后面。新添加的元素的位置位于LinkedList中。
//如果index==size;说明此时需要添加LinkedList中的集合中的每一个元素都是在LinkedList最后面。所以把succ设置为空，
//pred指向尾节点。否则的话succ指向插入待插入位置的节点。这里用到了node（int index）方法，这个方法
//后面会详细分析，这里只需要知道该方法返回对应索引位置上的Node（节点）。pred指向succ节点的前一个节点。
        Node<E> pred, succ;
        if (index == size) {
            succ = null;
            pred = last;
        } else {
            succ = node(index);
            pred = succ.prev;
        }
//接着遍历数组中的每个元素。在每次遍历的时候，都新建一个节点，该节点的值存储数组a中遍历
//的值，该节点的prev用来存储pred节点，next设置为空。接着判断一下该节点的前一个节点是否为
//空，如果为空的话，则把当前节点设置为头节点。否则的话就把当前节点的前一个节点的next值
//设置为当前节点。最后把pred指向当前节点，以便后续新节点的添加。
        for (Object o : a) {
            @SuppressWarnings("unchecked") E e = (E) o;
            Node<E> newNode = new Node<>(pred, e, null);
            if (pred == null)
                first = newNode;
            else
                pred.next = newNode;
            pred = newNode;
        }
//这里仍然和上面一样，分两种情况对待：
//①当succ==null（也就是新添加的节点位于LinkedList集合的最后一个元素的后面），
//通过遍历上面的a的所有元素，此时pred指向的是LinkedList中的最后一个元素，所以把last指向pred指向的节点。
//当不为空的时候，表明在LinkedList集合中添加的元素，需要把pred的next指向succ上，succ的prev指向pred。
//最后把集合的大小设置为新的大小。modCount（修改的次数）自增。
        if (succ == null) {
            last = pred;
        } else {
            pred.next = succ;
            succ.prev = pred;
        }

        size += numNew;
        modCount++;
        return true;
    }

4、辅助方法：（私有）
①：把参数中的元素作为链表的第一个元素。

private void linkFirst(E e) {
		//先取出原链表的头节点
        final Node<E> f = first;
        //创建新节点，next指针指向原头节点f
        final Node<E> newNode = new Node<>(null, e, f);
        //更新头节点first指向
        first = newNode;
        if (f == null)
            last = newNode;  // 原链表为空，则当前节点既是头节点也是尾节点
        else
            f.prev = newNode;  // 原头节点f的前指针prev指向新头节点
        size++;
        modCount++; 
    }

②：把参数中的元素作为链表的最后一个元素。

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

③：在非空节点succ之前插入元素e

void linkBefore(E e, Node<E> succ) {
        // assert succ != null;
        //取出当前节点的前一节点
        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++;
        modCount++;
    }

④删除LinkedList中的第一个节点，该节点不为空，并返回删除节点的值。
官方文档的代码中：使用该方法的前提是参数f为头节点，并且不为空。

  private E unlinkFirst(Node<E> f) {
        // assert f == first && f != null;
        //取出被删除节点的值
        final E element = f.item;
        //取得被删除节点的下一节点
        final Node<E> next = f.next;
        //将被删除节点赋值为null，有利于GC收集
        f.item = null;
        f.next = null; 
        //更新头指针和尾指针
        first = next;
        if (next == null)
            last = null;
        else
            next.prev = null;
        size--;
        modCount++;
        return element;
    }

⑤删除LinkedList的最后一个节点，该节点不为空，并且返回删除节点的值。

  private E unlinkLast(Node<E> l) {
        // assert l == last && l != null;
        final E element = l.item;
        final Node<E> prev = l.prev;
        l.item = null;
        l.prev = null; // help GC
        last = prev;
        if (prev == null)
            first = null;
        else
            prev.next = null;
        size--;
        modCount++;
        return element;
    }

⑥删除一个节点，该节点不为空。

    E unlink(Node<E> x) {
        // assert x != null;
        //获取被删除节点的值，用于返回
        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;
        }
		//赋值为null，利于GC
        x.item = null;
        size--;
        modCount++;
        return element;
    }

⑦返回指定索引上的节点。
LinkedList对此做了优化：先比较一下index更靠近头节点还是尾节点，然后选择哪个方向进行遍历，实现折半查找。

Node<E> node(int index) {
        // assert isElementIndex(index);

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

⑧判断参数index是否是元素的索引：用来判断index是否在linkedlist的索引范围内。
checkElementIndex(int index)调用这个方法，不是，返回异常。

    private boolean isElementIndex(int index) {
        return index >= 0 && index < size; //index要小于size
    }

⑨判断新添加元素时，传进来的index是否合法。
checkPositionIndex(int index)调用这个方法，不合法，返回异常。

    private boolean isPositionIndex(int index) {
        return index >= 0 && index <= size; //因为新加元素可能在最后一个元素的后面，所以允许=
    }

⑩返回越界信息

  private String outOfBoundsMsg(int index) {
        return "Index: "+index+", Size: "+size;
    }

5、对外接口方法：
①删除头节点

public E removeFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return unlinkFirst(f);
    }

②删除尾节点

public E removeLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return unlinkLast(l);
    }

③在头部或尾部添加节点

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

④判断是否包含某一个元素

public boolean contains(Object o) {
        return indexOf(o) != -1;
    }
public int indexOf(Object o) {
        int index = 0;
        //因为list可以存null，所以分两种情况
        if (o == null) {
            for (Node<E> x = first; x != null; x = x.next) {
                if (x.item == null)
                    return index;
                index++;
            }
        } else {
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item))
                    return index;
                index++;
            }
        }
        return -1;
    }

⑤计算LinkedList大小

    public int size() {
        return size;
    }

⑥添加一个新元素，直接在最后面添加。

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

⑦删除指定元素

 public boolean remove(Object o) {
        if (o == null) {
            for (Node<E> x = first; x != null; x = x.next) {
                if (x.item == null) {
                    unlink(x);
                    return true;
                }
            }
        } else {
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item)) {
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
    }

⑧清空LinkedList的所有元素

    public void clear() {
        for (Node<E> x = first; x != null; ) {
            Node<E> next = x.next;
            //将指针和值都赋值为null，利于GC
            x.item = null;
            x.next = null;
            x.prev = null;
            x = next;
        }
        first = last = null;
        size = 0;
        modCount++;
    }

⑨获取对应index的节点的值

    public E get(int index) {
        checkElementIndex(index);
        return node(index).item;  //node（）方法依据索引的值返回其对应的节点。
    }

⑩设置对应index 的节点的值
首先检查一下索引是否合法，然后通过node（）求出旧值，设置为新值，最后把旧值返回去。

public E set(int index, E element) {
        checkElementIndex(index);
        Node<E> x = node(index);
        E oldVal = x.item;
        x.item = element;
        return oldVal;
    }

11 在指定位置上添加新的元素

    public void add(int index, E element) {
        checkPositionIndex(index);
		//判断是否在尾部添加
        if (index == size)
            linkLast(element);
        else
        	//不是尾部，就指定添加
            linkBefore(element, node(index));
    }

12 移除指定位置的元素

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

13 在LinkedList中查找object在LinkedList中的位置。（从后向前遍历，只返回第一出线的元素的索引，如果没找到，则返回-1）

 public int lastIndexOf(Object o) {
        int index = size;
        if (o == null) {
            for (Node<E> x = last; x != null; x = x.prev) {
                index--;
                if (x.item == null)
                    return index;
            }
        } else {
            for (Node<E> x = last; x != null; x = x.prev) {
                index--;
                if (o.equals(x.item))
                    return index;
            }
        }
        return -1;
    }

还有实现双端队列的方法，比较简单。

参考该链接：https://blog.csdn.net/m0_37884977/article/details/80467658

小白写程序

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
LinkedList源码解析（JDK1.8）

一、LinkedList简介LinkedList是通过双链表来实现的，本身实现了List接口和Deque接口，并且实现了所有可选的列表操作，并且允许包含所有元素（包括null）。继承了AbstractSequentialList抽象类：遍历LinkedList的时候，官方推荐使用顺序访问，就是使用迭代器，相当于直接遍历一个链表。***（虽然LinkedList提供了get（index）...
复制链接

扫一扫