Java数据结构－LinkedList（四）

参考博客：http://www.cnblogs.com/skywang12345/p/3561803.html，表示感谢！

LinkedList 是List接口的一个基于双向链表的实现类，继承了AbstractSequentialList类，实现了List接口，Queue接口（队列），Deque（双端队列），Cloneable接口，Serializable接口。因此LinkedList具有队列的特点，可以作为堆栈，队列，双端队列使用。

和ArrayList一样，LinkedList也是非同步的，如果不需要使用队列的特性的话，一般使用ArrayList。

遍历LinkedList时，使用removeFist()或removeLast()效率最高。但用它们遍历时，

会删除原始数据；若单纯只读取，而不删除，应该使用增强for循环或者iterator的方式，

千万不要使用角标访问的形式来遍历。

LinkedList与Collection关系如下图：

LinkedList的本质是一个双向链表，那么什么是双向链表呢？

双向链表(双链表)是链表的一种。双链表由一个个节点组成，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。

双链表的示意图如下：

表头为空，表头的后继节点为"节点10"(数据为10的节点)；"节点10"的后继节点是"节点20"(数据为10的节点)，"节点20"的前继节点是"节点10"；"节点20"的后继节点是"节点30"，"节点30"的前继节点是"节点20"；...；末尾节点的后继节点是表头。

双链表删除节点

双链表添加节点

LinkedList源码分析：

package java.util;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.lang.reflect.Array;

/**
 * @since 1.2
 */
