基于jdk1.8的LinkedList的源码分析

基于jdk1.8的LinkedList的源码分析

前言：上篇文章我们已经分析了ArrayList的源码，了解到ArrayList的底层其实是数组结构，但是今天分析LinkedList的底层结构不太一样，它的底层是基于链表来实现的。本文我们还是会从构造方法、增加元素、删除元素、修改元素、查找元素以及它的遍历来进行解析。

一：基本的链表

在开始分析LinkedList的源码之前，我们先了解一下基本的链表结构，方便我们对源码有更好理解。链表一般分为单向链表和双向链表。

1.1：单向链表

单向链表的结构如上图所示：data指数据，next是下一个数据的具体指向，最后一个数据的具体指向为null。

优点：单向链表增加删除节点简单。

缺点：获取元素只能从头到尾遍历而且只能找到后面的元素，不能找到前面的元素。

1.2：双向链表

双向链表的结构如上图所示：data用来存储数据，next是下一个数据的指向，pre是上一个数据的指向，第一个数据的pre和最后一个数据的next指向的都为null。LinkedList的底层实现就是采用这种双向链表结构。

优点：可以找到前元素和后元素，可进可退。

缺点：增加删除节点复杂，需要多分配一个指针存储空间。

二：LinkedList的具体实现

2.1：构造函数

 LinkedList list = new LinkedList();    
 LinkedList list1 = new LinkedList(new ArrayList());

2.2：成员变量

//实际存储的元素个数 
transient int size = 0;
//链表的第一个元素
 transient Node<E> first;
//链表的最后一个元素
 transient Node<E> last;

//内部节点类 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;
        }
    }

2.3：构造函数的具体实现

 //空参构造
public LinkedList() {
    }

