List--LinkedList-源码理解

一、继承关系

public class LinkedList<E>    extends AbstractSequentialList<E>   
  implements List<E>, Deque<E>, Cloneable, java.io.Serializable

1. 继承父类关系

1.1 继承AbstractSequentialList类，是一个双向链表；
1.2 实现了List接口，可以对其进行队列操作；
1.3 实现了Cloneable接口，允许克隆；
1.4 实现了Serializable接口，可以对其进行序列化操作；
1.5 实现了Deque接口，能将LinkedList当作双端队列使用。

二、成员变量

//用于记录链表的长度
transient int size = 0;
//链表头结点
transient Node<E> first;
//链表的尾节点
transient Node<E> last;
//Node 是 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;
            }
  }

三、构造器

3.1 LinkedList()

public LinkedList() {}

声明一个空的链表

3.2 LinkedList(Collection<? extends E> c)

public LinkedList(Collection<? extends E> c) { 
        this();
        addAll(c);
   }

声明一个集合c的链表；
首先是调用LinkedList()方法，声明一个空链表,然后在调用addAll(size, 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; 
        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;
   }

调用checkPositionIndex判断index在当前链表中，集合c转成对象数组，numNew记录插入集合的长度，声明pred和succ两个Node对象，如果插入位置和当前链表长度一致，则说明是在该链表尾部插入集合，即succnull,pred=last;
否则通过 node(index) 方法获取index所在的对象，并将该node对象的prev赋值给pred;
循环遍历对象数组a，将对象转成Node对象，并声明新的Node节点对象，并将pred指向该Nodeprev，当prednull说明当前链表是个空链表，newNode节点指向first节点，如果pred不为空，则将pred的next指向当前节点（pred.next = newNode）
同时将newNode赋值给pred；将集合c元素加入到链表中之后，
如果succ==null，则将pred指向尾节点last，否则当前节点后驱指向插入节点，插入节点的前驱指向pred。

四、成员方法

4.1 linkFirst(E 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++;
}

将头结点赋值给f,创建一个新节点newNode，设置前驱为null，后驱指向f；
头结点first指向newNode，如果f为null（说明该链表为空），则尾节点指向newNode，否则f的前驱指向头结点；
链表size加1，操作次数自增；

4.2 linkLast(E e):插入尾节点

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

声明l指向尾节点last，声明新的节点newNode，并将新节点的前驱指向l，后驱设置为null，
last指向新节点newNode，如果l为null（说明链表为空），头结点指向新节点，否则l后驱指向新节点newNode,链表数据加1，操作次数自增1.

4.3 void linkBefore(E e, Node succ)：在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++;
}

使用前提节点succ不为null；
声明节点pred指向succ的前驱，创建新节点newNode，使其前驱指向节点succ的前驱，后驱指向succ节点。succ前驱指向新节点newNode,如果pred为空（说明succ节点头结点），则first头结点指向新节点，否则pred的后驱指向新节点；链表长度加1，链表操作次数自增1；

4.4 private E unlinkFirst(Node 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;
    }

使用前提节点f是头节点且不为null；
内部方法用于删除头结点
element指向节点f的item，节点next指向f.next;
将f的item和next都置为null，GC回收；
头结点指向next节点，如果next为null，则说明是个空链表，尾节点为null。否则next的前驱设置为null，size–，操作次数自增，返回头结点的item对象。

4.5 private E unlinkLast(Node l):删除尾节点

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

使用前提节点l是尾节点且不为null；
私有方法，用于删除尾节点：
element指向尾节点l的item，用于返回；
节点prev指向尾节点l的前驱，将尾节点l前驱，item设置为null，再将尾节点指向prev，如果prev==null，这说明链表是个空链表，头结点为null，否则prev后驱设置为null，链表长度自减，操作次数自增，返回尾节点的对象。

4.5 E unlink(Node 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; 
        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;
    }

使用该方法前提节点x不能为null；
声明对象element指向节点x的对象，
节点next指向节点x的后驱，节点prev指向节点x的前驱，如果prev为null，则说明x是头结点，即将头结点指向next，否则将x的前驱节点prev的后驱指向x的后驱节点，并将x前驱设置为null；
如果next为null，则说明节点x是尾节点，即将尾节点指向x的前驱prev，否则将x的后驱节点的前驱指向prev，x的后驱置为null；
将节点x的对象置为null，连链表长度自减，修改操作次数自增，并返回该节点的对象。

4.6 public E getFirst():返回list的头结点对象

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

获取头结点的对象，若头结点为null则抛出NoSuchElementException() 异常。

4.7 public E getLast()：获取尾节点的对象

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

4.8 public E removeFirst():删除头结点

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

4.9 public E removeLast():删除尾节点

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

4.10 public void addFirst(E e):将元素设置为头结点

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

4.11 public void addLast(E e):将元素设置为尾节点

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

4.12 public boolean contains(Object o) :判断list是否包含对象o

public boolean contains(Object o) {
        return indexOf(o) != -1;
   }

4.13 public int size() :返回list长度

public int size() {    
        return size;
    }

4.14 public boolean add(E e)：在list尾部添加元素

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

