JAVA集合源码解析——LinkedList

1.数据结构

LinkedList的数据结构是一个双向链表结构， next指向下一个节点的地址,prev指向上一节点,element代表链表中的值;同时first节点中的prev和last节点的next为null。

2.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.构造方法（初始化一个链表）

(1).无参构造函数(构造一个空链表)

/**
 * Constructs an empty list.
 * 无参构造函数，构造一个空列表
 */
public  LinkedList() {
}

(2).有参构造函数（将指定集合中的元素构建成LinkedList链表）

/**
 * Constructs a list containing the elements of the specified
 * collection, in the order they are returned by the collection's
 * iterator.
 * 有参构造函数，将集合c中的各个元素构建成LinkedList链表.
 *
 *  @param  c  the collection whose elements are to be placed into this list 需要放入链表中的集合
 *  @throws  NullPointerException if the specified collection is null 如果指定添加的集合为空，抛出空指针异常
 */
public  LinkedList(Collection<?  extends  E> c) {
    //调用无参的构造函数，构建一个空列表
    this() ;
    //将集合c中的元素添加到构建的空列表中
    addAll(c) ;
}

4.LinkedList中核心方法

(1). class Node<E>;

/**
 * LinkedList中构成链表的核心源码（链表节点属性）
 */
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). add(E  e);

/**
 * Appends the specified element to the end of this list.
 * 将指定的元素追加到列表的末尾.
 *  <p>
  *  <p> This method is equivalent to { @link  #addLast}.
 *
 *  @param  e  element to be appended to this list 需要添加到列表的元素e
 *  @return  { @code  true} (as specified by { @link  Collection#add})
 */
public boolean  add(E e) {
    //调用linkLast方法添加至末尾
    linkLast(e) ;
    return true;
}

/**
 * Links e as last element.
 * 将e作为链表中的最后一个节点添加到列表中
 *
 *  @param  e  需要添加的元素
 */
void  linkLast(E e) {
    //l赋值last（当前列表的最后一个节点);即为e添加后的首节点
    final LinkedList.Node<E> l = last ;
    //调用new Node<>()初始化当前节点,prev为l;e为节点的数据;因为添加到最后一个节点所以null表示该节点的next
    final LinkedList.Node<E> newNode =  new LinkedList.Node<>(l , e , null) ;
    //添加后newNode就成为最后一个节点了所以last赋值为newNode
    last = newNode ;
    if (l ==  null)
        //如果l即该链表的最后一个节点为null，那么新加的节点就是第一个节点需要给first赋值newNode
        first = newNode ;
    else
        //如果添加之前的最后一个节点为不为null,那么新增之前的最后一个节点的next就要指向当前新增的节点newNode
        l. next = newNode ;
    //新增一个节点，链表的大小size++
    size++ ;
    modCount++ ;
}

(3). addAll(Collection<?  extends  E>  c);

/**
 * Appends all of the elements in the specified collection to the end of
 * this list, in the order that they are returned by the specified
 * collection's iterator.  The behavior of this operation is undefined if
 * the specified collection is modified while the operation is in
 * progress.  (Note that this will occur if the specified collection is
 * this list, and it's nonempty.)
 * 将指定集合中的所有元素追加到列表的末尾
 *
 *  @param  c  collection containing elements to be added to this list 要添加到此列表的元素的集合
 *  @return  { @code  true} if this list changed as a result of the call
 *  @throws  NullPointerException if the specified collection is null 如果c为null抛出空指针异常
 */
public boolean  addAll(Collection<?  extends E> c) {
    return addAll(size , c) ;
}

/**
 * Inserts all of the elements in the specified collection into this
 * list, starting at the specified position.  Shifts the element
 * currently at that position (if any) and any subsequent elements to
 * the right (increases their indices).  The new elements will appear
 * in the list in the order that they are returned by the
 * specified collection's iterator.
 * 将指定集合中的所有元素插入到该列表中，从指定位置开始
 *
 *  @param  index  index at which to insert the first element
 *              from the specified collection 从指定集合插入第一个元素的索引。
 *  @param  c      collection containing elements to be added to this list 要添加到此列表的元素的集合
 *  @return  { @code  true} if this list changed as a result of the call
 *  @throws  IndexOutOfBoundsException { @inheritDoc }  索引越界异常
 *  @throws  NullPointerException      if the specified collection is null 如果要添加的集合为null抛出空指针异常
 */