//带参构造
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);
		//转换成数组
        Object[] a = c.toArray();
        //记录下数组的长度
        int numNew = a.length;
   		//入参为空
        if (numNew == 0)
            return false;
		//定义两个节点，pred记录前置节点，succ记录后置节点
        Node<E> pred, succ;
    
         //1.1:下面是为了找到在什么地方插入元素
    	//如果index == size 说明是在当前集合的尾部插入数据，此时后节点为null，前节点是之前元素的后节点
        if (index == size) {
            succ = null;
            pred = last;
        } else {
         //否则，找到当前下标指代的节点，要在该节点之前插入数据，所以succ等于该节点
            succ = node(index);
         //pred就等于succ前一位的节点   
            pred = succ.prev;
        }
    
		//1.2:下面是为了把元素插进去，并且前后节点建立联系
        for (Object o : a) {
            @SuppressWarnings("unchecked") E e = (E) o;
            //新建一个节点对象，pred为前置节点，e为元素，null为后置节点
            Node<E> newNode = new Node<>(pred, e, null);
            //第一次进来前置节点是null，所以把新节点赋值给first
            if (pred == null)
                first = newNode;
            else
              //前置节点不为空时，把新节点赋值给前置节点的下一个节点
                pred.next = newNode;
              //令新节点等于前置节点，方便下一次循环得到下一个节点
                pred = newNode;
        }
		//1.3:下面是一个链接的过程
    	//如果succ为null，说明是在集合的尾部插入的元素，所以让插入的最后一个元素赋值给last
        if (succ == null) {
            last = pred;
        } else {
            //如果succ不为null，说明不是在尾部插入的元素，这个时候pred是最后插入的元素，
            //succ是拆开节点的位置，所以令succ等于pred的下一个节点，
            //succ节点拆来之前的前置节点为succ.prev,所以令pred等于之前的前置节点
            pred.next = succ;
            succ.prev = pred;
        }
		//新插入numNew条数据，size增加相应的大小。
        size += numNew;
        modCount++;
        return true;
    }

  private void checkPositionIndex(int index) {
        //如果不符合抛出角标越界异常
        if (!isPositionIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

 private boolean isPositionIndex(int index) {
        //初次构建的时候index和size都为0
        return index >= 0 && index <= size;
    }

//根据index下标获取到相应的节点
//由于是双向链表，这个地方会去判断索引位置（size/2），前半段从头节点开始查找，后半段从尾节点开始查找
 Node<E> node(int index) {
        // assert isElementIndex(index);
        //判断插入元素的位置是在前半段还是在后半段
        if (index < (size >> 1)) { //size/2的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;
        }
    }

2.4：LinkedList之增加元素

增加元素的方法有七种，我们来逐一解析：

add(E)；
add(int index, E element)；
addAll(Collection<? extends E> c)；
addAll(int index, Collection<? extends E> c)；
addFirst(E e)；
addLast(E e)；
push(E e)；

2.4.1：add(E)源码解析

//默认直接在末尾添加元素  
public boolean add(E e) {
        linkLast(e);
        return true;
    }
//添加元素到尾部
void linkLast(E e) {
  			//存储原链表的尾部节点
        final Node<E> l = last;
  			//创建一个新的节点，之前的尾部节点为前置节点，后置节点为null
        final Node<E> newNode = new Node<>(l, e, null);
  			//重新赋值尾部节点
        last = newNode;
  			//如果尾部节点为空
        if (l == null)
          	//那么新增加的节点就是第一个节点
            first = newNode;
        else
          	//否则，新节点就是尾部节点的下一个节点
            l.next = newNode;
  			//链表长度 +1
        size++;
  			//修改次数 +1 
        modCount++;
    }

2.4.2：add(int index, E element)源码解析

//在指定的下标中添加元素  
public void add(int index, E element) {
  			//检查下标是否越界
        checkPositionIndex(index);
				//如果index=size，就在尾部添加元素
        if (index == size)
            linkLast(element);
        else
          //否则就是在前面添加元素，添加之前先找到该元素的位置
            linkBefore(element, node(index));
    }
//检查下标是否越界
 private void checkPositionIndex(int index) {
        if (!isPositionIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(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++;
        modCount++;
    }

	//根据下标找到指定的元素
   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;
        }
    }

	//在节点前添加元素
  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++;
    }

2.4.3：addAll(Collection<? extends E> c)源码分析

 public boolean addAll(Collection<? extends E> c) {
   //链表尾部添加元素,上面已经解析过了
        return addAll(size, c);
    }

    

2.4.4：addAll(int index, Collection<? extends E> c)源码解析

//根据下标插入元素，具体见上面分析
public boolean addAll(int index, Collection<? extends E> c) {
        checkPositionIndex(index);

        Object[] a = c.toArray();
        int numNew = a.length;
        if (numNew == 0)
            return false;

        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
                pred.next = newNode;
            pred = newNode;
        }

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

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

2.4.5：addFirst(E e)的源码解析

//在起始节点添加元素
public void addFirst(E e) {
        linkFirst(e);
    }

 private void linkFirst(E e) {
   			//记录首节点
        final Node<E> f = first;
   			//新建节点，把前置节点置为null，后置节点就是之前的首节点
        final Node<E> newNode = new Node<>(null, e, f);
   			//令新节点为首节点
        first = newNode;
   			//首节点为null，那么就只有一个元素，这个元素也就是最后一个元素
        if (f == null)
            last = newNode;
        else
          	//首节点不为null，那么新节点就是首节点的前置节点
            f.prev = newNode;
        size++;
        modCount++;
    }

2.4.6：addLast(E e)源码解析

//在尾部添加元素 
public void addLast(E e) {
        linkLast(e);
    }

 void linkLast(E e) {
   			//记录尾部节点
        final Node<E> l = last;
   			//新建一个节点，前置节点是尾部节点，后置节点为null
        final Node<E> newNode = new Node<>(l, e, null);
   			//新节点赋值给最后一个元素
        last = newNode;
   			//尾部为null，只有一个元素，尾节点就是最后一个节点
        if (l == null)
            first = newNode;
        else
          	//否则，新节点就是尾部节点的后置节点
            l.next = newNode;
        size++;
        modCount++;
    }

2.4.7：push(E e)源码解析

//添加首节点
public void push(E e) {
        addFirst(e);
    }

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

private void linkFirst(E e) {
        final Node<E> f = first;
        final Node<E> newNode = new Node<>(null, e, f);
        first = newNode;
        if (f == null)
            last = newNode;
        else
            f.prev = newNode;
        size++;
        modCount++;
    }
    

2.5：LinkedList之删除元素

删除元素的常用方法有如下七种，我们来逐一解析：

E remove(); 
E remove(int index); //根据下标删除元素 
boolean remove(Object o); //删除元素o 
E removeFirst(); //删除头结点
E removeLast(); //删除尾结点
boolean removeFirstOccurrence(Object o); //删除此节点中第一次出现的o
boolean removeLastOccurrence(Object o); //删除此节点中最后一次出现的o

2.5.1：remove()源码解析

//删除首元素
public E remove() {
        return removeFirst();
    }

 public E removeFirst() {
  			//记录首元素
        final Node<E> f = first;
        if (f == null)
          	//首元素为空抛出异常
            throw new NoSuchElementException();
        return unlinkFirst(f);
    }
//
private E unlinkFirst(Node<E> f) {
        // assert f == first && f != null;
  			//记录首节点的元素
        final E element = f.item;
  			//记录首节点的下一个节点
        final Node<E> next = f.next;
  			//把首节点元素置为null
        f.item = null;
  			//把首节点的下一个节点置为null
        f.next = null; // help GC
  			//接着把下一个节点设置为首节点
        first = next;
  			//如果下一个节点为空，说明只有一个元素，那么删掉后last就是null
        if (next == null)
            last = null;
        else
          	//否则，下一个节点的前置节点就是null
            next.prev = null;
  			//删掉一个节点，整体的size -1
        size--;
        modCount++;
				//返回删除的元素
        return element;
    }

2.5.2： remove(int index)源码解析

//会根据下标删除元素 
public E remove(int index) {
 				//检查下标越界
        checkElementIndex(index);
        return unlink(node(index));
    }

//根据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;
        }
    }

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;
				//如果该节点的前节点是null，说明是首节点，那么令下一个节点为首节点
        if (prev == null) {
            first = next;
        } else {
          //否则，令该节点的前节点的下一个节点为该节点的下一个节点
            prev.next = next;
          	//并令该节点的前置节点为null
            x.prev = null;
        }
				
        //如果后置节点为null，说明是最后一个节点，令最后节点为该节点的前一个节点
        if (next == null) {
            last = prev;
        } else {
          //否则，就令前下一个节点的前置节点等于当前节点的前置节点
            next.prev = prev;
          	//并让该节点后置节点为null
            x.next = null;
        }
				//置元素为null
        x.item = null;
        size--;
        modCount++;
        return element;
    }

