java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > 遍历LinkedList增强型for循环

一文讲透为什么遍历LinkedList要用增强型for循环

作者:Yocn

这篇文章主要为大家介绍了为什么遍历LinkedList要用增强型for循环的透彻详解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪

for循环和链表介绍

我们都知道java中有个增强型for循环,这个for循环很方便,如果不需要知道当前遍历到第几个的话可以跟普通for循环替换使用,也有人知道这俩好像有那么一点点不一样,但为什么不一样就不知道了。

我们还知道LinkedList是一个双向链表,这个集合应该是唯一一个既实现了List接口又实现了Queue接口的集合类。 链表这种数据结构,跟数组相比,优势在插入,劣势在遍历,那如果要遍历一个链表,就要从头开始遍历,否则根本不知道下一个Node是什么。

增强for循环为什么遍历LinkedList那么快

其实这个标题不合适,应该是为什么普通for循环遍历LinkedList为什么那么慢。我们写代码验证一下时间:

public void test() {
        LinkedList<Integer> list = new LinkedList<>();
        for (int i = 0; i < 100000; i++) {//插入100000条数据
            list.add(i);
        }
        int index = 0;//记录最后一个元素
        long time1 = System.currentTimeMillis();
        for (int i = 0; i < list.size(); i++) {//普通for循环遍历
            index = list.get(i);
        }
        long time2 = System.currentTimeMillis();
        LogUtil.Companion.d("1:" + (time2 - time1) + " index->" + index);
        for (int i : list) {//增强for循环遍历
            index = i;
        }
        long time3 = System.currentTimeMillis();
        LogUtil.Companion.d("2:" + (time3 - time2) + " index->" + index);
        Iterator<Integer> iterator = list.listIterator();
        while (iterator.hasNext()) {//iterator遍历
            index = iterator.next();
        }
        long time4 = System.currentTimeMillis();
        LogUtil.Companion.d("3:" + (time4 - time3) + " index->" + index);
    }

运行结果:

1:5056 index->99999
2:12 index->99999
3:1 index->99999

其实增强型for循环底层就是用iterator实现的,可以分析两者的字节码得出这个结论,这里我们不分析,算作一致结论。来看上面的结果,发现普通for循环遍历的时间跟增强for循环iterator相比简直令人发指。 为什么会这样呢?我们看LinkedList的源码一探究竟。

LinkedList是一个双向链表,用Head跟Tail两个Node记录了头尾节点。

LinkedList相关源码分析

普通for循环

我们看到其实普通for循环只是调用了LinkedList的 get(index) 方法:

//LinkedList.java
    public E get(int index) {
        checkElementIndex(index); //只是检测是否数组越界
        return node(index).item; //调用了node(index)方法
    /**
     * Returns the (non-null) Node at the specified element index.
     */
    Node<E> node(int index) {
        // assert isElementIndex(index);
//判断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;
        }
     }
    }

get方法很简单,只是调用了node方法,node方法也很简单,只是判断了index是否是小于size/2,小于说明离Head近一点,否则说明离tail近,离哪个近就从哪一头开始暴力遍历,所以如果LinkedList有100000个Node,那最远的那个Node如果调用get方法就需要遍历50000次。

所以普通for循环遍历一次n个节点的LinkedList需要1+2+3+...+n/2+n/2+...+3+2+1次,时间复杂度可以写作O(n^2^)

增强for循环

可以看到最终是调用了LinkedList的内部类ListItr

//LinkedList.java
public ListIterator<E> listIterator(int index) {
        checkPositionIndex(index);
        return new ListItr(index);
    }
    private class ListItr implements ListIterator<E> {
        private Node<E> lastReturned;
        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++;
            return lastReturned.item;
        }
...
        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

这里我们忽略一部分代码先只看for循环涉及的方法,代码其实也很简单。如果 hasNext() 存在,就调用next() ,两个Node:lastReturned和next。

每次获取index的时候调用 ListItr(int index) 后next会指向当前index的Node。

调用next的时候lastReturned会指向next也就是当前index的Node,next指向next.next,所以每次遍历的时候只要赋值一次就可以得到next的节点,所以遍历一个n个节点的LinkedList就是需要n次。

所以用iterator遍历的话时间复杂度就是O(n)。

这就是为什么两个for循环的方式这么区别这么大了~我们也可以直观的看出来当n到达十万这个级别的时候O(n^2^)和O(n)差别有多大了。

不知道各位发现没有,Iterator里面每个操作都先调用了 checkForComodification() 方法,判断 (modCount != expectedModCount) 是否相等。

各位应该发现了ListItr有一个赋值,把modCount赋值给了expectedModCount,但每次调用遍历或者addsetget的时候都会判断这两个值是否相等。

modCount是父类AbstractList的属性,而每次调用add(),remove()方法的时候这个值都会变,也就是如果集合里面内容修改了modCount都会发生改变。

So,在使用Iterator的时候不能调用add()或者remove()这些会改变集合内容的方法。两种情况:

否则都会报ConcurrentModificationException

以上就是一文讲透为什么遍历LinkedList要用增强型for循环的详细内容,更多关于遍历LinkedList增强型for循环的资料请关注脚本之家其它相关文章!

您可能感兴趣的文章:
阅读全文