为什么千万别用for循环迭代LinkedList

谁践踏了优雅 2022-07-13 11:16 229阅读 0赞

> 今天晚上7点时候，想着每天的8点健身还早，突然想起来以前的一个知识点说千万别用for循环迭代LinkedList，效率奇低，今天就想着来写个测试例子并分析原理：

# 代码测试与现象 #

哈哈哈，首先还是先上源码：

package collection;
    
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.LinkedList;
    import java.util.List;
    
    /** * Created by louyuting on 17/1/6. */
    public class ArrayListAndLinkedList { 
    
        public static void main(String[] args) {
    
            List<String> arrayList = new ArrayList<String>();
            List<String> linkedList = new LinkedList<String>();
    
            for(long i=0; i<100000; i++){
                arrayList.add(""+i);
                linkedList.add(""+i);
            }
    
    /** 测试foreach循环 */
            long ayyaybefore = System.currentTimeMillis();
            for(String ii : arrayList){
            }
            long ayyayafter = System.currentTimeMillis();
            System.out.println("arraylist使用foreach遍历的时间是:"+(ayyayafter-ayyaybefore)+"ms");
    
            ayyaybefore = System.currentTimeMillis();
            for(String ii : linkedList){
            }
            ayyayafter = System.currentTimeMillis();
            System.out.println("linkedlist使用foreach遍历的时间是:"+(ayyayafter-ayyaybefore)+"ms");
    
    /** 测试 iterator 循环 */
            Iterator aiterator = arrayList.iterator();
            ayyaybefore = System.currentTimeMillis();
            while (aiterator.hasNext()){
                aiterator.next();
            }
            ayyayafter = System.currentTimeMillis();
            System.out.println("arraylist使用iterator遍历的时间是:"+(ayyayafter-ayyaybefore)+"ms");
    
            Iterator literator = linkedList.iterator();
            ayyaybefore = System.currentTimeMillis();
            while (literator.hasNext()){
                literator.next();
            }
            ayyayafter = System.currentTimeMillis();
            System.out.println("linkedList使用iterator遍历的时间是:"+(ayyayafter-ayyaybefore)+"ms");
    
    /** 测试for循环 */
            ayyaybefore = System.currentTimeMillis();
            for(int ii=0; ii<arrayList.size(); ii++){
                arrayList.get(ii);
            }
            ayyayafter = System.currentTimeMillis();
            System.out.println("arrayList使用for遍历的时间是:"+(ayyayafter-ayyaybefore)+"ms");
    
            ayyaybefore = System.currentTimeMillis();
            for(int ii=0; ii<linkedList.size(); ii++){
                linkedList.get(ii);
            }
            ayyayafter = System.currentTimeMillis();
            System.out.println("linkedlist使用for遍历的时间是:"+(ayyayafter-ayyaybefore)+"ms");
        }
    }

> 说个插曲，上面的测试用例中，最开始我想着list中存入的数据放多点，就设置的一千万，结果，在最后的LinkedList的for循环遍历那一直卡住了，我冲了一杯咖啡喝了都没执行完…气的吐血。过段终止了，然后换成了10万条数据。下面看运行结果：

![运行结果][SouthEast]

10万条记录。很明显，不管是foreach，还是迭代器迭代，速度都差别不大，但是对于用for循环的时，linkedlist的for循环遍历有140s之久，是arrayList的12662倍。非常恐怖。

# 原因分析 #

为什么LinkedList的for循环迭代这么慢呢？我们来分析一下原因。其实这已经与Java没啥关系了，主要是与数据结构有关了。

我们先来看看LinkedList的get(int i)做了什么：

//get函数主要调用了node()函数
    Node<E> node(int 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;
        }
    }

由于LinkedList是双向链表，因此第6行的意思是算出i在一半前还是一半后，一半前正序遍历、一半后倒序遍历，这样会快很多，当然，先不管这个，分析一下为什么使用普通for循环遍历LinkedList会这么慢。

原因就在两个for循环里面，以前者为例：  
1、get(0)，直接拿到0位的Node0的地址，拿到Node0里面的数据

2、get(1)，直接拿到0位的Node0的地址，从0位的Node0中找到下一个1位的Node1的地址，找到Node1，拿到Node1里面的数据

3、get(2)，直接拿到0位的Node0的地址，从0位的Node0中找到下一个1位的Node1的地址，找到Node1，从1位的Node1中找到下一个2位的Node2的地址，找到Node2，拿到Node2里面的数据。

后面的以此类推。也就是说，LinkedList在get任何一个位置的数据的时候，都会把前面的数据走一遍。假如我有10个数据，那么将要查询1+2+3+4+5+5+4+3+2+1=30次数据，相比ArrayList，却只需要查询10次数据就行了，随着LinkedList的容量越大，差距会越拉越大。其实使用LinkedList到底要查询多少次数据，大家应该已经很明白了，来算一下：按照前一半算应该是（1 + 0.5N） \* 0.5N / 2，后一半算上即乘以2，应该是（1 + 0.5N） \* 0.5N = 0.25N2 + 0.5N，忽略低阶项和首项系数，得出结论，LinikedList遍历的时间复杂度为O(N2)，N为LinkedList的容量。

时间复杂度有以下经验规则：  
O(1) < O(log2N) < O(n) < O(N \* log2N) < O(N2) < O(N3) < 2N < 3N < N!

前四个比较好、中间两个一般、后3个很烂。也就是说O(N2)是相对糟糕的一种时间复杂度了，N大一点，程序就会执行得比较慢。

# 结论 #

根据以上的分析，各位Java程序员朋友们，切记一定不要使用普通for循环去遍历LinkedList。使用迭代器或者foreach循环（foreach循环的原理就是迭代器）去遍历LinkedList即可，这种方式是直接按照地址去找数据的，将会大大提升遍历LinkedList的效率。

[SouthEast]: /images/20220713/8a876a5bd73f4336bcbfa62053de493f.png