Java_集合操作_不同的列表选择不同的遍历方法

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

package deep;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class Client {

    public static void main(String[] args) {
        // 学生数量,80万
        int stuNum = 80 * 10000;
        // List集合,记录所有学生的分数
        List<Integer> scores = new ArrayList<Integer>(stuNum);// 指定list的大小,避免长度不够不断开辟新空间造成性能浪费
        // 写入分数
        for (int i = 0; i < stuNum; ++i) {
            scores.add(new Random().nextInt(150));
        }
        // 记录开始计算时间
        long start = System.currentTimeMillis();
        System.out.println("平均分是:" + average(scores));
        System.out.println("执行时间:" + (System.currentTimeMillis() - start)
                + "ms");
    }

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

}

把80万名学生的成绩放到一个ArrayList数组中,然后通过高级for方式遍历求和,再计算平均值,程序非常简单,输出的结果是:
平均分是:74
执行时间:16ms

我们仔细分析一下average方法,加号操作是最基本操作,没有什么可以优化的,剩下的就是一个遍历了,问题是List的遍历可以优化吗?
我们可以尝试一下,List的遍历还有另外一种方式,即通过下标方式来访问,代码如下:

    // 计算平均数
    private 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();
    }

不再使用高级for方式遍历列表,而是采用下标方式遍历,我们看看输出结果如何:
平均分是:74
执行时间:8ms

执行时间已经大幅下降,为什么?
这是因为ArrayList数组实现了RandomAccess接口(随机存取接口),如下:

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

这也就标志着ArrayList是一个可以随机存取的列表。在Java中,RandomAccess和Cloneable、Serializable一样,都是标志性接口,如下:

package java.util;

/**
 * Marker interface used by <tt>List</tt> implementations to indicate that
 * they support fast (generally constant time) random access.  The primary
 * purpose of this interface is to allow generic algorithms to alter their
 * behavior to provide good performance when applied to either random or
 * sequential access lists.
 *
 * <p>The best algorithms for manipulating random access lists (such as
 * <tt>ArrayList</tt>) can produce quadratic behavior when applied to
 * sequential access lists (such as <tt>LinkedList</tt>).  Generic list
 * algorithms are encouraged to check whether the given list is an
 * <tt>instanceof</tt> this interface before applying an algorithm that would
 * provide poor performance if it were applied to a sequential access list,
 * and to alter their behavior if necessary to guarantee acceptable
 * performance.
 *
 * <p>It is recognized that the distinction between random and sequential
 * access is often fuzzy.  For example, some <tt>List</tt> implementations
 * provide asymptotically linear access times if they get huge, but constant
 * access times in practice.  Such a <tt>List</tt> implementation
 * should generally implement this interface.  As a rule of thumb, a
 * <tt>List</tt> implementation should implement this interface if,
 * for typical instances of the class, this loop:
 * <pre>
 *     for (int i=0, n=list.size(); i &lt; n; i++)
 *         list.get(i);
 * </pre>
 * runs faster than this loop:
 * <pre>
 *     for (Iterator i=list.iterator(); i.hasNext(); )
 *         i.next();
 * </pre>
 *
 * <p>This interface is a member of the
 * <a href="{@docRoot}/../technotes/guides/collections/index.html">
 * Java Collections Framework</a>.
 *
 * @since 1.4
 */
public interface RandomAccess {
}

不需要任何实现,只是用来表明其实现类具有某种特质的,实现了Cloneable表明可以被拷贝,实现了Serializable接口表明被序列化了,实现了RandomAccess则表明这个类可以随机存取,对我们的ArrayList来说也就标志着其数据元素之间没有关联,即两个位置相邻的元素之间没有相互依赖和索引关系,可以随机访问和存储。
我们知道,Java中的高级for语法是iteator(迭代器)的变形用法,也就是说上面的高级for与下面的代码等价:

        for (Iterator<Integer> i = list.iterator(); i.hasNext();) {
            sum += i.next();
        }

那我们再想想什么是迭代器,迭代器是23个设计模式中的一种,“提供一种方法访问一个容器对象的各个元素,同时又无须暴露该对象的内部细节”,也就是说对于ArrayList,需要先创建一个迭代器容器,然后屏蔽内部遍历细节,对外提供hasNext、next等方法。问题是ArrayList实现了RandomAccess接口,已表明元素之间本来没有关系,可是,为了使用迭代器就需要强制建立一种互相“知晓”的关系,比如上一个元素可以判断是否有下一个元素,以及下一个元素是什么等关系,这也就是通过高级for遍历耗时的原因。
Java为ArrayList类加上了RandomAccess接口,就是在告诉我们,“嘿,ArrayList是随机存取的,采用下标方式遍历列表会更快”,接着又有一个问题了:为什么不把RandomAccess加到所有的List实现类上呢?
那是因为有些List实现类不是随机存取的,而是有序存取的,比如LinkedList类,LinkedList也是一个列表,但它实现了双向链表,每个数据点中都有三个数据项:前节点的引用(Previous Node)、本节点元素(Node Element)、后继节点的引用(Next Node),这是数据结构的基本知识,不多讲了,也就是说在LinkedList中的两个元素本来就是有关联的,我知道你的存在,你也知道我的存在。那大家想想看,元素之间已经有关联关系了,使用高级for也就是迭代器方式是不是效率更高呢?我们修改一下例子,代码如下:

package deep;

import java.util.LinkedList;
import java.util.List;
import java.util.Random;

public class Client {

    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().nextInt(150));
        }
        // 记录开始计算时间
        long start = System.currentTimeMillis();
        System.out.println("平均分是:" + average(scores));
        System.out.println("执行时间:" + (System.currentTimeMillis() - start)
                + "ms");
    }

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

}

运行结果:
平均分是:74
执行时间:14ms

我们再来测试一下下标方式遍历LinkedList元素的情况:

    // 计算平均数
    private 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();
    }

运行结果:
平均分是:74
执行时间:791159ms

效率真的非常低!!!我们直接来看下标方式遍历LinkedList源码:

    public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
    }
    Node<E> node(int index) {
        // assert isElementIndex(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方法都是一个遍历,“性能”二字从何说起呢!
明白了随机存取列表和有序存取列表的区别,我们的average方法就必须重构了,以便实现不同的列表采用不同的遍历方式,代码如下:

package deep;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;
import java.util.RandomAccess;

public class Client {

    public static void main(String[] args) {
        // 学生数量,80万
        int stuNum = 80 * 10000;
        // List集合,记录所有学生的分数
        List<Integer> scoresAL = new ArrayList<Integer>(stuNum);
        List<Integer> scoresLL = new LinkedList<Integer>();
        // 写入分数
        for (int i = 0; i < stuNum; ++i) {
            scoresAL.add(new Random().nextInt(150));
            scoresLL.add(new Random().nextInt(150));
        }
        // 记录开始计算时间
        long startAL = System.currentTimeMillis();
        System.out.println("平均分是:" + average(scoresAL));
        System.out.println("scoresAL执行时间:"
                + (System.currentTimeMillis() - startAL) + "ms");
        long startLL = System.currentTimeMillis();
        System.out.println("平均分是:" + average(scoresLL));
        System.out.println("scoresLL执行时间:" + (System.currentTimeMillis() - startLL)
                + "ms");
    }

    // 计算平均数
    private static 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 {
            // 有序存取,使用高级for(迭代器)
            for (int i : list) {
                sum += i;
            }
        }
        // 除以人数,计算平均值
        return sum / list.size();
    }

}

运行结果:
平均分是:74
scoresAL执行时间:8ms
平均分是:74
scoresLL执行时间:16ms

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

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值