public boolean  addAll( int index , Collection<?  extends E> c) {
    //检查指定位置索引是否满足条件
    checkPositionIndex(index) ;
    //将要添加到链表的集合转换为Object数组赋值给a
    Object[] a = c.toArray() ;
    //numNew代表要添加集合的长度
    int numNew = a. length ;
    if (numNew ==  0) //如果要添加的集合为空直接返回false
        return false;
    //定义两个临时节点,pred标识要插入集合的前一个节点;succ标识要插入集合的后一个节点
    Node<E> pred , succ ;
    if (index == size) { //如果index=size;当链表为空例如构造函数初始化时 或者 在链表结尾添加 走这边
        //如果插入链表为空或者在链表尾部插入;succ(标识要插入集合的后一个节点)一定为空
        succ =  null;
        //如果插入链表为空last为空 pred = null;如果不为空在链表尾部插入pred（标识要插入集合的前一个节点）为链表的最后一个元素last
        pred = last ;
    }  else { //如果在链表元素中间插入集合
        //succ赋值为当前指定索引节点；node方法根据节点所以获取节点信息
        succ = node(index) ;
        //pred为succ节点的prev
        pred = succ.prev ;
    }
    for (Object o : a) { //遍历要插入的集合
        @SuppressWarnings( "unchecked") E e = (E) o ; //将o的值赋给e
        //初始化当前需要添加的节点newNode；新节点prev = pred， 添加的元素e， next暂时赋值为null
        Node<E> newNode =  new Node<>(pred , e , null) ;
        if (pred ==  null) //如果要插入元素的前一个节点为null
            //当前节点就是第一个节点first赋值为当前节点
            first = newNode ;
        else
            //否则pred(要插入元素的前一个节点)的next为当前节点
            pred.next = newNode ;
        //最后添加完节点后当前节点为下次插入时的pred（标识要插入集合的前一个节点）
        pred = newNode ;
    }
    if (succ ==  null) { //标识要插入的后一个节点为null
        //此时的pred就是链表中的最后一个节点
        last = pred ;
    }  else {
        //要添加的集合的最后一个节点对象的next指向要插入链表的最后一个节点
        pred.next = succ ;
        //同理要插入链表的最后一个节点对象的prev指向pred
        succ.prev = pred ;
    }
    //修改链表元素的大小值+要添加元素的集合大小
    size += numNew ;
    modCount++ ;
    return true;
}

/**
 * 检查指定位置索引是否满足条件
 *
 *  @param  index  从指定集合插入第一个元素的索引。
 */
private void  checkPositionIndex( int index) {
    if (!isPositionIndex(index))
        //调用isPositionIndex判断索引是否满足条件，如果不满足条件抛出该索引越界异常
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index)) ;
}

/**
 * Tells if the argument is the index of a valid position for an
 * iterator or an add operation.
 * 判断参数是否是有效位置的索引
 */
private boolean  isPositionIndex( int index) {
    //如果索引大于等于0并且小于等于size（该链表的大小）返回true
    return index >=  0 && index <= size ;
}

(4). remove(Object o);

/**
 * Removes the first occurrence of the specified element from this list,
 * if it is present.  If this list does not contain the element, it is
 * unchanged.  More formally, removes the element with the lowest index
 * { @code  i} such that
 *  <tt> (o==null &nbsp; ? &nbsp; get(i)==null &nbsp; : &nbsp; o.equals(get(i))) </tt>
  * (if such an element exists).  Returns { @code  true} if this list
 * contained the specified element (or equivalently, if this list
 * changed as a result of the call).
 * 找到要移除元素的值，没找到什么都不用做，如果存在多个一样的值则移除索引index最小的那个
 *
 *  @param  o  element to be removed from this list, if present   要移除的元素
 *  @return  { @code  true} if this list contained the specified element
 */
public boolean  remove(Object o) {
    if (o ==  null) { //LinkedList放null，如果要移除的元素为null
        for (Node<E> x = first ; x !=  null; x = x.next) { //遍历链表
            //如果链表元素中的值为null
            if (x.item ==  null) {
                //调用unlink方法移除
                unlink(x) ;
                return true;
            }
        }
    }  else { //移除非空的元素
        for (Node<E> x = first ; x !=  null; x = x.next) { //遍历链表
            if (o.equals(x.item)) { //如果链表中的值和要移除的元素相等
                //调用unlink方法移除
                unlink(x) ;
                return true;
            }
        }
    }
    //如果链表中没有找到要移除的元素则返回false
    return false;
}