2.5.3：remove(Object o)源码解析：

//删除元素
public boolean remove(Object o) {
  			//如果删除的元素为null
        if (o == null) {
          	//遍历链表所有的数据
            for (Node<E> x = first; x != null; x = x.next) {
              	//如果元素值为null，删掉
                if (x.item == null) {
                    unlink(x);
                    return true;
                }
            }
        } else {
          //如果元素不为null
            for (Node<E> x = first; x != null; x = x.next) {
              //找到元素后删掉
                if (o.equals(x.item)) {
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
    }
//见上面分析
 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;
        }

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

2.5.4：removeFirst()源码解析

//删除首节点
 public E removeFirst() {
   			//记录首节点
        final Node<E> f = first;
   			//首节点为null，抛错
        if (f == null)
            throw new NoSuchElementException();
        return unlinkFirst(f);
    }
//删除首节点，见上面分析
private E unlinkFirst(Node<E> f) {
        // assert f == first && f != null;
        final E element = f.item;
        final Node<E> next = f.next;
        f.item = null;
        f.next = null; // help GC
        first = next;
        if (next == null)
            last = null;
        else
            next.prev = null;
        size--;
        modCount++;
        return element;
    }

2.5.5：removeLast()源码分析

//删除尾部节点
 public E removeLast() {
   			//记录尾部节点
        final Node<E> l = last;
   			//为空，抛错
        if (l == null)
            throw new NoSuchElementException();
        return unlinkLast(l);
    }
//删除尾部节点
private E unlinkLast(Node<E> l) {
        // assert l == last && l != null;
  			//记录尾部节点的元素
        final E element = l.item;
  			//记录尾部节点的前置节点
        final Node<E> prev = l.prev;
  			//让元素为null
        l.item = null;
  			//让前置节点为null
        l.prev = null; // help GC
  			//令最后的节点为删除节点的前置节点
        last = prev;
  			//如果前置节点为null，说明是首节点，那么令首节点为null
        if (prev == null)
            first = null;
        else
          //否则前置节点的下一个节点置为null
            prev.next = null;
        size--;
        modCount++;
        return element;
    }

2.5.6：removeFirstOccurrence(Object o)源码解析

 //删除此节点中第一次出现的o
 public boolean removeFirstOccurrence(Object o) {
        return remove(o);
    }
	//具体解析见上文
  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;
    }

2.5.7：removeLastOccurrence(Object o)源码解析

//删除此节点中最后一次出现的o
 public boolean removeLastOccurrence(Object o) {
        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;
    }

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

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

2.6：LinkedList之修改元素

set(int index, E element)

源码解析：

 public E set(int index, E element) {
   			//检查下标越界
        checkElementIndex(index);
   			//找到该节点的位置
        Node<E> x = node(index);
   			//记录旧节点的值
        E oldVal = x.item;
   			//令旧等于新元素
        x.item = element;
   			//返回旧元素
        return oldVal;
    }

2.7：LinkedList之获取元素

获取元素有如下三种方法，我们来逐一分析：

get(int index)； 
getFirst()；
getLast()；

2.7.1：get(int index)源码解析

//根据下标获取元素值
public E get(int index) {
  	//检查下标越界
    checkElementIndex(index);
    return node(index).item;
}

//根据下标获取到具体的节点位置，上没有分析
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;
        }
    }

