LinkedList源码解析

UML

public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, Serializable {
    // linkedList大小
    transient int size = 0；
    
    // 头节点
    transient Node<E> first;
    
    // 尾节点
    transient Node<E> last;
    
    public LinkedList() {}
    
    public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
    }
    
    /**
     * 在头部插入一个元素
     */
    private void linkedFirst(E e) {
        // 原头部元素
        final Node<E> f = first;
        // 新建节点
        final Node<E> newNode = new Node<>(null, e, f);
        // 头部节点指向新建节点
        first = newNode;

        if(f == null) {
            // 如果原头部节点为null，则说明链表是空的，将尾指针也指向新建节点
            last = newNode;
        }else {
            // 原头部节点不为空，说明链表不为空，将原头部的前驱设置为新建节点
            f.prev = newNode;
        }
        size++;
        modCount++;
    }
    
    /**
     * 在尾部插入元素
     */
    void linkedLast(E e) {
        // 原尾部元素
        final Node<E> l = last;
        // 新建节点
        final Node<E> newNode = new Node<>(l, e, null);
        // 将尾节点指向newNode
        last = newNode;
        if(l == null) {
            // 如果原尾节点为null，说明原链表为空，将first也指向新建节点
            first = newNode
        }else {
            // 如果原尾节点不为null，说明原链表不为空，将原尾节点的后驱指向新建节点
            l.next = newNode;
        }
        size++;
        modCount++;
    }
    
    /**
    * 在非空节点succ前插入节点e
    */
    void linkedBefore(E e, Node<E> succ) {
        // 获取succ的前驱
        final Node<E> pred = succ.prev;
        // 新建节点
        final Node<E> newNode = new Node<>(pred, e, succ);
        // 将succ的前驱指向newNode
        succ.prev = newNode;
        
        if(pred == null) {
            // 如果succ的原前驱为null，说明succ是头节点，则将头节点指向新建节点
            first = newNode;
        }else {
            // succ的前驱不为null，则将succ前驱的next指向newNode
            pred.next = newNode;
        }
        size++;
        modCount++;
    }
    
    /**
     * 移除头节点
     */
    private E unlinkedFirst(Node<E> f) {
        // 头节点值
        final E element = f.item;
        // 头节点的后驱
        final Node<E> next = f.next;
        // 将头节点的值和next设置为空
        f.item = null;
        f.next = null;
        // 将后驱设置为头节点
        first = next;
        if(next == null) {
            // 如果next为null，说明只有一个元素，将last也设置为null
            last == null;
        }else {
            // 将next的前驱设置为null
            next.prev = null;
        }
        size--;
        modCount++;
        return element;
    }
    
    /**
     * 移除尾节点
     */
    private E unlinkLast(Node<E> l) {
        // 尾节点值
        final E element = l.item;
        // 尾节点的前驱
        final Node<E> prev = l.prev;
        // 将尾节点的值和前驱设置为null
        l.item = null;
        l.prev = null;
        // 将尾节点指向prev
        last = prev;
        if(prev == null) {
            // 如果prev为null，说明只有一个元素，移除后链表为空，所以把first设置为null
            first = null;
        }else {
            // 前驱的next设置为null
            prev.next = null;
        }
        size--;
        modCount++;
        return element;
    }
    
    /**
     * 删除某个节点
     */
    E unlink(Node<E> x) {
        // 获取到x的的值，前驱、后驱
        final E element = x.item;
        final Node<E> next = x.next;
        final Node<E> prev = x.prev;
        if(prev == null) {
            // x的前驱为null，说明x是头节点，移除x之后，next为头节点
            first = next;
        }else {
           // x的前驱不为null，将x的前驱的next指向next
            prev.next = next;
            // x的前驱设为null
            x.prev = null;
        }
        if(next == null) {
            // x的后驱为null，说明是尾节点，将x的前驱设置为尾节点
            last = prev;
        }elsee {
            // x的后驱不为null，将next的前驱设置为x的前驱
            next.prev = prev;
            // 将x的后驱设置为null
            x.next = null;
        }
        // x的值设为null
        x.item = null;
        size--;
        modCount++;
        return element;
    }
    
    /**
     * 获取头节点元素值
     * 如果头节点为null，抛出异常，不空返回item
     */
    public E getFirst() {
        final Node<E> f = first;
        if(f == null) {
            throw new NoSuchElementException();
        }
        return f.item;
    }
    
    /**
     * 获取尾节点元素值
     * 如果尾节点为null，抛出异常，不空返回item
     */
    public E getLast() {
        final Node<E> l = last;
        if(l == null) {
            throw new NoSuchElemtnException();
        }
        return l.item;
    }
    
    /**
     * 移除头部节点
     */
    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();
    } 
    
    /**
     * 添加元素至头部
     */
    public void addFirst(E e) {
        linkFirst(e);
    }
    
    /**
     * 添加元素到尾部
     */
    public void addLast(E e) {
        linkLast(e);
    }
    
    /**
     * 是否包含对象o
     * 如果对象o的索引位置不等于-1，则表示包含对象o
     */
    public boolean contains(Object o) {
        return indexOf(o) != -1;
    }
    
    /**
     * 返回元素数量
     */
    public int size() {
        return size;
    }
    
    /**
     * 添加元素到头部
     */
    public boolean add(E e) {
        linkFist(e);
        return true;
    }
    
    /**
     * 移除某个元素。 如果移除对象存在返回true，否则返回false
     */
    public boolean remove(Object o) {
        // 移除对象为null，则从头部开始查找第一个为null的元素
        if(o == null) {
            for(Node<E> x = first; x != null; x = x.next) {
                if(x.item == null) {
                    // 找到为null的元素，进行移除，返回true
                    unlink(x);
                    return true;
                }
            }
        }
        // 移除元素不为null，从头部开始查找第一个与o相等得元素
        else {
            for(Node<E> x = first; x != null; x = x.next) {
                if(o.equals(x.item)) {
                    // 找到与object相等的元素，进行移除，返回true
                    unlink(x);
                    return true;
                }
            }
        }
        // 没有找到，返回false
        return false;
    }
    
    /**
     * 在尾部添加一个集合c
     */
    public boolean addAll(Collection<? extends E> c) {
        return addAll(size, c);
    }
    
    /**
     * 添加一个集合c在index位置
     */
    public boolean addAll(int index, Collection<? extends E> c) {
        // 检查index对象是否越界，index大于等于0，小于等于size 
        checkPositionIndex(index);
        // 集合转数组
        Object[] a = c.toArray();
        int numNew = a.length;
        // 如果添加的元素个数为0，返回false
        if(numNew == 0) {
            return false;
        }
        
        Node<E> pred, succ;
        // 如果index == size，说明是添加在尾部，只需要获取到尾部节点即可
        if(index == size) {
            succ = null;
            pred = last;
        }
        // 添加位置不是尾部，不需要获取到index位置的元素succ，并获取到succ的前驱
        else {
            succ = node(index);
            pred = succ.prev;
        }
        
        // 遍历数组形成链表
        for(Object o : a) {
            // 强转
            E e = (E) o;
            // 新建节点
            Node<E> newNode = new Node<>(pred, e, null);
            // 如果pred为null，说明是空链表，将新建节点设置头节点
            if(pred == null) {
                first = newNode;
            }
            // 不是空链表，将当前节点设为pred的后驱
            else {
                pred.next = newNode;
            }
            // 新建节点为pred
            pred = newNode;
        }
        
        // 如果index位置不存在节点，即添加在尾部
        if(succ == null) {
            // 最后一个新建节点作为last
            last = newNode;
        }
        // index位置存在节点
        else {
            // 最后一个集合元素的next指向原index位置元素
            pred.next = succ;
            // 原index位置的元素的前驱指向集合最后一个节点
            succ.prev = pred;
        }
        size++;
        modCount++;
        return true;
    }
    
    /**
     * 清空链表
     * 遍历节点将每个节点的item，next、prev置空，同时将first、、last置空，size置为0
     */
    public void clear() {
        // 遍历节点，置空item。next、prev
        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
        first = last = null;
        // size置为0
        size = 0;
        modCount++;
    }
    
    /**
     * 获取index位置的元素值
     */
    public E get(int index) {
        // 检查是否越界
        checkElementIndex(index);
        return node(index).item;
    }
    
    
    /**
     * 将index位置的元素的元素自设置为element
     */
    public E set(int index, E element) {
        // 检车是否越界
        checkElementIndex(index);
        // 获取index位置的元素
        Node<E> x = node(index);
        // 获取到旧元素值
        E oldVal = x.item;
        // 赋值为新的元素值
        x.item = element;
        // 返回旧的元素值
        return oldVal;
    }
    
    /**
     * 添加元素至index位置
     */
    public void add(int index, E element) {
        // 检查是否越界
        checkPositionIndex(index);
        
        if(index == size) {
            // 如果index == size，那么添加到队列尾部
            linkLast(element);
        }else {
            // 添加在index位置，找到原index位置元素，添加在其位置，原元素后移一位
            linkBefore(element, node(index));
        }
    }
    
    /**
     * 移除index位置的元素
     */
    public E remove(int index) {
        // 检查是否越界
        checkElementIndex(index);
        return unlink(node(index));
    }
    
    private boolean isElementIndex(int index) {
        return index >= 0 && index < size;
    }
    
    private boolean isPositionIndex(int index) {
        return index >= 0 && index <= size;
    }
    
    private String checkElementIndex(int index) {
        if(!isElementIndex(index)) {
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
        }
    }
    
    private void checkPositionIndex(int index) {
        if(!isPositionIndex(index)) {
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
        }
    }
    
    /**
     * 获取index位置的元素
     */
    Node<E> node(int 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;
        }
    }
    
    /**
     * 获取对象在链表中位置（相对于头部）
     */ 
    public int indexOf(Object o) {
        int index = 0;
        // 对象o为null
        if(o == null) {
            for(Node<E> x = first; x != null; x.next) {
                if(x.item == null) {
                    return index;
                }
                index++;
            }
        }
        // 对象o不为null
        else {
            for(Node<E> x = first; x != null; x.next) {
                if(o.equals(x.item)) {
                    return index;
                }
                index++;
            }
        }
        return -1;
    }
    
    
    /**
     * 获取对象在链表中位置（相对于尾部）
     */
    public int lastIndexOf(Object o) {
        int index = size;
        // 对象o为null
        if(o == null) {
            for(Node<E> x = last; x != null; x = x.prev) {
                index--;
                if(x.item == null) {
                    return index;
                }
            }
        }
        // 对象o不为null
        else {
            for(Node<E> x = last; x != null; x.prev) {
                index--;
                if(o.equals(x.item)) {
                    return index;
                }
            }
        }
        return -1;
    }
    
    /**
     * 获取头部元素
     */
    public E peek() {
        final Node<E> f = first;
        return (f == null) ? null : f.item;
    }
    
    /**
     * 获取头部元素
     */
    public E element() {
        return getFirst();
    }
    
    /**
     * 移除一个元素，从头部移除
     */
    public E poll() {
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
    }
    
    /**
     * 移除一个元素，模式移除头部，链表为空，将会抛出异常
     */
    public E remove() {
        return removeFirst();
    }
    
    /**
     * 添加一个元素到尾部
     */ 
    public boolean offer(E e) {
        return add(e);
    }
    
    /**
     * 添加一个元素到头部
     */ 
    public boolean offerFirst(E e) {
        addFirst(e);
        return retrue;
    }
    
    /**
     * 添加一个元素到尾部
     */
    public boolean offerLast(E e) {
        addLast(e);
        return true;
    }
    
    
    /**
     * 返回头部元素值
     */
    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
    }
    
    /**
     * 移除头部元素
     */ 
    public E pollFirst() {
        final Node<E> f = first;
        return (f == null) ? f : unlinkFirst(f);
    }
    
    /**
     * 移除尾部元素
     */
    public E pollLast() {
        final Node<E> l = last;
        return (l == null) ? null : unlinkLast(l);
    }
    
    /**
     * 头部添加元素
     */
    public void push(E e) {
        addFirst(e);
    }
    
    /**
     * 头部移除元素
     */
    public void pop() {
        return removeFirst();
    }
    
    /**
     * 链表转数组
     */
    public Object[] toArray() {
        Object[] result = new Object[size];
        int i = 0;
        for(Node<E> x = first; x != null; x = x.next) {
            result[i++] = x.item;
        }
        return result;
    }
    
    /**
     * 序列化
     */
    private void writeObject(ObjectOutputStream s) throw IOException {
        s.defaultWriteObject();
        s.writeInt(size);
        for(Node<E> x = first; x != null; x = x.next) {
            s.writeObject(x.item);
        }
    }
    
    /**
     * 反序列化
     */ 
    private void readObject(ObjectInputStream s) throw IOEception{
        s.defaultReadObject();
        int size = s.readInt();
        for(int i = 0; i < size; i++) {
            linkLast((E)s.readObject());
        }
    }
    
    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;
        }
    }
}

add(E e)	添加在尾部
remove(Object o)	找到并移除
addFirst(E e)	头部添加一个元素
removeFirst()	头部移除一个元素，如果链表为空，抛出异常
addLast(E e)	尾部添加一个元素
removeLast()	尾部移除一个元素，如果链表为空，抛出异常
remove()	调用removeFirst(), 从头部移除一个元素

peek()	取到第一个元素，不会对元素进行移除
element()	取到第一个元素，不会对元素进行移除，但如果链表为空，抛出异常
poll()	头部移除一个元素，链表空时返回null
remove()	头部移除一个元素，链表为空时抛出异常

offer(E)	添加元素到链表尾部
offerFirst(E)	添加元素到链表头部
offerLast(E)	添加元素到链表尾部

push()	头部添加一个元素
pop()	头部移除一个元素，链表为空时抛出异常