public class LinkedList extends AbstractSequentialList implements
        List, Deque, Queue, Cloneable, Serializable {

    private static final long serialVersionUID = 876323262645176354L;
    
    //LinkedList中的元素的数量
    transient int size = 0;
    
    //双链表中的head，它是空的，不保存数据
    transient Link voidLink;
    
    //LinkedList中的节点，用来保存数据，
    //每个节点包含向前 向后的节点的引用以及本节点的数据
    private static final class Link {
        ET data;

        Link previous, next;

        Link(ET o, Link p, Link n) {
            data = o;
            previous = p;
            next = n;
        }
    }
    
    
    //LinkedList内部的iterator实现，可以用来进行遍历以及数据的增删修改
    private static final class LinkIterator implements ListIterator {
        int pos, expectedModCount;

        final LinkedList list;
        
        //当前节点 最后节点的引用
        Link link, lastLink;
        
        //从指定位置返回LinkedList的iterator
        LinkIterator(LinkedList object, int location) {
            list = object;
            expectedModCount = list.modCount;
            
            //检查角标是否越界
            if (location >= 0 && location <= list.size) {
                // pos ends up as -1 if list is empty, it ranges from -1 to
                // list.size - 1
                // if link == voidLink then pos must == -1
                
                //获取LinkedList的head节点
                link = list.voidLink;
                
                //根据指定位置判断其位于LinkedList前半部分还是后半部分，
                //然后决定是从开始查找，还是从后开始查找，
                //找到指定位置的节点。
                //这种根据位置来决定从前半部分还是后半部分查找的方法在LinkedList中很常见也很有效
                if (location < list.size / 2) {
                    for (pos = -1; pos + 1 < location; pos++) {
                        link = link.next;
                    }
                } else {
                    for (pos = list.size; pos >= location; pos--) {
                        link = link.previous;
                    }
                }
            } else {
                throw new IndexOutOfBoundsException();
            }
        }
        
        //通过iterator添加元素
        
        public void add(ET object) {
            if (expectedModCount == list.modCount) {
                Link next = link.next;//获取当前节点的下一个节点
                //为需要添加的新元素创建一个新的节点对象
                //新节点的前一个节点指向当前节点
                //新节点的后一个节点指向当前节点的原来的后一节点
                //即将新的节点插入原节点于其后一节点之间
                Link newLink = new Link(object, link, next);
                link.next = newLink;//将当前节点的下一个节点指向新建的节点
                next.previous = newLink;//将原节点的后一节点的向前的引用指向新的节点
                link = newLink;//将原节点的引用指向新添加的节点
                lastLink = null;//将原来最后一个节点的引用释放，因为位置发生改变
                pos++;          //指针位置移动
                expectedModCount++;//预期修改次数加一
                list.size++;        //LinkedList元素数量加一
                list.modCount++;    //LinkedList修改次数加一
            } else {
                throw new ConcurrentModificationException();
            }
        }
        
        //返回当前指针位置后面是否还有元素
        //如果该节点后面是head节点，则其为LinkedList最后一个节点
        //否则后面还有其他元素
        public boolean hasNext() {
            return link.next != list.voidLink;
        }
        
        //返回当前指针位置前面是否还有元素
        //如果当前节点不是head节点那么其前面还有元素
        public boolean hasPrevious() {
            return link != list.voidLink;
        }
        
        //获取当前指针位置后面的节点中的元素
        public ET next() {
            if (expectedModCount == list.modCount) {//fail-fase判断
                LinkedList.Link next = link.next;//获取当前阶段的下一节点
                if (next != list.voidLink) {//判断是否已经到末尾
                    lastLink = link = next;//更新引用，向前移动
                    pos++;                  //指针位置向前移动
                    return link.data;       //返回数据
                }
                throw new NoSuchElementException();
            }
            throw new ConcurrentModificationException();
        }
    
    
        //返回下一角标，即指针位置加一
        //指针开始位置为－1，角标开始为0
        public int nextIndex() {
            return pos + 1;
        }
        
        //返回当前指针位置的前一个元素
        public ET previous() {
            if (expectedModCount == list.modCount) {
                if (link != list.voidLink) {
                    lastLink = link;
                    link = link.previous;
                    pos--;
                    return lastLink.data;
                }
                throw new NoSuchElementException();
            }
            throw new ConcurrentModificationException();
        }
        
        //返回当前指针位置的前一角标，即指针本身位置
        //因为指针总是在角标的前一位
        public int previousIndex() {
            return pos;
        }


        //移除LinkedList的一个元素
        public void remove() {
            if (expectedModCount == list.modCount) {
                if (lastLink != null) {
                    Link next = lastLink.next;
                    Link previous = lastLink.previous;//获取lastLink前后节点引用
                    next.previous = previous;
                    previous.next = next;//将lastLink前后节点连接起来
                    if (lastLink == link) {
                        pos--;          //如果移除的是最后一个节点，指针位置减一
                    }
                    link = previous;
                    lastLink = null;
                    expectedModCount++;
                    list.size--;
                    list.modCount++;
                } else {
                    throw new IllegalStateException();
                }
            } else {
                throw new ConcurrentModificationException();
            }
        }
        
        //修改lastLink节点的值
        public void set(ET object) {
            if (expectedModCount == list.modCount) {
                if (lastLink != null) {
                    lastLink.data = object;
                } else {
                    throw new IllegalStateException();
                }
            } else {
                throw new ConcurrentModificationException();
            }
        }
    }

    //倒序的iterator
    private class ReverseLinkIterator implements Iterator {
        private int expectedModCount;

        private final LinkedList list;

        private Link link;

        private boolean canRemove;

        ReverseLinkIterator(LinkedList linkedList) {
            list = linkedList;
            expectedModCount = list.modCount;
            link = list.voidLink;
            canRemove = false;
        }

        public boolean hasNext() {
            return link.previous != list.voidLink;
        }

        public ET next() {
            if (expectedModCount == list.modCount) {
                if (hasNext()) {
                    link = link.previous;
                    canRemove = true;
                    return link.data;
                }
                throw new NoSuchElementException();
            }
            throw new ConcurrentModificationException();

        }

        public void remove() {
            if (expectedModCount == list.modCount) {
                if (canRemove) {
                    Link next = link.previous;
                    Link previous = link.next;
                    next.next = previous;
                    previous.previous = next;
                    link = previous;
                    list.size--;
                    list.modCount++;
                    expectedModCount++;
                    canRemove = false;
                    return;
                }
                throw new IllegalStateException();
            }
            throw new ConcurrentModificationException();
        }
    }
    
    
    //默认的LinkedList构造函数
    //创建一个head节点，其前后节点的引用都指向自己
    //为空
    public LinkedList() {
        voidLink = new Link(null, null, null);
        voidLink.previous = voidLink;
        voidLink.next = voidLink;
    }

    //使用一个collection创建一个LinkedList
    //将collection中所有元素添加到LinkedList中
    public LinkedList(Collection collection) {
        this();
        addAll(collection);
    }

    //添加元素到指定位置
    @Override
    public void add(int location, E object) {
        if (location >= 0 && location <= size) {
            Link link = voidLink;
            
            //获取到指定位置的原有节点
            if (location < (size / 2)) {
                for (int i = 0; i <= location; i++) {
                    link = link.next;
                }
            } else {
                for (int i = size; i > location; i--) {
                    link = link.previous;
                }
            }
            //添加新的节点到原位置节点与其前一个节点之间
            //取代原节点的位置
            Link previous = link.previous;
            Link newLink = new Link(object, previous, link);
            previous.next = newLink;
            link.previous = newLink;
            size++;
            modCount++;
        } else {
            throw new IndexOutOfBoundsException();
        }
    }

    //默认添加元素，添加到末尾
    @Override
    public boolean add(E object) {
        return addLastImpl(object);
    }
    
    private boolean addLastImpl(E object) {
        Link oldLast = voidLink.previous;
        Link newLink = new Link(object, oldLast, voidLink);
        voidLink.previous = newLink;
        oldLast.next = newLink;
        size++;
        modCount++;
        return true;
    }

    //添加一个collection中的所有元素到LinkedList中，从指定位置开始
    //添加的元素顺序为原collection中的顺序
    @Override
    public boolean addAll(int location, Collection collection) {
        if (location < 0 || location > size) {
            throw new IndexOutOfBoundsException();
        }
        int adding = collection.size();
        if (adding == 0) {
            return false;
        }
        Collection elements = (collection == this) ?
                new ArrayList(collection) : collection;

        Link previous = voidLink;
        if (location < (size / 2)) {
            for (int i = 0; i < location; i++) {
                previous = previous.next;
            }
        } else {
            for (int i = size; i >= location; i--) {
                previous = previous.previous;
            }
        }
        Link next = previous.next;
        for (E e : elements) {
            Link newLink = new Link(e, previous, null);
            previous.next = newLink;
            previous = newLink;
        }
        previous.next = next;
        next.previous = previous;
        size += adding;
        modCount++;
        return true;
    }

    
    @Override
    public boolean addAll(Collection collection) {
        int adding = collection.size();
        if (adding == 0) {
            return false;
        }
        Collection elements = (collection == this) ?
                new ArrayList(collection) : collection;

        Link previous = voidLink.previous;
        for (E e : elements) {
            Link newLink = new Link(e, previous, null);
            previous.next = newLink;
            previous = newLink;
        }
        previous.next = voidLink;
        voidLink.previous = previous;
        size += adding;
        modCount++;
        return true;
    }

    //添加元素到队列的头部 双端链表的方法
    public void addFirst(E object) {
        addFirstImpl(object);
    }

    private boolean addFirstImpl(E object) {
        Link oldFirst = voidLink.next;
        Link newLink = new Link(object, voidLink, oldFirst);
        voidLink.next = newLink;
        oldFirst.previous = newLink;
        size++;
        modCount++;
        return true;
    }

    //添加元素到列表的末尾 
    public void addLast(E object) {
        addLastImpl(object);
    }

    //清空列表
    //将head的前后引用指向自身
    @Override
    public void clear() {
        if (size > 0) {
            size = 0;
            voidLink.next = voidLink;
            voidLink.previous = voidLink;
            modCount++;
        }
    }

    //clone方法
    //复制一个LinkedList然后将当前list加入复制的列表汇中
    @SuppressWarnings("unchecked")
    @Override
    public Object clone() {
        try {
            LinkedList l = (LinkedList) super.clone();
            l.size = 0;
            l.voidLink = new Link(null, null, null);
            l.voidLink.previous = l.voidLink;
            l.voidLink.next = l.voidLink;
            l.addAll(this);
            return l;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError(e);
        }
    }

    //查找列表中是否包含某个元素
    //遍历列表
    @Override
    public boolean contains(Object object) {
        Link link = voidLink.next;
        if (object != null) {
            while (link != voidLink) {
                if (object.equals(link.data)) {
                    return true;
                }
                link = link.next;
            }
        } else {
            while (link != voidLink) {
                if (link.data == null) {
                    return true;
                }
                link = link.next;
            }
        }
        return false;
    }
    
    //获取指定位置的元素
    //熟悉的根据指定的位置来判断从前端还是后端进行遍历
    //从中可以看出，根据角标来获取LinkedList的时候，由于每次
    //都需要进行遍历，因此效率较低
    //严禁通过这种随机访问的形式来进行LinkedList的遍历
    @Override
    public E get(int location) {
        if (location >= 0 && location < size) {
            Link link = voidLink;
            if (location < (size / 2)) {
                for (int i = 0; i <= location; i++) {
                    link = link.next;
                }
            } else {
                for (int i = size; i > location; i--) {
                    link = link.previous;
                }
            }
            return link.data;
        }
        throw new IndexOutOfBoundsException();
    }

    //返回队列的首元素
    public E getFirst() {
        return getFirstImpl();
    }

    private E getFirstImpl() {
        Link first = voidLink.next;
        if (first != voidLink) {
            return first.data;
        }
        throw new NoSuchElementException();
    }

    //返回列队的末元素
    public E getLast() {
        Link last = voidLink.previous;
        if (last != voidLink) {
            return last.data;
        }
        throw new NoSuchElementException();
    }
    
    
    //查找指定元素的角标
    @Override
    public int indexOf(Object object) {
        int pos = 0;
        Link link = voidLink.next;
        if (object != null) {
            while (link != voidLink) {
                if (object.equals(link.data)) {
                    return pos;
                }
                link = link.next;
                pos++;
            }
        } else {
            while (link != voidLink) {
                if (link.data == null) {
                    return pos;
                }
                link = link.next;
                pos++;
            }
        }
        return -1;
    }

    //倒序查找指定元素的角标
    @Override
    public int lastIndexOf(Object object) {
        int pos = size;
        Link link = voidLink.previous;
        if (object != null) {
            while (link != voidLink) {
                pos--;
                if (object.equals(link.data)) {
                    return pos;
                }
                link = link.previous;
            }
        } else {
            while (link != voidLink) {
                pos--;
                if (link.data == null) {
                    return pos;
                }
                link = link.previous;
            }
        }
        return -1;
    }

    //返回一个List的iterator
    @Override
    public ListIterator listIterator(int location) {
        return new LinkIterator(this, location);
    }

    //移除指定位置的元素
    @Override
    public E remove(int location) {
        if (location >= 0 && location < size) {
            Link link = voidLink;
            if (location < (size / 2)) {
                for (int i = 0; i <= location; i++) {
                    link = link.next;
                }
            } else {
                for (int i = size; i > location; i--) {
                    link = link.previous;
                }
            }
            Link previous = link.previous;
            Link next = link.next;
            previous.next = next;
            next.previous = previous;
            size--;
            modCount++;
            return link.data;
        }
        throw new IndexOutOfBoundsException();
    }
    
    //移除指定元素
    @Override
    public boolean remove(Object object) {
        return removeFirstOccurrenceImpl(object);
    }

    //移除队列的首元素
    public E removeFirst() {
        return removeFirstImpl();
    }

    private E removeFirstImpl() {
        Link first = voidLink.next;
        if (first != voidLink) {
            Link next = first.next;
            voidLink.next = next;
            next.previous = voidLink;
            size--;
            modCount++;
            return first.data;
        }
        throw new NoSuchElementException();
    }

    //移除队列的末元素
    public E removeLast() {
        return removeLastImpl();
    }

    private E removeLastImpl() {
        Link last = voidLink.previous;
        if (last != voidLink) {
            Link previous = last.previous;
            voidLink.previous = previous;
            previous.next = voidLink;
            size--;
            modCount++;
            return last.data;
        }
        throw new NoSuchElementException();
    }

    //返回一个倒序的iterator
    public Iterator descendingIterator() {
        return new ReverseLinkIterator(this);
    }

    //Deque接口的方法实现 添加元素到队列首位
    public boolean offerFirst(E e) {
        return addFirstImpl(e);
    }

    //Deque接口的方法实现，添加元素到队列末位
    public boolean offerLast(E e) {
        return addLastImpl(e);
    }

    //Deque接口的方法实现，获取队列首位的元素
    //队列为空则返回null
    public E peekFirst() {
        return peekFirstImpl();
    }

    //Deque接口方法，获取队列末位元素
    //队列为空则返回null
    public E peekLast() {
        Link last = voidLink.previous;
        return (last == voidLink) ? null : last.data;
    }

    //Deque接口方法
    //移除队列首位元素并返回
    //队列为空则返回null
    public E pollFirst() {
        return (size == 0) ? null : removeFirstImpl();
    }

   //Deque方法
   //移除队列末位元素并返回
    public E pollLast() {
        return (size == 0) ? null : removeLastImpl();
    }

    //Deque方法
    //移除队列首位元素并返回
    //与pollFirst方法区别在于队列为空时会抛出异常
    public E pop() {
        return removeFirstImpl();
    }

    //Deque方法
    //添加元素到队列首位
    public void push(E e) {
        addFirstImpl(e);
    }

    //Deque方法
    public boolean removeFirstOccurrence(Object o) {
        return removeFirstOccurrenceImpl(o);
    }

    
    public boolean removeLastOccurrence(Object o) {
        Iterator iter = new ReverseLinkIterator(this);
        return removeOneOccurrence(o, iter);
    }

    private boolean removeFirstOccurrenceImpl(Object o) {
        Iterator iter = new LinkIterator(this, 0);
        return removeOneOccurrence(o, iter);
    }

    private boolean removeOneOccurrence(Object o, Iterator iter) {
        while (iter.hasNext()) {
            E element = iter.next();
            if (o == null ? element == null : o.equals(element)) {
                iter.remove();
                return true;
            }
        }
        return false;
    }

    //修改指定位置的元素
    @Override
    public E set(int location, E object) {
        if (location >= 0 && location < size) {
            Link link = voidLink;
            if (location < (size / 2)) {
                for (int i = 0; i <= location; i++) {
                    link = link.next;
                }
            } else {
                for (int i = size; i > location; i--) {
                    link = link.previous;
                }
            }
            E result = link.data;
            link.data = object;
            return result;
        }
        throw new IndexOutOfBoundsException();
    }

    //返回当前列表的元素数量
    @Override
    public int size() {
        return size;
    }
    
    //添加元素到队列末位
    public boolean offer(E o) {
        return addLastImpl(o);
    }
    
    //移除并返回队列首位元素
    public E poll() {
        return size == 0 ? null : removeFirst();
    }
    
    //移除并返回队列首位元素
    //为空时会抛出异常
    public E remove() {
        return removeFirstImpl();
    }
    
    //返回队列首位元素
    //不会删除元素
    //为空时会返回null
    public E peek() {
        return peekFirstImpl();
    }

    private E peekFirstImpl() {
        Link first = voidLink.next;
        return first == voidLink ? null : first.data;
    }
    
    //获取首位元素
    public E element() {
        return getFirstImpl();
    }

    //返回列表的数组形式
    @Override
    public Object[] toArray() {
        int index = 0;
        Object[] contents = new Object[size];
        Link link = voidLink.next;
        while (link != voidLink) {
            contents[index++] = link.data;
            link = link.next;
        }
        return contents;
    }

    //返回列表的数组形式
    //如果参数传递的数组够大则使用参数数组
    //否则创建新数组
    @Override
    @SuppressWarnings("unchecked")
    public  T[] toArray(T[] contents) {
        int index = 0;
        if (size > contents.length) {
            Class ct = contents.getClass().getComponentType();
            contents = (T[]) Array.newInstance(ct, size);
        }
        Link link = voidLink.next;
        while (link != voidLink) {
            contents[index++] = (T) link.data;
            link = link.next;
        }
        if (index < contents.length) {
            contents[index] = null;
        }
        return contents;
    }
    
    //序列化方法
    //先写入容量即size
    //再写入每个节点
    private void writeObject(ObjectOutputStream stream) throws IOException {
        stream.defaultWriteObject();
        stream.writeInt(size);
        Iterator it = iterator();
        while (it.hasNext()) {
            stream.writeObject(it.next());
        }
    }
    
    //反序列化方法
    //先读取容量即size
    //再创建LinkedList，读取每个节点加入队列
    @SuppressWarnings("unchecked")
    private void readObject(ObjectInputStream stream) throws IOException,
            ClassNotFoundException {
        stream.defaultReadObject();
        size = stream.readInt();
        voidLink = new Link(null, null, null);
        Link link = voidLink;
        for (int i = size; --i >= 0;) {
            Link nextLink = new Link((E) stream.readObject(), link, null);
            link.next = nextLink;
            link = nextLink;
        }
        link.next = voidLink;
        voidLink.previous = link;
    }
}