码迷,mamicode.com
首页 > 编程语言 > 详细

java集合框架04——LinkedList和源码分析

时间:2016-04-13 00:22:07      阅读:259      评论:0      收藏:0      [点我收藏+]

标签:

     上一章学习了ArrayList,并分析了其源码,这一章我们将对LinkedList的具体实现进行详细的学习。依然遵循上一章的步骤,先对LinkedList有个整体的认识,然后学习它的源码,深入剖析LinkedList。

LinkedList简介

    首先看看LinkedList与Collection的关系:

                                                 技术分享


    LinkedList的继承关系如下:

java.lang.Object
   ?     java.util.AbstractCollection<E>
         ?     java.util.AbstractList<E>
               ?     java.util.AbstractSequentialList<E>
                     ?     java.util.LinkedList<E>

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

    LinkedList是一个继承与AbatractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作

    LinkedList实现了List接口,能对它进行队列操作。

    LinkedList实现了Deque接口,即能将LinkedList当作双端队列使用。

    LinkedList实现了java.io.Serializable接口,这意味着LinkedList支持序列化,能通过序列化去传输。

    LinkedList是非同步的

    这里插一句,简单说一下AbstractSequentialList,因为LinkedList是其子类。

    AbstractSequentialList实现了get(int index)、set(int index, E element)、add(int index, E element)和remove(int index)这些方法。这些接口都是随机访问List的,LinkedList是双向链表,既然它继承与AbstractSequentialList,就相当于已经实现了“get(int index)”这些接口,可以支持随机访问了。

    此外,如果我们需要通过AbstractSequentialList实现一个自己的列表,只需要扩展此类,并提供listIterator()和size()方法的实现即可。若要实现不可修改的列表,则需要实现列表迭代器的hashNext、next、hashPrevious、previous和index方法即可。

    下面先总览一下LinkedList的构造函数和API:

LinkedList的API
boolean       add(E object)
void          add(int location, E object)
boolean       addAll(Collection<? extends E> collection)
boolean       addAll(int location, Collection<? extends E> collection)
void          addFirst(E object)
void          addLast(E object)
void          clear()
Object        clone()
boolean       contains(Object object)
Iterator<E>   descendingIterator()
E             element()
E             get(int location)
E             getFirst()
E             getLast()
int           indexOf(Object object)
int           lastIndexOf(Object object)
ListIterator<E>     listIterator(int location)
boolean       offer(E o)
boolean       offerFirst(E e)
boolean       offerLast(E e)
E             peek()
E             peekFirst()
E             peekLast()
E             poll()
E             pollFirst()
E             pollLast()
E             pop()
void          push(E e)
E             remove()
E             remove(int location)
boolean       remove(Object object)
E             removeFirst()
boolean       removeFirstOccurrence(Object o)
E             removeLast()
boolean       removeLastOccurrence(Object o)
E             set(int location, E object)
int           size()
<T> T[]       toArray(T[] contents)
Object[]     toArray()

    LinkedList包含三个重要的成员:first、last和size:first是双向链表的表头,last是双向链表的尾节点,size是双向链表中的节点个数。

LinkedList源码分析(基于JDK1.7)

    下面通过分析LinkedList的源码更加深入的了解LinkedList原理。由于LinkedList是通过双向链表实现的,所以源码也比较容易理解:
package java.util;

