我们来思考这样一个案例:统计一个省得各科高考平均值,比如数学平均分是多少,语文平均分是多少等,这是每年招生办都会公布的数据,我们来想想看该算法应如何实现。当然使用数据库中的一个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 scores = new ArrayList(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 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 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 extends AbstractList implements List, RandomAccess, Cloneable, java.io.Serializable
这也就标志着ArrayList是一个可以随机存取的列表。在Java中,RandomAccess和Cloneable、Serializable一样,都是标志性接口,如下:
package java.util;
/**
* Marker interface used by List 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.
*
*
The best algorithms for manipulating random access lists (such as
* ArrayList) can produce quadratic behavior when applied to
* sequential access lists (such as LinkedList). Generic list
* algorithms are encouraged to check whether the given list is an
* instanceof 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.
*
*
It is recognized that the distinction between random and sequential
* access is often fuzzy. For example, some List implementations
* provide asymptotically linear access times if they get huge, but constant
* access times in practice. Such a List implementation
* should generally implement this interface. As a rule of thumb, a
* List implementation should implement this interface if,
* for typical instances of the class, this loop:
*
* for (int i=0, n=list.size(); i < n; i++)
* list.get(i);
*
* runs faster than this loop:
*
* for (Iterator i=list.iterator(); i.hasNext(); )
* i.next();
*
*
*
This interface is a member of the
* Java Collections Framework.
*
* @since 1.4
*/
public interface RandomAccess {
}
不需要任何实现,只是用来表明其实现类具有某种特质的,实现了Cloneable表明可以被拷贝,实现了Serializable接口表明被序列化了,实现了RandomAccess则表明这个类可以随机存取,对我们的ArrayList来说也就标志着其数据元素之间没有关联,即两个位置相邻的元素之间没有相互依赖和索引关系,可以随机访问和存储。
我们知道,Java中的高级for语法是iteator(迭代器)的变形用法,也就是说上面的高级for与下面的代码等价:
for (Iterator 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 scores = new LinkedList();
// 写入分数
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 list) {
int sum = 0;
// 遍历求和
for (int i : list) {
sum += i;
}
// 除以人数,计算平均值
return sum / list.size();
}
}
运行结果:
平均分是:74
执行时间:14ms
我们再来测试一下下标方式遍历LinkedList元素的情况:
// 计算平均数
private static int average(List 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 node(int index) {
// assert isElementIndex(index);
if (index < (size >> 1)) {
Node x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
Node 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 scoresAL = new ArrayList(stuNum);
List scoresLL = new LinkedList();
// 写入分数
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 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
列表遍历不是那么简单的,其中很有“学问”,适时选择最优的遍历方式,不要固化为一种。