Java集合之LinkedList

  前面写过ArrayList，此类继承了RandomAccess这个标记接口，标记其随机访问速度快(例如使用get方法，set方法等通过索引直接定位的方法)，因为其底层是数组，所以直接通过索引定位速度较快。而LinkedList底层是链表，随机访问速度相对较慢，因此其要一步步移动指针来定位；但是执行插入或删除时，LinkedList较快，因此其直接指针修改即可，而ArrayList要重新移动数据来填补空间。因此在遍历时，LinkedList使用迭代器速度会较快，而通过索引值去访问会比较慢，而ArrayList与此相反。

public class LinkedList<E>//可克隆、序列化，非线程安全。   JDK1.7    java.util
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
    transient int size = 0;//实际元素个数
    transient Node<E> first;//链表表头结点
    transient Node<E> last;//表尾结点
    public LinkedList() {//无参构造器
    }
    public LinkedList(Collection<? extends E> c) {//用集合来构造
        this();
        addAll(c);
    }
    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;
        }
    }
    public E getFirst() {//返回此列表的第一个元素
        final Node<E> f = first;//获取第一个结点
        if (f == null)//列表为空，则抛出异常
            throw new NoSuchElementException();
        return f.item;
    }
    public E getLast() {//返回此列表的最后一个元素
        final Node<E> l = last;//获取最后一个结点
        if (l == null)//列表为空，则抛出异常
            throw new NoSuchElementException();
        return l.item;
    }
    public E removeFirst() {//移除并返回此列表的第一个元素。
        final Node<E> f = first;//获取第一个结点
        if (f == null)//列表为空，则抛出异常
            throw new NoSuchElementException();
        return unlinkFirst(f);
    }
    private E unlinkFirst(Node<E> f) {
        final E element = f.item;//获取第一个结点的元素
        final Node<E> next = f.next;//获取下一个结点
        f.item = null;
        f.next = null; //f结点(初始结点)没用了。帮助GC回收
        first = next;//删除之后原先的下一个结点就变成第一个结点
        if (next == null)//如果原来的下一个结点为null
            last = null;//则列表实际为null
        else
            next.prev = null;//初始结点的上一个结点必须为null
        size--;//元素个数-1
        modCount++;//操作次数加1
        return element;//返回删除的元素
    }
    public E removeLast() {//移除并返回此列表的最后一个元素。
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();//为空则异常
        return unlinkLast(l);
    }
    private E unlinkLast(Node<E> l) {
        final E element = l.item;//获取最后一个结点的元素
        final Node<E> prev = l.prev;//获取前一个结点
        l.item = null;
        l.prev = null; // help GC
        last = prev;//删除之后的最后一个结点
        if (prev == null)//如果原来的前一个结点为null
            first = null;//则列表实际为null
        else
            prev.next = null;//现在最后一个结点的下一个结点必须为null
        size--;//元素个数-1
        modCount++;//操作次数加1
        return element;
    }
    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);//创建基于e的新结点
        first = newNode;
        if (f == null)
            last = newNode;//如果只有该结点一个元素。则起始结点等于末尾结点
        else
            f.prev = newNode;//把原先起始结点中的prev属性指向现在的起始结点
        size++;//元素个数+1
        modCount++;//操作次数+1
    }
    public void addLast(E e) {//将指定元素添加到此列表的结尾。 
        linkLast(e);
    }
    void linkLast(E e) {
        final Node<E> l = last;//保存原先的末尾结点
        final Node<E> newNode = new Node<>(l, e, null);//创建基于e的新结点
        last = newNode;
        if (l == null)
            first = newNode;//如果只有该结点一个元素。则起始结点等于末尾结点
        else
            l.next = newNode;//把原先末尾结点中的next属性指向现在的末尾结点
        size++;//元素个数+1
        modCount++;//操作次数+1
    }
    public boolean contains(Object o) {//是否包含元素
        return indexOf(o) != -1;
    }
    public int size() {//元素个数
        return size;
    }
    public boolean add(E e) {//将指定元素添加到此列表的结尾，此方法等效于 addLast(E)。 
        linkLast(e);
        return true;
    }
    public boolean remove(Object o) {//从此列表中移除首次出现的指定元素（如果存在）。如果列表不包含该元素，则不作更改
        if (o == null) {
            for (Node<E> x = first; x != null; x = x.next) {//遍历全部结点
                if (x.item == null) {//为null时
                    unlink(x);
                    return true;
                }
            }
        } else {
            for (Node<E> x = first; x != null; x = x.next) {//遍历全部结点
                if (o.equals(x.item)) {//不为null时
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
    }
    public boolean addAll(Collection<? extends E> c) {//添加指定 collection 中的所有元素到此列表的结尾
        return addAll(size, c);
    }
    public boolean addAll(int index, Collection<? extends E> c) {//index开始插入的索引,从0开始
        checkPositionIndex(index);//index校验  0 <= index <= size
        Object[] a = c.toArray();
        int numNew = a.length;
        if (numNew == 0)
            return false;//如果数组长度为0，则直接返回false

        Node<E> pred, succ;//succ为起始位置的结点，pred为起始位置的前一个结点。于是新的集合就在pred和succ之间
        if (index == size) {
            succ = null;//此时在末尾插入
            pred = last;
        } else {
            succ = node(index);//获取原列表中第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;//pred指向最末尾结点
        } else {
            pred.next = succ;
            succ.prev = pred;
        }
        size += numNew;
        modCount++;
        return true;
    }
    Node<E> node(int index) {//返回第index个结点
        if (index < (size >> 1)) {//index小于size/2
            Node<E> x = first;
            for (int i = 0; i < index; i++)//从前往后遍历
                x = x.next;//从first开始一直找下一个结点
            return x;
        } else {                  //index大于等于size/2
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)//从后往前遍历
                x = x.prev;
            return x;//从last开始一直找前一个结点
        }
    }
    public void clear() {
        for (Node<E> x = first; x != null; ) {
            Node<E> next = x.next;//每个结点的所有属性全部置为null
            x.item = null;
            x.next = null;
            x.prev = null;
            x = next;
        }
        first = last = null;//清空first、last
        size = 0;//元素个数为0
        modCount++;//修改次数+1
    }
    public E get(int index) {//返回此列表中指定位置处的元素
        checkElementIndex(index);//参数校验
        return node(index).item;//直接获取该结点元素
    }
    public E set(int index, E element) {//将此列表中指定位置的元素替换为指定的元素
        checkElementIndex(index);
        Node<E> x = node(index);//直接拿到该结点进行操作，只需操作该结点自身。
        E oldVal = x.item;
        x.item = element;
        return oldVal;
    }
    public void add(int index, E element) {//在此列表中指定的位置插入指定的元素
        checkPositionIndex(index);

        if (index == size)
            linkLast(element);//直接末尾添加
        else
            linkBefore(element, node(index));
    }
    void linkBefore(E e, Node<E> succ) {
        final Node<E> pred = succ.prev;//e将位于pred和succ之间
        final Node<E> newNode = new Node<>(pred, e, succ);//e的前一个结点是pred，后一个是succ，直接构造
        succ.prev = newNode;
        if (pred == null)
            first = newNode;
        else
            pred.next = newNode;
        size++;//元素个数+1
        modCount++;//操作次数+1
    }
    public E remove(int index) {//移除此列表中指定位置处的元素
        checkElementIndex(index);
        return unlink(node(index));
    }
    E unlink(Node<E> x) {
        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;
    }
    private boolean isElementIndex(int index) {//参数校验
        return index >= 0 && index < size;
    }
    private boolean isPositionIndex(int index) {//参数校验
        return index >= 0 && index <= size;
    }
    private String outOfBoundsMsg(int index) {//异常信息封装
        return "Index: "+index+", Size: "+size;
    }
    private void checkElementIndex(int index) {//参数校验
        if (!isElementIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
    private void checkPositionIndex(int index) {//参数校验
        if (!isPositionIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
    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)//为null
                    return index;
                index++;
            }
        } else {
            for (Node<E> x = first; x != null; x = x.next) {//遍历全部结点
                if (o.equals(x.item))//不为null
                    return index;
                index++;
            }
        }
        return -1;//如果此列表中不包含该元素，则返回 -1
    }
    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)//为null
                    return index;
            }
        } else {
            for (Node<E> x = last; x != null; x = x.prev) {
                index--;
                if (o.equals(x.item))//不为null
                    return index;
            }
        }
        return -1;//如果此列表中不包含该元素，则返回 -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 true;
    }
    public boolean offerLast(E e) {//在此列表末尾插入指定的元素
        addLast(e);
        return true;
    }
    public E peekFirst() {//获取但不移除此列表的第一个元素；如果此列表为空，则返回 null
        final Node<E> f = first;
        return (f == null) ? null : f.item;
     }
    public E peekLast() {//获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null
        final Node<E> l = last;
        return (l == null) ? null : l.item;
    }
    public E pollFirst() {//获取并移除此列表的第一个元素；如果此列表为空，则返回 null
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
    }
    public E pollLast() {//获取并移除此列表的最后一个元素；如果此列表为空，则返回 null
        final Node<E> l = last;
        return (l == null) ? null : unlinkLast(l);
    }
    public void push(E e) {//将元素推入此列表所表示的堆栈。换句话说，将该元素插入此列表的开头
        addFirst(e);
    }
    public E pop() {//从此列表所表示的堆栈处弹出一个元素。换句话说，移除并返回此列表的第一个元素
        return removeFirst();
    }
    public boolean removeFirstOccurrence(Object o) {//从此列表中移除第一次出现的指定元素
        return remove(o);
    }
    public boolean removeLastOccurrence(Object o) {//从此列表中移除最后一次出现的指定元素
        if (o == null) {
            for (Node<E> x = last; x != null; x = x.prev) {//从后往前遍历
                if (x.item == null) {//null
                    unlink(x);
                    return true;
                }
            }
        } else {
            for (Node<E> x = last; x != null; x = x.prev) {//从后往前遍历
                if (o.equals(x.item)) {//不为null
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
    }
    public ListIterator<E> listIterator(int index) {//返回此列表中的元素的列表迭代器，从列表中指定位置开始
        checkPositionIndex(index);//校验index
        return new ListItr(index);
    }
    //双向迭代器的内部实现
    private class ListItr implements ListIterator<E> {
        private Node<E> lastReturned = null;//前一次迭代的结点
        private Node<E> next;//迭代的结点
        private int nextIndex;//迭代的索引
        private int expectedModCount = modCount;//expectedModCount期望修改次数，最初等于实际修改次数

        ListItr(int index) {
            next = (index == size) ? null : node(index);//初始化迭代的结点
            nextIndex = index;//初始化索引
        }

        public boolean hasNext() {
            return nextIndex < size;//迭代的索引小于元素个数，有元素可以继续迭代
        }

        public E next() {//返回迭代获取的元素
            checkForComodification();//校验expectedModCount = modCount是否成立，见AbstractList源码分析
            if (!hasNext())
                throw new NoSuchElementException();//无元素可以迭代，抛出异常

            lastReturned = next;
            next = next.next;
            nextIndex++;
            return lastReturned.item;
        }

        public boolean hasPrevious() {//向前迭代是否有元素
            return nextIndex > 0;
        }

        public E previous() {//前一个元素
            checkForComodification();
            if (!hasPrevious())
                throw new NoSuchElementException();
            //next为null，前一个就为last结点，否则为next.prev
            lastReturned = next = (next == null) ? last : next.prev;
            nextIndex--;
            return lastReturned.item;
        }

        public int nextIndex() {//索引
            return nextIndex;
        }

        public int previousIndex() {//前一个索引
            return nextIndex - 1;
        }

        public void remove() {//移除当前元素
            checkForComodification();//校验expectedModCount = modCount是否成立
            if (lastReturned == null)
                throw new IllegalStateException();

            Node<E> lastNext = lastReturned.next;
            unlink(lastReturned);
            if (next == lastReturned)
                next = lastNext;
            else
                nextIndex--;
            lastReturned = null;
            expectedModCount++;
        }

        public void set(E e) {//修改元素
            if (lastReturned == null)
                throw new IllegalStateException();
            checkForComodification();
            lastReturned.item = e;
        }

        public void add(E e) {//新增元素
            checkForComodification();
            lastReturned = null;
            if (next == null)
                linkLast(e);
            else
                linkBefore(e, next);
            nextIndex++;
            expectedModCount++;
        }

        final void checkForComodification() {//校验modCount = expectedModCount
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }
    public Iterator<E> descendingIterator() {//返回以逆向顺序在此双端队列的元素上进行迭代的迭代器
        return new DescendingIterator();
    }
    private class DescendingIterator implements Iterator<E> {//该迭代器的实现
        private final ListItr itr = new ListItr(size());//将双向迭代器的初始索引指向末尾
        public boolean hasNext() {
            return itr.hasPrevious();//向前迭代
        }
        public E next() {
            return itr.previous();//前一个元素
        }
        public void remove() {//删除
            itr.remove();
        }
    }

    @SuppressWarnings("unchecked")
    private LinkedList<E> superClone() {
        try {
            return (LinkedList<E>) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new InternalError();
        }
    }
    public Object clone() {//浅复制
        LinkedList<E> clone = superClone();

        clone.first = clone.last = null;
        clone.size = 0;
        clone.modCount = 0;

        for (Node<E> x = first; x != null; x = x.next)//遍历结点
            clone.add(x.item);

        return clone;
    }
    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;
    }
    @SuppressWarnings("unchecked")
    public <T> T[] toArray(T[] a) {//转化为数组，保留类型
        if (a.length < size)
            a = (T[])java.lang.reflect.Array.newInstance(
                                a.getClass().getComponentType(), size);
        int i = 0;
        Object[] result = a;
        for (Node<E> x = first; x != null; x = x.next)
            result[i++] = x.item;

        if (a.length > size)
            a[size] = null;

        return a;
    }

    private static final long serialVersionUID = 876323262645176354L;//版本号
    private void writeObject(java.io.ObjectOutputStream s)//序列化
        throws java.io.IOException {
        s.defaultWriteObject();
        s.writeInt(size);//写入元素个数
        for (Node<E> x = first; x != null; x = x.next)
            s.writeObject(x.item);//写入每个结点
    }
    @SuppressWarnings("unchecked")
    private void readObject(java.io.ObjectInputStream s)//反序列化
        throws java.io.IOException, ClassNotFoundException {
        s.defaultReadObject();
        //独处元素个数
        int size = s.readInt();
        for (int i = 0; i < size; i++)
            linkLast((E)s.readObject());//读出每个节点
    }
}