/*双向链表*/
public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
	/**
	* 这里先说一下transient关键字的用法:
	* 一个对象只要实现了Serilizable接口,这个对象就可以被序列化,java的这种序列化模式为开发者提供了很多便利,可以不必关系具体序列化的过程,
	* 只要这个类实现了Serilizable接口,这个的所有属性和方法都会自动序列化。但是有种情况是有些属性是不需要序列号的,所以就用到这个关键字。
	* 只需要实现Serilizable接口,将不需要序列化的属性前添加关键字transient,序列化对象的时候,这个属性就不会序列化到指定的目的地中。
	*/
    transient int size = 0; //LinkedList中元素的个数
    transient Node<E> first; //链表的头结点
    transient Node<E> last; //链表的尾节点

    public LinkedList() { //默认构造函数,创建一个空链表
    }

    //按照c中的元素生成一个LinkedList
    public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c); //将c中的元素添加到空链表的尾部
    }

    /***************************** 添加头结点 ********************************/
	public void addFirst(E e) {
        linkFirst(e);
    }

    private void linkFirst(E e) {
        final Node<E> f = first; //f指向头结点
		//生成一个新结点e,其前向指针为null,后向指针为f  
        final Node<E> newNode = new Node<>(null, e, f);
        first = newNode; //first指向新生成的结点,f保存着老的头结点信息  
        if (f == null)
            last = newNode; //如果f为null,则表示整个链表目前是空的,则尾结点也指向新结点
        else
            f.prev = newNode;
        size++;
        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);
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
    }

    /****************** 在非空节点succ之前插入新节点e ************************/
    void linkBefore(E e, Node<E> succ) {
        // assert succ != null; //外界调用需保证succ不为null,否则程序会抛出空指针异常  
        final Node<E> pred = succ.prev;
		 //生成一个新结点e,其前向指针指向pred,后向指针指向succ  
        final Node<E> newNode = new Node<>(pred, e, succ);
        succ.prev = newNode; //succ的前向指针指向newNode  
        if (pred == null)
			//如果pred为null,则表示succ为头结点,此时头结点指向最新生成的结点newNode 
            first = newNode;
        else
			//pred的后向指针指向新生成的结点,此时已经完成了结点的插入操作
            pred.next = newNode;
        size++;
        modCount++;
    }

    /*********************** 删除头结点,并返回头结点的值 *********************/
    public E removeFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return unlinkFirst(f); //private方法
    }
    
    private E unlinkFirst(Node<E> f) {
        // assert f == first && f != null; //需确保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)
			//如果next为null,则表示f为last结点,此时链表即为空链表 
            last = null;
        else
			//修改next的前向指针,因为first结点的前向指针为null 
            next.prev = null;
        size--;
        modCount++;
        return element;
    }

    /********************** 删除尾节点,并返回尾节点的值 ********************/
	public E removeLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return unlinkLast(l); //private方法
    }

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

    /******************** 删除为空节点x,并返回该节点的值 ******************/
    E unlink(Node<E> x) {
        // assert x != null; //需确保x不为null,否则后续操作会抛出空指针异常  
        final E element = x.item;
        final Node<E> next = x.next;
        final Node<E> prev = x.prev;

        if (prev == null) {
			//如果prev为空,则x结点为first结点,此时first结点指向next结点(x的后向结点)
            first = next;
        } else {
            prev.next = next; //x的前向结点的后向指针指向x的后向结点  
            x.prev = null; //释放x的前向指针  
        }

        if (next == null) {
			//如果next结点为空,则x结点为尾部结点,此时last结点指向prev结点(x的前向结点)
            last = prev;
        } else {
            next.prev = prev; //x的后向结点的前向指针指向x的前向结点
            x.next = null; //释放x的后向指针  
        }

        x.item = null; //释放x的值节点,此时x节点可以完全被GC回收  
        size--;
        modCount++;
        return element;
    }

    /********************** 获得头结点的值 ********************/
    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;
    }

    /*************** 判断元素(值为o)是否在链表中 *************/
    public boolean contains(Object o) {
        return indexOf(o) != -1; //定位元素
    }

    //返回元素个数
    public int size() {
        return size;
    }

    //向链表尾部添加元素e
    public boolean add(E e) {
        linkLast(e);
        return true;
    }

    /*************** 删除值为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 {//o不为空
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item)) {
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
    }

    /*************** 将集合e中所有元素添加到链表中 *************/
    public boolean addAll(Collection<? extends E> c) {
        return addAll(size, c);
    }
	//从index开始,向后添加的
    public boolean addAll(int index, Collection<? extends E> c) {
        checkPositionIndex(index); //判断index是否越界

        Object[] a = c.toArray(); //将集合c转换为数组
        int numNew = a.length;
        if (numNew == 0)
            return false;

        Node<E> pred, succ;
        if (index == size) {//即index个节点在尾节点后面
            succ = null;
            pred = last; //pred指向尾节点
        } else {
            succ = node(index); //succ指向第index个节点
            pred = succ.prev; //pred指向succ的前向节点
        }

		//for循环结束后,a里面的元素都添加到当前链表里了,向后添加
        for (Object o : a) {
            @SuppressWarnings("unchecked") E e = (E) o;
            Node<E> newNode = new Node<>(pred, e, null);
            if (pred == null)
                first = newNode; //如果pred为null,则succ为头结点
            else
                pred.next = newNode; //pred的后向指针指向新节点
            pred = newNode; //pred指向新节点,即往后移动一个节点,用于下一次循环
        }

        if (succ == null) { //succ为null表示index为尾节点之后
            last = pred;
        } else {
			//pred表示所有元素添加好之后的最后那个节点,此时pred的后向指针指向之前记录的节点,即index处的节点
            pred.next = succ;
            succ.prev = pred; //之前记录的结点指向添加元素之后的最后结点
        }

        size += numNew;
        modCount++;
        return true;
    }

    /******************** 清空链表 *************************/
    public void clear() {
        for (Node<E> x = first; x != null; ) {
            Node<E> next = x.next;
            x.item = null; //释放值结点,便于GC回收  
            x.next = null; //释放前向指针  
            x.prev = null; //释放前后指针  
            x = next; //后向遍历  
        }
        first = last = null; //释放头尾节点
        size = 0;
        modCount++;
    }


    /******************* Positional Access Operations ***********************/

    //获得第index个节点的值
    public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
    }

    //设置第index元素的值
    public E set(int index, E element) {
        checkElementIndex(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)
            linkLast(element);
        else
            linkBefore(element, node(index));
    }

    //删除第index个节点
    public E remove(int index) {
        checkElementIndex(index);
        return unlink(node(index));
    }

    //判断index是否为链表中的元素下标
    private boolean isElementIndex(int index) {
        return index >= 0 && index < size;
    }

    //判断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));
    }

    //定位index处的节点
    Node<E> node(int index) {
        // assert isElementIndex(index);
		//index<size/2时,从头开始找
        if (index < (size >> 1)) {
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else { //index>=size/2时,从尾开始找
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }

    /*************************** Search Operations *************************/

    //返回首次出现指定元素值o的节点索引
    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
    }

    //返回最后一次出现指定元素值o的节点索引
    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;
    }

    /***************************** Queue operations ***********************/
    //下面是与栈和队列相关的操作了
    //实现栈的操作,返回第一个元素的值
    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);
    }

    /************************* Deque operations **********************/
    //下面都是和双端队列相关的操作了
	//添加头结点
    public boolean offerFirst(E e) {
        addFirst(e);
        return true;
    }

    //添加尾节点
    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) ? null : unlinkFirst(f); //删除
    }

    //弹出尾节点
    public E pollLast() {
        final Node<E> l = last;
        return (l == null) ? null : unlinkLast(l); //删除
    }

    //栈操作,添加头结点
    public void push(E e) {
        addFirst(e);
    }

    //栈操作,删除头结点
    public E pop() {
        return removeFirst();
    }

    //删除第一次出现o的节点
    public boolean removeFirstOccurrence(Object o) {
        return remove(o);
    }

    //删除最后一次出现o的节点
    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;
    }

    /************************* ListIterator ***********************/
	
    public ListIterator<E> listIterator(int index) {
        checkPositionIndex(index);
        return new ListItr(index); //ListItr是一个双向迭代器
    }

    //实现双向迭代器
    private class ListItr implements ListIterator<E> {
        private Node<E> lastReturned = null;//记录当前节点信息
        private Node<E> next; //当前节点的后向节点
        private int nextIndex; //当前节点的索引
        private int expectedModCount = modCount; //修改次数

        ListItr(int index) {
            // assert isPositionIndex(index);
            next = (index == size) ? null : node(index);
            nextIndex = index;
        }

        public boolean hasNext() {
            return nextIndex < size;
        }

        public E next() {
            checkForComodification();
            if (!hasNext())
                throw new NoSuchElementException();

            lastReturned = next; //记录当前节点
            next = next.next; //向后移动一个位置
            nextIndex++; //节点索引+1
            return lastReturned.item; //返回当前节点的值
        }

        public boolean hasPrevious() {
            return nextIndex > 0;
        }

		//返回前向节点的值
        public E previous() {
            checkForComodification();
            if (!hasPrevious())
                throw new NoSuchElementException();

            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();
            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() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

    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 Iterator<E> descendingIterator() {
        return new DescendingIterator();
    }

    //通过ListItr.previous来提供前向迭代器,方向与原来相反
    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();

        // Put clone into "virgin" state
        clone.first = clone.last = null;
        clone.size = 0;
        clone.modCount = 0;

        // Initialize clone with our elements
        for (Node<E> x = first; x != null; x = x.next)
            clone.add(x.item);

        return clone;
    }

    /*************************** toArray ****************************/
    //返回LinkedList的Object[]数组
	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;
    }

    //返回LinkedList的模板数组,存储在a中
    @SuppressWarnings("unchecked")
    public <T> T[] toArray(T[] a) {
        if (a.length < size)
			//如果a的大小 < LinkedList的元素个数,意味着数组a不能容纳LinkedList的全部元素
			//则新建一个T[]数组,T[]的大小为LinkedList大小,并将T[]赋给a
            a = (T[])java.lang.reflect.Array.newInstance(
                                a.getClass().getComponentType(), size);
		//如果a大小够容纳LinkedList的全部元素
        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;

    /************************* Serializable **************************/
    //java.io.Serializable的写入函数
    //将LinkedList的“容量,所有元素值”写入到输出流中
    private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException {
        // Write out any hidden serialization magic
        s.defaultWriteObject();

        // Write out size
        s.writeInt(size); //写入容量

        // Write out all elements in the proper order.
        for (Node<E> x = first; x != null; x = x.next) //写入所有数据
            s.writeObject(x.item);
    }

    //java.io.Serializable的读取函数:根据写入方式反向读出
    //先将LinkedList的“容量”读出,然后将“所有元素值”读出
    @SuppressWarnings("unchecked")
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        // Read in any hidden serialization magic
        s.defaultReadObject();

        // Read in size
        int size = s.readInt(); //读出容量

        // Read in all elements in the proper order.
        for (int i = 0; i < size; i++) //读出所有元素值
            linkLast((E)s.readObject());
    }
}
    总结一下:

    1). LinkedList是通过双向链表去实现的。

    2). 从LinkedList的实现方式中可以看出,它不存在容量不足的问题,因为是链表。

    3). LinkedList实现java.io.Serializable的方式。当写入到输出流时,先写入“容量”,再依次写出“每一个元素”;当读出输入流时,先读取“容量”,再依次读取“每一个元素”。

    4). LinkdedList的克隆函数,即是将全部元素克隆到一个新的LinkedList中。

    5). 由于LinkedList实现了Deque,而Deque接口定义了在双端队列两端访问元素的方法。提供插入、移除和检查元素的方法。

    6). LinkedList可以作为FIFO(先进先出)的队列,作为FIFO的队列时,下标的方法等价:

