遍历LinkedList要用增强型for循环的原因是什么

本文小编为大家详细介绍“遍历LinkedList要用增强型for循环的原因是什么”，内容详细，步骤清晰，细节处理妥当，希望这篇“遍历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()这些会改变集合内容的方法。两种情况：

• 在增强型for循环里面不能有add或者remove操作，使用Iterator迭代的时候不能做add或者remove操作。

• 如果有其他线程操作集合，需要加锁避免改变集合，等待循环结束之后再修改。

否则都会报ConcurrentModificationException。

读到这里，这篇“遍历LinkedList要用增强型for循环的原因是什么”文章已经介绍完毕，想要掌握这篇文章的知识点还需要大家自己动手实践使用过才能领会，如果想了解更多相关内容的文章，欢迎关注亿速云行业资讯频道。