[置顶] HashMap循环遍历方式及其性能对比 主要介绍HashMap的四种循环遍历方式，各种方式的性能测试对比，根据HashMap的源码实现分析性能结果，总结结论。
1. Map的四种遍历方式
下面只是简单介绍各种遍历示例(以HashMap为例)，各自优劣会在本文后面进行分析给出结论。
(1) for each map.entrySet()
(2) 显示调用map.entrySet()的集合迭代器
(3) for each map.keySet()，再调用get获取
(4) for each map.entrySet()，用临时变量保存map.entrySet()
在测试前大家可以根据对HashMap的了解，想想上面四种遍历方式哪个性能更优。
2、HashMap四种遍历方式的性能测试及对比
以下是性能测试代码，会输出不同数量级大小的HashMap各种遍历方式所花费的时间。
import java.text.DecimalFormat;
import java.util.Calendar;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
/**
* JavaLoopTest
*
* @author www.trinea.cn 2013-10-28
*/
public class JavaLoopTest {
public static void main(String[] args) {
System.out.print("compare loop performance of HashMap");
loopMapCompare(getHashMaps(10000, 100000, 1000000, 2000000));
}
public static Map<String, String>[] getHashMaps(int... sizeArray) {
Map<String, String>[] mapArray = new HashMap[sizeArray.length];
for (int i = 0; i < sizeArray.length; i++) {
int size = sizeArray[i];
Map<String, String> map = new HashMap<String, String>();
for (int j = 0; j < size; j++) {
String s = Integer.toString(j);
map.put(s, s);
}
mapArray[i] = map;
}
return mapArray;
}
public static void loopMapCompare(Map<String, String>[] mapArray) {
printHeader(mapArray);
long startTime, endTime;
// Type 1
for (int i = 0; i < mapArray.length; i++) {
Map<String, String> map = mapArray[i];
startTime = Calendar.getInstance().getTimeInMillis();
for (Entry<String, String> entry : map.entrySet()) {
entry.getKey();
entry.getValue();
}
endTime = Calendar.getInstance().getTimeInMillis();
printCostTime(i, mapArray.length, "for each entrySet", endTime - startTime);
}
// Type 2
for (int i = 0; i < mapArray.length; i++) {
Map<String, String> map = mapArray[i];
startTime = Calendar.getInstance().getTimeInMillis();
Iterator<Map.Entry<String, String>> iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<String, String> entry = iterator.next();
entry.getKey();
entry.getValue();
}
endTime = Calendar.getInstance().getTimeInMillis();
printCostTime(i, mapArray.length, "for iterator entrySet", endTime - startTime);
}
// Type 3
for (int i = 0; i < mapArray.length; i++) {
Map<String, String> map = mapArray[i];
startTime = Calendar.getInstance().getTimeInMillis();
for (String key : map.keySet()) {
map.get(key);
}
endTime = Calendar.getInstance().getTimeInMillis();
printCostTime(i, mapArray.length, "for each keySet", endTime - startTime);
}
// Type 4
for (int i = 0; i < mapArray.length; i++) {
Map<String, String> map = mapArray[i];
startTime = Calendar.getInstance().getTimeInMillis();
Set<Entry<String, String>> entrySet = map.entrySet();
for (Entry<String, String> entry : entrySet) {
entry.getKey();
entry.getValue();
}
endTime = Calendar.getInstance().getTimeInMillis();
printCostTime(i, mapArray.length, "for entrySet=entrySet()", endTime - startTime);
}
}
static int FIRST_COLUMN_LENGTH = 23, OTHER_COLUMN_LENGTH = 12, TOTAL_COLUMN_LENGTH = 71;
static final DecimalFormat COMMA_FORMAT = new DecimalFormat("#,###");
public static void printHeader(Map... mapArray) {
printRowDivider();
for (int i = 0; i < mapArray.length; i++) {
if (i == 0) {
StringBuilder sb = new StringBuilder().append("map size");
while (sb.length() < FIRST_COLUMN_LENGTH) {
sb.append(" ");
}
System.out.print(sb);
}
StringBuilder sb = new StringBuilder().append("| ").append(COMMA_FORMAT.format(mapArray[i].size()));
while (sb.length() < OTHER_COLUMN_LENGTH) {
sb.append(" ");
}
System.out.print(sb);
}
TOTAL_COLUMN_LENGTH = FIRST_COLUMN_LENGTH + OTHER_COLUMN_LENGTH * mapArray.length;
printRowDivider();
}
public static void printRowDivider() {
System.out.println();
StringBuilder sb = new StringBuilder();
while (sb.length() < TOTAL_COLUMN_LENGTH) {
sb.append("-");
}
System.out.println(sb);
}
public static void printCostTime(int i, int size, String caseName, long costTime) {
if (i == 0) {
StringBuilder sb = new StringBuilder().append(caseName);
while (sb.length() < FIRST_COLUMN_LENGTH) {
sb.append(" ");
}
System.out.print(sb);
}
StringBuilder sb = new StringBuilder().append("| ").append(costTime).append(" ms");
while (sb.length() < OTHER_COLUMN_LENGTH) {
sb.append(" ");
}
System.out.print(sb);
if (i == size - 1) {
printRowDivider();
}
}
}
PS：如果运行报异常in thread “main” java.lang.OutOfMemoryError: Java heap space，请将main函数里面map size的大小减小。
其中getHashMaps函数会返回不同size的HashMap。
loopMapCompare函数会分别用上面的遍历方式1-4去遍历每一个map数组(包含不同大小HashMap)中的HashMap。
print开头函数为输出辅助函数，可忽略。
测试环境为Windows7 32位系统 3.2G双核CPU 4G内存，Java 7，Eclipse -Xms512m -Xmx512m
最终测试结果如下：
表横向为同一遍历方式不同大小HashMap遍历的时间消耗，纵向为同一HashMap不同遍历方式遍历的时间消耗。
PS：由于首次遍历HashMap会稍微多耗时一点，for each的结果稍微有点偏差，将测试代码中的几个Type顺序调换会发现，for each entrySet耗时和for iterator entrySet接近。
3、遍历方式性能测试结果分析
(1) foreach介绍
见：ArrayList和LinkedList的几种循环遍历方式及性能对比分析中介绍。
(2) HashMap遍历方式结果分析
从上面知道for each与显示调用Iterator等价，上表的结果中可以看出除了第三种方式(for each map.keySet())，再调用get获取方式外，其他三种方式性能相当。本例还是hash值散列较好的情况，若散列算法较差，第三种方式会更加耗时。
我们看看HashMap entrySet和keySet的源码
分别是keySet()和entrySet()返回的set的迭代器，从中我们可以看到只是返回值不同而已，父类相同，所以性能相差不多。只是第三种方式多了一步根据key get得到value的操作而已。get的时间复杂度根据hash算法而异，源码如下：