ArrayList和HashMap遍历方式的比较
文章目录
- Arraylist的遍历
- 1. 普通for循环
- 2. 增强for循环
- 3. Iterator 迭代器遍历
- 三种方式对比
- 总结
- Map的遍历
- 1. 增强for循环+keySet()
- 2. 增强for循环+entrySet()
- 3. Iterator+keySet()
- 4. itorator+entrySet()
- 效率对比
- 总结：
- java开发手册（关于map的）
- 文章参考于
- ArrayList三种遍历方式比较
- Java中HashMap遍历几种方式
Arraylist的遍历
1. 普通for循环
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
2. 增强for循环
- 增强for循环的底层也是 Iterator 实现的，仅对它包装了一下
for (int i : list) {
System.out.println(i);
}
3. Iterator 迭代器遍历
Iterator iterator = list.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
三种方式对比
public class ListErgodic {
public static void main(String[] args) {
List list = new ArrayList<>();
Random random = new Random();
for (int i = 0; i < Math.pow(10, 7); i++) {
list.add(random.nextInt((int) Math.pow(10, 7)));
}
for (int i = 0; i < 5; i++) {
System.out.println("第 " + (i + 1) + " 次");
forList(list);
forEachList(list);
iteratorList(list);
System.out.println();
}
}
public static void forList(List list) {
long start = System.currentTimeMillis();
for (int i = 0; i < list.size(); i++) {
}
long end = System.currentTimeMillis();
System.out.println("普通for循环遍历时间：" + (end - start));
}
public static void forEachList(List list) {
long start = System.currentTimeMillis();
for (int i : list) {
}
long end = System.currentTimeMillis();
System.out.println("增强for循环遍历时间：" + (end - start));
}
public static void iteratorList(List list) {
long start = System.currentTimeMillis();
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
iterator.next();
}
long end = System.currentTimeMillis();
System.out.println("Iterator 循环遍历时间：" + (end - start));
}
}
- 单纯遍历的实验结果
第 1 次
普通for循环遍历时间：3
增强for循环遍历时间：33
Iterator 循环遍历时间：9
第 2 次
普通for循环遍历时间：0
增强for循环遍历时间：21
Iterator 循环遍历时间：12
第 3 次
普通for循环遍历时间：0
增强for循环遍历时间：38
Iterator 循环遍历时间：2
第 4 次
普通for循环遍历时间：0
增强for循环遍历时间：22
Iterator 循环遍历时间：1
第 5 次
普通for循环遍历时间：0
增强for循环遍历时间：23
Iterator 循环遍历时间：2
普通for循环耗时最少，iterator次之，增强for循环耗时最长
- 取值的测试代码
public static void forList(List list) {
long start = System.currentTimeMillis();
int test = 0;
for (int i = 0; i < list.size(); i++) {
test = list.get(i);
}
long end = System.currentTimeMillis();
System.out.println("普通for循环遍历时间：" + (end - start));
}
public static void forEachList(List list) {
long start = System.currentTimeMillis();
int test = 0;
for (int i : list) {
test = list.get(i);
}
long end = System.currentTimeMillis();
System.out.println("增强for循环遍历时间：" + (end - start));
}
public static void iteratorList(List list) {
long start = System.currentTimeMillis();
int test = 0;
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
test = (int) iterator.next();
}
long end = System.currentTimeMillis();
System.out.println("Iterator 循环遍历时间：" + (end - start));
}
- 取值的实验结果
第 1 次
普通for循环遍历时间：45
增强for循环遍历时间：396
Iterator 循环遍历时间：39
第 2 次
普通for循环遍历时间：22
增强for循环遍历时间：362
Iterator 循环遍历时间：22
第 3 次
普通for循环遍历时间：39
增强for循环遍历时间：392
Iterator 循环遍历时间：39
第 4 次
普通for循环遍历时间：23
增强for循环遍历时间：373
Iterator 循环遍历时间：26
第 5 次
普通for循环遍历时间：26
增强for循环遍历时间：403
Iterator 循环遍历时间：23
总结
- 普通for循环耗时最少，iterator次之，增强for循环耗时最长
Map的遍历
- 大致分为 增强for循环 和 **Iterator迭代器 **两种，而其中每个又各自分为使用 keySet() 和 entrySet() 两种，所以 一共四种。
1. 增强for循环+keySet()
for (int i : map.keySet()) {
map.get(i);
}
2. 增强for循环+entrySet()
for (Map.Entry entry : map.entrySet()) {
entry.getKey();
entry.getValue();
}
3. Iterator+keySet()
Iterator iterator = map.keySet().iterator();
while (iterator.hasNext()) {
Object key = iterator.next();
Object value = map.get(key);
}
4. itorator+entrySet()
Iterator iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry entry = (Map.Entry) iterator.next();
entry.getKey();
entry.getValue();
}
效率对比
- 向map中随机添加1000000个数，仅测试 取值效率
public class HashMapErgodic {
public static void main(String[] args) {
Random random = new Random();
Map map = new HashMap<>();
for (int i = 0; i < Math.pow(10, 6); i++) {
//向 map中随机添加 1000000个随机整数
map.put(i, random.nextInt((int) Math.pow(10, 6)));
}
for (int i = 0; i < 5; i++) {
System.out.println("第 " + (i + 1) + " 次");
forEachKeySet(map);
forEachEntrySet(map);
IteratorKeySet(map);
IteratorEntrySet(map);
System.out.println();
}
}
public static void forEachKeySet(Map map) {
long start = System.currentTimeMillis();
for (int i : map.keySet()) {
map.get(i);
}
long end = System.currentTimeMillis();
System.out.println("增强for循环 keySet() 遍历时间：" + (end - start));
}
public static void forEachEntrySet(Map map) {
long start = System.currentTimeMillis();
for (Map.Entry entry : map.entrySet()) {
entry.getKey();
entry.getValue();
}
long end = System.currentTimeMillis();
System.out.println("增强for循环 entrySet() 遍历时间：" + (end - start));
}
public static void IteratorKeySet(Map map) {
long start = System.currentTimeMillis();
Iterator iterator = map.keySet().iterator();
while (iterator.hasNext()) {
Object key = iterator.next();
Object value = map.get(key);
}
long end = System.currentTimeMillis();
System.out.println("Iterator keySet() 遍历时间：" + (end - start));
}
public static void IteratorEntrySet(Map map) {
long start = System.currentTimeMillis();
Iterator iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry entry = (Map.Entry) iterator.next();
entry.getKey();
entry.getValue();
}
long end = System.currentTimeMillis();
System.out.println("Iterator entrySet() 遍历时间：" + (end - start));
}
}
- 测试结果
第 1 次
增强for循环 keySet() 遍历时间：70
增强for循环 entrySet() 遍历时间：35
Iterator keySet() 遍历时间：42
Iterator entrySet() 遍历时间：40
第 2 次
增强for循环 keySet() 遍历时间：66
增强for循环 entrySet() 遍历时间：15
Iterator keySet() 遍历时间：26
Iterator entrySet() 遍历时间：15
第 3 次
增强for循环 keySet() 遍历时间：90
增强for循环 entrySet() 遍历时间：42
Iterator keySet() 遍历时间：54
Iterator entrySet() 遍历时间：32
第 4 次
增强for循环 keySet() 遍历时间：27
增强for循环 entrySet() 遍历时间：21
Iterator keySet() 遍历时间：25
Iterator entrySet() 遍历时间：16
第 5 次
增强for循环 keySet() 遍历时间：25
增强for循环 entrySet() 遍历时间：19
Iterator keySet() 遍历时间：27
Iterator entrySet() 遍历时间：15
总结：
- entrySet() 比 keySet() 效率要好点
- Iterator 要比 for each 效率要好点
- 所以：Iterator + entrySet() 效率最好（参考需谨慎）
java开发手册（关于map的）
-
推荐使用 entrySet 遍历 Map 集合 KV，而不是使用 keySet 方式遍历
-
原因：keySet 其实是遍历了2次，一次是转为 Iterator 对象，另一次是从 hashMap 中取出 key 所对应的 value。而 entrySet 只是遍历了一次就把 key 和 value 都放到了 entry 中，效率更高。如果是JDK8，使用 Map.foreach方法。
-
正例：values() 返回的是V值集合，是一个 list 集合对象，keySet() 返回的是 K值集合，是一个Set集合对象，entrySet() 返回的是 K-V值组合集合。
import java.util.*;
public class MapForeachTest{
public static void main(String[] args){
Map <String ,Integer> hashMap = new HashMap<>();
hashMap.put("key_1",1);
hashMap.put("key_2",2);
hashMap.put("key_3",3);
//开发手册推荐的传统方式 entrySet()
Iterator iterator = hashMap.entrySet().iterator();
while(iterator.hasNext()){
Map.Entry entry = (Map.Entry) iterator.next();
System.out.println(entry.getKey()+":"+entry.getValue());
}
System.out.println();
//JDK8提供的方法
hashMap.forEach((key,value) ->{
System.out.println(key+":"+value);
});
}
}
- 运行结果
key_3:3
key_2:2
key_1:1
key_3:3
key_2:2
key_1:1