4.15 public boolean remove(Object o):删除list中的元素 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;
    }

如果元素o为null，则遍历list，满足元素为null时，调用unlink方法移除o，并返回true;
否则在遍历list用equals比较是否相等。

4.16 addAll(Collection<? extends E> c) ： 将集合元素添加到list中

public boolean addAll(Collection<? extends E> c) {    
        return addAll(size, c);
    }

4.17 addAll(int index, Collection<? extends E> c)：在下标index后面将集合元素添加至list

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

首先判断下标是否在list内；
将集合转成对象数组a,numNew记录a的长度，如果集合为空，则返回false;
声明两个节点prev和succ，如何下标index等于当前list长度，则说明是在list尾部添加元素，节点pred指向尾节点，succ为null,否则succ指向index下标的节点，pred指向succ的前驱节点；
遍历对象数组a，创建新节点newNode，如果prev为空，则说明prev为头结点，即头结点指向新节点，否则pred的后驱节点指向新节点，同时将pred指向新节点；
如果节点succ为null，则尾节点指向pred，否将pred和succ节点的前驱和后驱相互指向，使其连接；
list长度增加numNew，操作次数自增，返回true.

4.18 public void clear():清除list元素

public void clear() {  
    // Clearing all of the links between nodes is "unnecessary", but:    
    // - helps a generational GC if the discarded nodes inhabit  
    //   more than one generation  
    // - is sure to free memory even if there is a reachable 
    Iterator    for (Node<E> x = first; x != null; ) {   
        Node<E> next = x.next;   
        x.item = null;      
        x.next = null;    
        x.prev = null;      
        x = next;  
        } 
        first = last = null;  
        size = 0; 
        modCount++;
    }

使用迭代器遍历list节点元素，所有节点设为null，长度设置为0，修改次数自增。

4.19 public E get(int index) ：获取下标下的对象

public E get(int index) { 
        checkElementIndex(index);
        return node(index).item;
    }

校验下标是否在list区间内，通过node获取某下标节点，并返回其item。

4.20 public E 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;
    }

4.21 public void add(int index, E element):在下标index处插入新元素

public void add(int index, E element) {
        checkPositionIndex(index);  
        if (index == size)    
            linkLast(element); 
        else    
          linkBefore(element, node(index));
     }

4.22 public E remove(int index):删除某下标处元素

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

4.23 Node node(int 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在list区间内，遍历时，采用一次二分遍历。

4.24 public int indexOf(Object o):获取对象o第一次在list出现的下标

public int indexOf(Object o) {  
        int index = 0;    
        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;
    }

找到返回下标，未找到返回-1，判断对象是否相等分null和非null。

4.25 public int lastIndexOf(Object o) :获取对象o最后一次在list出现的下标

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

逻辑基本与4.24一致，不过遍历是从后往前查询。

4.26 public E peek()：获取第一个元素（可以为null）

public E peek() {  
        final Node<E> f = first;
        return (f == null) ? null : f.item;
}

4.27 public E element() ：获取第一个元素（不能为null）

public E element() { 
        return getFirst();
}

4.28 public E poll() ：获取第一个元素并删除（可以为null）

public E poll() { 
        final Node<E> f = first;  
        return (f == null) ? null : unlinkFirst(f);
    }

4.29 E remove() ：删除第一个元素（不能为null）

public E remove() {  
        return removeFirst();
    }

4.30 public boolean offer(E e)：在list尾部添加元素

public boolean offer(E e) {
        return add(e);
    }

4.31 public boolean offerFirst(E e)：元素放置在头节点

public boolean offerFirst(E e) {  
        addFirst(e); 
        return true;
}

4.32 public boolean offerLast(E e)：元素放置在尾节点

public boolean offerLast(E e) {
        addLast(e); 
        return true;
    }

4.33 public E peekFirst()：获取第一个元素（可以为null）

public E peekFirst() { 
        final Node<E> f = first;
        return (f == null) ? null : f.item; 
    }

4.34 public E peekLast() ：：获取最后一个元素（可以为null）

public E peekLast() {  
        final Node<E> l = last; 
        return (l == null) ? null : l.item;
}

4.35 public E pollFirst()：弹出第一个元素并将其移除（可以为null）

public E pollFirst() { 
        final Node<E> f = first; 
        return (f == null) ? null : unlinkFirst(f);
    }

4.36 public E pollLast() ：弹出最后一个元素并将其移除（可以为null）

public E pollLast() { 
        final Node<E> l = last; 
        return (l == null) ? null : unlinkLast(l);
    }

4.37 public void push(E e) ：添加到头节点

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

4.38 public E pop() ：移除头节点（不能为null）

public E pop() {
        return removeFirst();
    }

4.39 public boolean removeFirstOccurrence(Object o) ：移除某元素（第一次出现的位置）

public boolean removeFirstOccurrence(Object o) {
        return remove(o);
    }

4.40 public boolean removeLastOccurrence(Object o)：移除元素在list最后出现的位置

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

五、内部类

private static class Node

private class ListItr implements ListIterator

static final class LLSpliterator implements Spliterator

private class DescendingIterator implements Iterator

暂不解析，具体看其源码