LinkedList 源码

LinkedList

重要属性

1. 使用双向链表实现，适用于更新频繁，查询较少的场景
2. 除了实现了List接口还实现了 Deque 接口，所以LinkedList 提供了列表相关的方法外还提供了双向队列相关的方法

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

    /**
     * 头节点
     * 不变真理: (first == null && last == null) ||
     *            (first.prev == null && first.item != null)  
     */
    transient Node<E> first;

    /**
     * 尾节点
     * 不变真理: (first == null && last == null) ||
     *            (last.next == null && last.item != null)
     */
    transient Node<E> last;

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

重要api

添加方法 ：addFirst,addLast,add,offer,offerFirst,offerLast，push

1. 提供了多个添加数据的方法，可从头节点插入，尾节点插入， 提供了列表形式的add 添加，也提供了队列形式的offer 添加， 头节点添加和尾节点添加都是比较方便的，修改原有头节点或者尾节点的 next 或者 prev 指向

    // 头插
   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++;
   }
   
   /**
        * 尾插
        */
   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++;
   }
   

查询方法

1. LinkedList 的public E get(int index)查询是比较耗时的，需要遍历链表

       Node<E> node(int index) {
           // assert isElementIndex(index); 调用此方法需要先校验 index,防止越界
   		// 二分遍历 
           if (index < (size >> 1)) { //size >> 1即是除以2
               //如果需要查找的元素在离头比较近则从头遍历
               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. linkedList 队列相关的查询方法 ： peeKLast, peekFirst

   // 获取头节点元素 
   public E peekFirst() {
        final Node<E> f = first;
        return (f == null) ? null : f.item;
    }
   
   // 获取尾节点元素
   public E peekLast() {
       final Node<E> l = last;
       return (l == null) ? null : l.item;
   }
   

队列弹出相关方法 poll（弹出头节点元素，如果节点为空 返回空）, pop（删除头节点，如果头节点为空抛出异常，删除成功返回头节点元素）, pollFirst, pollLast

1. 以上方法都是对队列头的头节点或者队列尾的尾节点进行操作，返回节点，并将节点删除

2. 删除节点其实是将原有指向置为 null ， 使得原来的节点元素不可达，方便垃圾回收， remove 移除方法的本质也是如此

   // 删除头节点 
   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;
    }
   
   /**
        * 删除尾节点
        */
   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;
   }
   

序列化

1. 自定义的序列化和反序列话的方法，逐个序列化链表中的元素， 序列化的长度为 LinkedList的size

private void writeObject(java.io.ObjectOutputStream s)
    throws java.io.IOException {
    // Write out any hidden serialization magic
    s.defaultWriteObject();

    // Write out size
    s.writeInt(size);

    // 遍历链表元素，逐个序列化
    for (Node<E> x = first; x != null; x = x.next)
        s.writeObject(x.item);
}

private void readObject(java.io.ObjectInputStream s)
    throws java.io.IOException, ClassNotFoundException {
    // Read in any hidden serialization magic
    s.defaultReadObject();

    // Read in size
    int size = s.readInt();

    // 逐个读取元素并加入链表
    for (int i = 0; i < size; i++)
        linkLast((E)s.readObject());
}