队列方法       等效方法
add(e)        addLast(e)
offer(e)      offerLast(e)
remove()      removeFirst()
poll()        pollFirst()
element()     getFirst()
peek()        peekFirst()
    7). LinkedList可以作为LIFO(后进先出)的栈,作为LIFO的栈时,下表的方法等价:
栈方法        等效方法
push(e)      addFirst(e)
pop()        removeFirst()
peek()       peekFirst()

LinkedList遍历方式

    LinkedList支持多种遍历方式,建议不要采用随机访问的方式去遍历LinkedList,而采用逐个遍历的方式。下面我们来看看每种遍历方式:

    1). 通过Iterator迭代器遍历

for(Iterator iter = list.iterator(); iter.hasNext();)
    iter.next();
    2). 通过快速随机访问遍历
int size = list.size();
    for (int i=0; i<size; i++) {
        list.get(i);        
}
    3). 通过for循环遍历
for (Integer integ:list) 
    ;
    4). 通过pollFirst()pollLast()来遍历
while(list.pollFirst() != null)
    ;
while(list.pollLast() != null)
    ;
    5). 通过removeFirst()removeLast()来遍历
while(list.removeFirst() != null)
        ;
while(list.removeLast() != null)
        ;
    下面通过一个测试用例来测试一下这些方法的效率:
