不同的列表选择不同的遍历方法

Posted 2022-02-06 你是我的天晴

我们来思考这样一个案例：统计一个省的各科髙考平均值，比如数学平均分是多少，语文平均分是多少等，这是每年招生办都会公布的数据，我们来想想看该算法应如何实现。当 然使用数据库中的一个SQL语句就能求出平均值，不过这不再我们的考虑之列，这里还是使用纯；lava的算法来解决之，看代码：

public static void main(String[]args) 
    //学生数量，80万
    int stuNum = 80*10000 ?
    //List集合，记录所有学生的分数
    List<Integer> scores = new ArrayList<Integer>(stuNum);
    //写入分数
    for(int i=0;i<stuNum;i++)
        scores.add(new Random。.nextlnt(150));
    
    //记录开始计算时间
    long start = System.currentTimeMillis(); 
    System.out.println("平均分是：" + average(scores)); 
    System.out.println("执行时间：" + (System.currentTimeMillis() - start) + "ms"); 





//计算平均数 
public static int average(List<Integer> list) 
    int sum = 0; 
    //遍历求和 
    for(int i : list) 
        num += i; 
     
    //除以人数，计算平均值 
    return sum/list.size(); 

把80万名学生的成绩放到一个ArrayList数组中，然后通过foreach方式遍历求和，再 计算平均值，程序非常简单，输出的结果是：

平均分是：74 执行时间：47ms

仅仅求一个算术平均值就花费了 47毫秒，不要说考虑其他诸如加权平均值、补充平均值等算法，那花的时间肯定更长。我们仔细分析一下arverage方法，加号操作是最基本操 作，没有什么可以优化的，剩下的就是一个遍历了，问题是List的遍历可以优化吗？

我们可以尝试一下，List的遍历还有另外一种方式，即通过下标方式来访问，代码如下:

public static int average(List<Integer> list) 
    int sum = 0; 
    //遍历求和 
    for(int i = 0, size = list.size(); i < size; i++) 
        sum += list.get(i); 
     
    //除以人数，计算平均值 
    return sum/list.size(); 
 

不再使用foreach方式遍历列表，而是采用下标方式遍历，我们看看输出结果如何：

平均分是：74

执行时间：16ms

执行时间已经大幅度下降，性能提升了 65%，这是一个飞速提升！那为什么我们使用下标方式遍历数组会有这么高的性能提升呢？

这是因为ArrayList数组实现了 RandomAccess接口（随机存取接口），这也就标志着 Array List 是一个可以随机存取的列表。在 Java 中，RandomAccess 和 Cloneable、Serializable一样，都是标志性接口，不需要任何实现，只是用来表明其实现类具有某种特质的，实现了Cloneable表明可以被拷贝，实现了 Serializable接口表明被序列化了，实现了 RandomAccess则表明这个类可以随机存取，对我们的ArrayList来说也就标志着其数据元素之间没有关联, 即两个位置相邻的元素之间没有相互依赖和索引关系，可以随机访问和存储。

我们知道，Java中的foreach语法是iterator (迭代器）的变形用法，也就是说上面的 foreach与下面的代码等价：

for(Iterator<Intoger>i=list.iterator(); i.hasNext(); )

  sum+=i.next()；

那我们再想想什么是迭代器，迭代器是23个设计模式中的一种，“提供一种方法访问一 个容器对象中的各个元素，同时又无须暴露该对象的内部细节”，也就是说对于ArrayList， 需要先创建一个迭代器容器，然后屏蔽内部遍历细节，对外提供hasNext、next等太法。问 题是ArrayList实现了 RandomAccess接口，已表明元素之间本来没有关系，可是，为了使用 迭代器就需要强制建立一种互相“知晓”的关系，比如上一个元素可以判断是否有下一个元素，以及下一个元素是什么等关系，这也就是通过foreach遍历耗时的原因。

Java 为 ArrayList 类加上了 RandomAccess 接口，就是在告诉我们，“嘿，ArrayList是随机存取的，采用下标方式遍历列表速度会更快”，接着又有一个问题了：为什么不把RandomAccess加到所有的List实现类上呢？

那是因为有些List实现类不是随机存取的，而是有序存取的，比如LinkedList类， LinkedList也是一个列表，但它实现了双向链表，每个数据结点中都有三个数据项：前节点的引用（Previous Node)、本节点元素（Node_Element)、后继节点的引用（Next Node),这是数据结构的基本知识，不多讲了，也就是说在LinkedList中的两个元素本 来就是有关联的，我知道你的存在，你也知道我的存在。那大家想想看，元素之间已经有关联关系了，使用foreach也就是迭代器方式是不是效率更高呢？我们修改一下例子， 代码如下：

public static void main(String[] args) 
    //学生数量，80万 
    int stuNum = 80 * 10000; 
    //List集合，记录所有学生分数 
    List<Integer> scores = new LinkedList<Integer>(); 
    //写入分数 
    for(int i = 0; i < stuNum; i++) 
        scores.add(new Random.nextIne(150)); 
     
    //记录开始计算时间 
    long start = System.currentTimeMillis(); 
    System.out.println("平均分是：" + average(scores)); 
    System.out.println("执行时间：" + (System.currentTimeMillis() - start) + "ms"); 
 
public static int average(List<Integer> list) 
    int sum = 0; 
    //foreach遍历求和 
    for(int i : list) 
        sum += i; 
     
    //除以人数，计算平均值 
    return sum/list.size(); 
 

运行的结果如下：

平均分是：74 执行时间：16ms

确实如此，也是16毫秒，效率非常高。可能大家还想要测试一下下标方式（也就是采用get方法访问元素）遍历LinkedList元素的情况，其实不用测试，效率真的非常低，我们 直接看源码：

public Eget(int index) 
    return entry(index).element;

由entry方法査找指定下标的节点，然后返回其包含的元素，看entry方法:

private Entry<E> entry(int index) 
    //检查下标是否越界 
    Entry<E> e = header; 
    if(index < (size >> 1)) 
        //如果下标小于中间值，则从头节点开始搜索 
        for(int i = 0; i <= index; I++) 
        e = e.next; 
    else 
        //如果下标大于等于中间值，则从尾节点反向遍历 
        for(int i = size; i > index; i++) 
            e = e.previous; 
         
    
    return e; 

看懂了吗？程序会先判断输入的下标与中间值（size右移一位，也就是除以2 了）的关 系，小于中间值则从头开始正向捜索，大于中间值则从尾节点反向搜索，想想看，每一次的

get方法都是一个遍历，“性能”两字从何说起呢！

明白了随机存取列表和有序存取列表的区别，我们的average方法就必须重构了，以便 实现不同的列表采用不同的遍历方式，代码如下：

publicstatic int average(List<Integer> list)  int sum = 0；

    if (list instanceof RandomAccess) 
    
        //可以随机存取，则使用下标遍历

        for (int i = 0, size = list.size)； i < size； i++) 
            sum += list.get(i);
        

     else 
        //有序存储，使用foreach方式 
        for(int i : list) 
            sum += i; 
         
        //除以人数，计算平均值 
        return sum / list.size ()；
    

如此一来，列表的遍历就可以“以不变应万变”了，无论是随机存取列表还是有序列 表，它都可以提供快速的遍历。

注意列表遍历不是那么简单的，其中很有“学问”，适时选择最优的遍历方式，不要固化为一种。