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 < 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

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