import java.util.Iterator;
import java.util.LinkedList;
import java.util.NoSuchElementException;

/*
 * @description 测试LinkedList的几种遍历方式和效率
 * @author eson_15
 */
public class LinkedListThruTest {
    public static void main(String[] args) {
        // 通过Iterator遍历LinkedList
        iteratorLinkedListThruIterator(getLinkedList()) ;
        
        // 通过快速随机访问遍历LinkedList
        iteratorLinkedListThruForeach(getLinkedList()) ;

        // 通过for循环的变种来访问遍历LinkedList
        iteratorThroughFor2(getLinkedList()) ;

        // 通过PollFirst()遍历LinkedList
        iteratorThroughPollFirst(getLinkedList()) ;

        // 通过PollLast()遍历LinkedList
        iteratorThroughPollLast(getLinkedList()) ;

        // 通过removeFirst()遍历LinkedList
        iteratorThroughRemoveFirst(getLinkedList()) ;

        // 通过removeLast()遍历LinkedList
        iteratorThroughRemoveLast(getLinkedList()) ;
    }
    
    private static LinkedList<Integer> getLinkedList() {
        LinkedList<Integer> llist = new LinkedList<Integer>();
        for (int i=0; i<500000; i++)
            llist.addLast(i);

        return llist;
    }
    /**
     * 通过快迭代器遍历LinkedList
     */
    private static void iteratorLinkedListThruIterator(LinkedList<Integer> list) {
        if (list == null)
            return ;
        long start = System.currentTimeMillis();
        
        for(Iterator<Integer> iter = list.iterator(); iter.hasNext();)
            iter.next();
        long end = System.currentTimeMillis();
        long interval = end - start;
        System.out.println("iteratorLinkedListThruIterator:" + interval+" ms");
    }