2.7.2：getFirst()源码分析

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

2.7.3：getLast()源码分析

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

2.8：LinkedList之遍历

list.listIterator()

2.8.1：list.listIterator()源码解析

public ListIterator<E> listIterator() {
        return listIterator(0);
    }

 public ListIterator<E> listIterator(final int index) {
        rangeCheckForAdd(index);

        return new ListItr(index);
    }

//在这里我们可以看见ListItr继承自Itr并且实现了ListIterator，在之前分析的ArrayList的文章里就提到过
//Itr这个内部类，其中的next()和hasNext()方法和之前的一样。
 private class ListItr extends Itr implements ListIterator<E> {
        ListItr(int index) {
            cursor = index;
        }

        public boolean hasPrevious() {
            return cursor != 0;
        }

        public E previous() {
            checkForComodification();
            try {
                int i = cursor - 1;
                E previous = get(i);
                lastRet = cursor = i;
                return previous;
            } catch (IndexOutOfBoundsException e) {
                checkForComodification();
                throw new NoSuchElementException();
            }
        }

        public int nextIndex() {
            return cursor;
        }

        public int previousIndex() {
            return cursor-1;
        }

        public void set(E e) {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                AbstractList.this.set(lastRet, e);
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

        public void add(E e) {
            checkForComodification();

            try {
                int i = cursor;
                AbstractList.this.add(i, e);
                lastRet = -1;
                cursor = i + 1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }
    }

三：总结

1：LinkedList插入数据和删除数据比较快，查询比较慢，因为需要遍历真个链表才可以找到该元素；
2：LinkedList父类继承了Iterable，遍历的时候使用iterator循环，效率更高；
3: LinkedList所有指定位置的操作都是从头开始遍历进行的；
4: LinkedList线程不安全，可以使用：List list = Collections.synchronizedList(new LinkedList(…))；
5: LinkedList允许null值；

至此，ArrayList的源码研究告一段落，欢迎大家一起讨论学习。

了解更多干货，欢迎关注我的微信公众号：爪哇论剑