ArrayList和HashMap遍历方式的比较

最新推荐文章于 2024-05-09 14:15:16 发布
最新推荐文章于 2024-05-09 14:15:16 发布
阅读量1k 收藏 8
点赞数
分类专栏： javaweb初长成 文章标签： list map 遍历
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37638061/article/details/89606140
版权

文章目录

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<Integer> 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<Integer> 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<Integer> list) {
        long start = System.currentTimeMillis();

        for (int i : list) {
           
        }

        long end = System.currentTimeMillis();
        System.out.println("增强for循环遍历时间：" + (end - start));
    }

    public static void iteratorList(List<Integer> 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<Integer> 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<Integer> 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<Integer> 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<Integer, Integer> 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<Integer, Integer> 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<Integer, Integer> 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<Integer, Integer> map) {
        long start = System.currentTimeMillis();

        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
            entry.getKey();
            entry.getValue();
        }

        long end = System.currentTimeMillis();
        System.out.println("增强for循环 entrySet() 遍历时间：" + (end - start));
    }


    public static void IteratorKeySet(Map<Integer, Integer> 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<Integer, Integer> 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
落叶无痕00
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
list，map，遍历速度最优方案
pinklpig的专栏
07-24 1万+
JAVA遍历LIst的性能有以下两种方法遍历：      [code]public void list1(List list)        {                long l1 = System.currentTimeMillis();
hashmap和arraylist的区别
weixin_34245749的博客
01-29 1973
2019独角兽企业重金招聘Python工程师标准>>> ...
ArrayList和hashMap的几种遍历方法
hangshao的博客
03-23 1278
ArrayList的遍历 方法一：for each循环 List list = new ArrayList(); for (Integer j : list) { // use j }方法二：显式调用集合迭代器 Listlist = new ArrayList(); for (Iteratoriterator = list.iterator();iterator.hasNex
ArrayList的三种遍历方式
最新发布
weixin_65469337的博客
05-09 232
首先创建一个顺序表，通过add为表中添加四个整型元素。可以还从后往前遍历，需要传入最后一个元素的位置。两种方式都可以，相当于第一个是第二个的父类。2通过for each遍历。1通过for循环遍历。
ArrayList、LinkedList、HashMap哪个速度更快?
Coinker的博客
01-24 6303
1、ArrayList 有序集合 底层为数组 按下标查找快 增删慢 按元素查找、增删都慢 2、LinkedList 有序集合 底层为链表 按下标查找慢 增删快 按元素查找慢 增删比arrayList快 3、HashMap 无序哈希表 底层哈希表 按下标查找一般比LinkedList快 增删快跟主体大小有关 按元素查找快 增删快跟主体大小有关，越大越慢...
区别是什么
上官铁头
09-27 334
他们的底层实现不同，ArrayList和Map的底层实现是数组，Set的底层实现是Map, Map是要存放两个值，key和value，key不能重复，而Set的实现是存放Map的key，所以Set的值也不能重复，Map,和Set无序且不可重复，ArrayList有序可重复 如果ArrayList 和Map存储的元素都比较多。那么在取元素方面，ArrayList要慢很多。 但是这也不是绝对
Java数据存储类型ArrayList、HashSet、HashMap、LinkedList使用不同遍历方法效率研究By Python
12-22
ArrayList HashSet HashMap LinkedList 遍历方法 传统遍历方法 for(int i=0;i<list.size();i++) { String str = list.get(i); ... } 内置迭代器 for (String str : list) { ... } 显式迭代器 Iterator it = ...
HashMap和链表的查找效率比较
04-09
在Java编程语言中，`HashMap`和`List`（通常指的是`ArrayList`或`LinkedList`）是两种常用的数据结构，它们各自在不同的场景下有着不同的性能优势。本工程通过`VS2013`（Visual Studio 2013，虽然它主要用于C++开发...
java遍历机制性能的比较详解
08-25
Java遍历机制性能的比较详解主要探讨了Java中三种常见的遍历方式——for循环、forEach循环和Iterator循环在处理ArrayList、LinkedList和HashSet等基础数据结构时的性能差异。本文将详细解析这些遍历机制的工作原理...
使用Enumeration和Iterator遍历集合类详解
09-05
例如，`Vector` 和 `Hashtable` 这些旧的集合类仍然支持 `Enumeration`，但在新代码中，应尽量避免使用这些过时的集合类型，转而使用 `ArrayList`、`HashMap` 等现代集合类，它们默认支持 `Iterator`。 总结来说，`...
比较分析Vector、ArrayList和hashtable hashmap数据结构
09-01
比较分析Vector、ArrayList和hashtable hashmap数据结构
HashMap与ArrayList的PK
轻轻草原
11-04 193
本周要闻，这一周自己先干了两天的代码优化工作，优化自己的导入代码，在虎哥的指引下自己一步步理解优化这个过程很艰辛啊，其中在这个过程中理解到了，一个好的设计并非那么容易，同样一段程序如何让这段代码学的非常有精髓，有思想，这一点是非常不容易的。 对于以前自己很多地方都是用的list这样在循环太可怕了，五千次不怕，怕的是五千乘以五千这样你的代码现的非常没有代码深度，这样你的代码循环起来太慢了，这个...
HashMap存取效率高原因、ArrayList和LinkedList区别、JAVA实现链表的基本功能
choujudian4301的博客
02-14 686
一、HashMap存取效率高原因 1、Hash 也叫散列、哈希。 主要用于信息安全领域中的算法，把长度不同的信息转化为杂乱的128位的编码，找到一种数据内容与地址之间的映射关系。 注意：不同的输入可能会散列成相同的输出 我们最熟悉的Object类中就提供了hashcod...
ArrayList和HashMap比较
DX390609的博客
08-09 851
相同点： 1.都是线程不安全，不同步 2.都可以储存null值 3.获取元素个数方法一样，都是用size()方法获取 4.都是可扩容的容器 区别： 1.实现的接口 ArrayList实现了List接口（Collection（接口）->List(接口）->ArrayList（类）），底层使用的是数组；HashMap实现了Map接口，底层使用的是数组+链表结构 2.添加元素的方法 ArrayList用add(Object object)方法添加元素，而HashMap用put(Object key,O
ArrayList和HashMap的遍历方式
Kunaly
09-12 451
ArrayList和HashMap的遍历方式 ArrayList的遍历方式 package com.kun.package3; import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class ArrayListTest { public static void main(String[] args) { List<String> list = new
Java集合遍历汇总（HashMap，ArrayList）
qq_38596491的博客
07-18 164
一、HashMap遍历 1.1 foreach遍历，——keySet() + get(key) import java.util.*; public class Main { public static void main(String[] args) { Map<Integer,String> map = new HashMap<>(); map.put(1,"asd"); map.put(2,"dgh"); map.put(3,"awe"); map
Java中ArrayList与HashMap的遍历
cece0926的专栏
11-01 1958
1.ArrayList遍历 [html] view plaincopyprint? package com.test;      import java.util.ArrayList;   import java.util.Iterator;   import java.util.List;   public class Array
Arraylist和hashMap正在遍历的时候插入有什么问题
03-13
对于ArrayList，可以使用Iterator进行遍历，而对于HashMap，可以使用Iterator或者entrySet进行遍历。在遍历过程中，如果需要插入元素，可以先将元素添加到一个临时的集合中，遍历完成后再将临时集合中的元素添加到原...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值