/**
 * Unlinks non-null node x.
 * 移除指点的节点元素（不能传一个null值）
 */
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) { //如果该节点prev为null
        //该节点就是首节点，删除该节点next就为首节点
        first = next ;
    }  else { //如果该节点prev不为空
        //该节点的prev.next指向next
        prev.next = next ;
        //该节点的prev指向置空
        x.prev =  null;
    }

    if (next ==  null) { //如果该节点next为null
        //要删除的节点为尾节点，删除该节点后prev就为尾节点
        last = prev ;
    }  else { //如果该节点next不为null
        //该节点next.prev指向prev
        next.prev = prev ;
        //该节点的next指向置空
        x.next =  null;
    }

    //之前的操作是吧要删除的节点前后指向都置空了，这里吧里面的数据也置空
    x.item =  null;
    //删除后链表的大小--
    size-- ;
    modCount++ ;
    //返回已经删除节点的数据
    return element ;
}

(5). remove(int  index);

/**
 * Removes the element at the specified position in this list.  Shifts any
 * subsequent elements to the left (subtracts one from their indices).
 * Returns the element that was removed from the list.
 * 删除该列表中指定位置的元素。
 *
 *  @param  index  the index of the element to be removed  要删除元素的索引
 *  @return  the element previously at the specified position 返回删除元素的值
 *  @throws  IndexOutOfBoundsException { @inheritDoc } 抛出数组越界异常
 */
public  E  remove( int index) {
    //检查索引看是否存在索引越界异常
    checkElementIndex(index) ;
    //直接根据索引调用node方法获取节点后调用unlink方法删除该节点
    return unlink(node(index)) ;
}

(6). set(int  index,  E  element);

/**
 * Replaces the element at the specified position in this list with the
 * specified element.
 * 用指定的元素替换列表中指定位置的元素。
 *
 *  @param  index    index of the element to replace 替换元素的索引
 *  @param  element  element to be stored at the specified position 要在指定位置上存储的元素
 *  @return  the element previously at the specified position 替换前该位置上的元素
 *  @throws  IndexOutOfBoundsException { @inheritDoc } 抛出索引越界异常
 */
public  E  set( int index ,  E element) {
    //索引校验
    checkElementIndex(index) ;
    //根据索引值获取该索引上的节点
    Node< E> x = node(index) ;
    //该索引元素替换前的值
    E oldVal = x. item ;
    //将替换元素赋给改该节点的item
    x. item = element ;
    //返回该索引元素替换前的值
    return oldVal ;
}

(7). get(int  index);

/**
 * Returns the element at the specified position in this list.
 * 返回该列表中指定位置的元素。
 *
 *  @param  index  index of the element to return 返回元素的索引
 *  @return  the element at the specified position in this list  列表中指定位置的元素
 *  @throws  IndexOutOfBoundsException { @inheritDoc } 抛出索引越界异常
 */
public E  get( int index) {
    //校验index索引看是否存在越界异常
    checkElementIndex(index) ;
    //直接调用node(index)方法获取节点;通过节点的item属性来拿值。关键还是在node()方法上
    return node(index).item ;
}

/**
 * Returns the (non-null) Node at the specified element index.
 * 返回指定索引位置上的节点信息
 */
Node<E>  node( int index) {
    // assert isElementIndex(index);
    if (index < (size >>  1)) { //如果索引在链表的前半段
        Node<E> x = first ;
        for ( int i =  0 ; i < index ; i++) //从first头结点开始遍历
            x = x.next ;
        //返回index位置上的节点对象
        return x ;
    }  else { //如果索引在链表的后半段
        Node<E> x = last ;
        for ( int i = size -  1 ; i > index ; i--) //从last尾节点开始遍历
            x = x.prev ;
        //返回index位置上的节点对象
        return x ;
    }
}

5.LinkedList总结

(1). LinkedList本质是一个双向链表，核心是链表上的节点通过Node内部类实现。

(2). 基于双向链表的属性相对于LinkedList在新增，删除操作时只需要调整指针的指向相对ArrayList性能较好。但是在查询方面需要遍历指针位置上的元素性能相对ArrayList来说较差。

(3). 和ArrayList一样都是非线程安全的在单线程下才能使用。

(4). 链表中元素的属性值可以为null。