    /**
     * 通过快速随机访问遍历LinkedList
     */
    private static void iteratorLinkedListThruForeach(LinkedList<Integer> list) {
        if (list == null)
            return ;
        long start = System.currentTimeMillis(); 
        int size = list.size();
        for (int i=0; i<size; i++) {
            list.get(i);        
        }
        long end = System.currentTimeMillis();
        long interval = end - start;
        System.out.println("iteratorLinkedListThruForeach:" + interval+" ms");
    }

    /**
     * 通过另外一种for循环来遍历LinkedList
     */
    private static void iteratorThroughFor2(LinkedList<Integer> list) {
        if (list == null)
            return ;
        long start = System.currentTimeMillis();
        
        for (Integer integ : list) 
            ;
        long end = System.currentTimeMillis();
        long interval = end - start;
        System.out.println("iteratorThroughFor2:" + interval+" ms");
    }

    /**
     * 通过pollFirst()来遍历LinkedList
     */
    private static void iteratorThroughPollFirst(LinkedList<Integer> list) {
        if (list == null)
            return ;
        long start = System.currentTimeMillis();
        while(list.pollFirst() != null)
            ;
        long end = System.currentTimeMillis();
        long interval = end - start;
        System.out.println("iteratorThroughPollFirst:" + interval+" ms");
    }

    /**
     * 通过pollLast()来遍历LinkedList
     */
    private static void iteratorThroughPollLast(LinkedList<Integer> list) {
        if (list == null)
            return ;
        long start = System.currentTimeMillis();
        while(list.pollLast() != null)
            ;
        long end = System.currentTimeMillis();
        long interval = end - start;
        System.out.println("iteratorThroughPollLast:" + interval+" ms");
    }

    /**
     * 通过removeFirst()来遍历LinkedList
     */
    private static void iteratorThroughRemoveFirst(LinkedList<Integer> list) {
        if (list == null)
            return ;
        long start = System.currentTimeMillis();
        try {
            while(list.removeFirst() != null)
                ;
        } catch (NoSuchElementException e) {
        }
        long end = System.currentTimeMillis();
        long interval = end - start;
        System.out.println("iteratorThroughRemoveFirst:" + interval+" ms");
    }

    /**
     * 通过removeLast()来遍历LinkedList
     */
    private static void iteratorThroughRemoveLast(LinkedList<Integer> list) {
        if (list == null)
            return ;
        long start = System.currentTimeMillis();
        try {
            while(list.removeLast() != null)
                ;
        } catch (NoSuchElementException e) {
        }
        long end = System.currentTimeMillis();
        long interval = end - start;
        System.out.println("iteratorThroughRemoveLast:" + interval+" ms");
    }

}
    测试结果如下:

iteratorLinkedListThruIterator:10 ms
iteratorLinkedListThruForeach:414648 ms
iteratorThroughFor2:10 ms
iteratorThroughPollFirst:8 ms
iteratorThroughPollLast:10 ms
iteratorThroughRemoveFirst:7 ms
iteratorThroughRemoveLast:6 ms
    由此可见,遍历LinkedList时,使用removeFirst()或removeLast()效率最高。但是用它们遍历会删除原始数据;若只是单纯的取数据,而不删除,建议用迭代器方式或者for-each方式。

    无论如何,千万不要用随机访问去遍历LinkedList!除非脑门儿被驴给踢了... ...

    LinkedList源码就讨论这么多,如果有错误的地方请留言指正,如果喜欢的话,别忘了点个赞哟~


java集合框架04——LinkedList和源码分析

标签:

原文地址:http://blog.csdn.net/eson_15/article/details/51135944

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!