精华内容
下载资源
问答
  • HashTable遍历效率比较

    2020-04-18 01:34:30
    HashTable遍历效率比较一、什么是Hashtable二、4种遍历方法三、测试四、结果 一、什么是Hashtable Hashtable 类代表了一系列基于键的哈希代码组织起来的键/值对。它使用键来访问集合中的元素。 二、4种遍历方法 ...

    一、什么是Hashtable

    Hashtable 类代表了一系列基于的哈希代码组织起来的/对。它使用键来访问集合中的元素。

    二、4种遍历方法

    HashTable 遍历的时候,有4种方法

    • Method1: 通过foreach遍历哈希表中的
    • Method2: 通过foreach遍历哈希表中的
    • Method3: DictionaryEntry 遍历哈希表中的键值
    • Method4:IDictionaryEnumerator 遍历哈希表中的键值

    三、测试

    生成1千万条hashtable数据进行比对:

    static void Main(string[] args)
     {
     	//--------产生1000W条HashTable记录-------------------
         Hashtable hashtable = new Hashtable();
         for (int i = 0; i < 10000000; i++)
         {
             hashtable.Add(i.ToString(), "qcj");
         }
         Console.WriteLine("Ready? Let's Go!");
         Console.WriteLine(" ");
         Stopwatch watch = new Stopwatch();
         
         //遍历方法一:遍历哈希表中的键--------------------
         watch.Start();
         foreach (string key in hashtable.Keys)
         {
             //Console.WriteLine(string.Format("{0}-{1}"), key, hashtable[key]);
         }
         watch.Stop();
         Console.WriteLine("foreach遍历键:" + watch.Elapsed.TotalSeconds);
         Console.WriteLine("**********************************************************");
         
         //遍历方法二:遍历哈希表中的值----------------------
         watch.Restart();
         foreach (string value in hashtable.Values)
         {
            // Console.WriteLine(value);
         }
         watch.Stop();
         Console.WriteLine("foreach遍历值:" + watch.Elapsed.TotalSeconds);
         Console.WriteLine("**********************************************************");
         //遍历方法三:遍历哈希表中的键值-------------------
         watch.Restart();
         foreach (DictionaryEntry de in hashtable)
         {
            // Console.WriteLine(string.Format("{0}-{1}", de.Key, de.Value));
         }
         watch.Stop();
         Console.WriteLine("DictionaryEntry 遍历键值:" + watch.Elapsed.TotalSeconds);
         Console.WriteLine("**********************************************************");
         //遍历方法四:遍历哈希表中的键值------------------------
         watch.Restart();
         IDictionaryEnumerator myEnumerator = hashtable.GetEnumerator();
         bool flag = myEnumerator.MoveNext();
         while (flag)
         {
             //Console.WriteLine(myEnumerator.Key + "-" + myEnumerator.Value);
             flag = myEnumerator.MoveNext();
         }
         watch.Stop();
         Console.WriteLine("IDictionaryEnumerator 遍历键值:" + watch.Elapsed.TotalSeconds);
         Console.Read();
     }
    

    最后结果如下:
    在这里插入图片描述

    四、结果

    结果表明:

    • foreach遍历值和IDictionaryEnumerator遍历键值速度差不多

    • IDictionaryEnumerator要更快一点,而且能同时获得key 和 value

    • foreach遍历值的时候访问不到键,遍历键的时候访问不到值。

    展开全文
  • 1、主要目的是为了比较LinkedList和ArrayList的插入效率一级遍历效率,预期的结果是LinkedList比ArrayList插入效率高,但遍历效率低,下面用代码证明下。2、代码如下:package com.example.test;import java.util....
    1主要目的是为了比较LinkedList和ArrayList的插入效率一级遍历效率,预期的结果是LinkedList比ArrayList插入效率高,但遍历效率低,下面用代码证明下。

    2、代码如下:
    package com.example.test;

    import java.util.ArrayList;
    import java.util.LinkedList;
    import java.util.List;

    public class ListTest {
    public static void main(String[] args) {

    testListInsertTime("ArrayList:" , new ArrayList<>());
    testListInsertTime("LinkedList:" ,new LinkedList<>());

    }

    public static void testListInsertTime(String type,List<Object> list) {
    long begin = System.currentTimeMillis();
    for (int i = 0; i < 50000; i++) {
    Object o = new Object();
    list.add(0,o);
    }
    System.out.println(type +"插入耗时" +(System.currentTimeMillis() - begin) + "ms");
    long t = System.currentTimeMillis();
    for (int i = 0;i<50000; i++) {
    Object o = list.get(i);
    }
    System.out.println(type +"遍历耗时" + (System.currentTimeMillis() - t) + "ms");
    }
    }

    3、运行结果
    ArrayList:插入耗时211ms
    ArrayList:遍历耗时2ms
    LinkedList:插入耗时5ms
    LinkedList:遍历耗时1229ms

    4、事实证明插入效率,LinkedList要比ArrayList好的多;但遍历效率ArrayList比LinkedList效率要高的多。
    展开全文
  • list和maps的查询及遍历效率对比

    千次阅读 2020-12-16 16:44:22
    list和maps的查询及遍历效率对比 list和maps的查询及遍历效率对比 一、查询效率对比 1.测试方法: 测试代码如下: 方法F1、F2执行1000000次,得出测试结果: 2.遍历效率对比 测试代码如下: 方法执行10000次,...

    1.查询效率对比:

    测试代码如下:
    在这里插入图片描述
    方法F1、F2执行1000000次,得出测试结果:
    在这里插入图片描述

    2.遍历效率对比

    测试代码如下:

    方法执行10000次,得出测试结果:
    在这里插入图片描述

    总结

    遍历为主的数据,应优先使用lists,并且遍历使用foldl比使用map更快。maps:map会将数据转为list,效率是比较低下的,不过它的fold不需要将数据转为list结构来遍历,而是使用迭代器,效率会更高。
    插入和查询为主的数据,应优先使用maps,速度快了好几个级别,这得益于它的数据结构。maps底层数据结构也是有意思,元素数量小于等于32为flatmap,多于32的时候为hashmap结构

    展开全文
  • java map集合如何遍历效率高java中Map遍历的方式 一、前言 1、在看 《阿里巴巴java开发手册》时候,有一条推荐的规约: 【推荐】使用entrySet遍历Map类集合KV,而不是keySet方式进行遍历。 说明:keySet其实是...

                                 java map集合如何遍历效率高 java中Map遍历的方式

     

    一、前言

    1、在看 《阿里巴巴java开发手册》时候,有一条推荐的规约: 【推荐】使用entrySet遍历Map类集合KV而不是keySet方式进行遍历。 说明:keySet其实是遍历了2次,一次是转为Iterator对象,另一次是从hashMap中取出key所对应的value。而entrySet只是遍历了一次就把key和value都放到了entry中,效率更高。 ---- 那么如何理解那一段话呢? map 集合如何遍历效率高?

     

     

    二、Map集合的遍历

    1、根据 key 找 value

    • 获取所有的 key 集合。 map.keySet() 
    • 遍历 key 集合。

    • 根据 key 到集合中去找 value 。 map.get(key)

     

    2、根据 key--value 键值对 找键和值

    • 获取所有的 key--value键值对集合。 map.entrySet()
    • 遍历键值对集合,获取每一个键值对对象。
    • 根据键值对对象,获取 key 键 和 value 值。 entry.getKey(); entry.getValue();

     

    3、遍历values 值对象: map.values();

     

    三、代码实现

    1、 遍历测试代码如下:

    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Map.Entry;
    import org.junit.Test;
    /**
    * description: 遍历Map集合效率比较
    * @version v1.0
    * @author w
    * @date 2018年10月23日上午11:20:08
    */
    public class ForeachMap {
        /**
        * description: 初始化map集合中元素
        * @param map
        * @version v1.0
        * @author w
        * @date 2018年10月23日 下午2:45:35
        */
        public void init(Map<Integer, String> map){
            // 初始化map集合中元素的个数
            int count = 1000000;
            for (int i = 1; i <= count; i++) {
                map.put(i, i+ " ---> map");
            }
        }
    
        @Test
        public void test(){
            Map<Integer, String> map = new HashMap<>();
            Map<Integer, String> map2 = new HashMap<>();
            long start = System.currentTimeMillis();
            init(map);
            init(map2);
            System.out.println("装载map耗时: "+(System.currentTimeMillis()-start)+ " ms");
    
            start = System.currentTimeMillis();
            foreachKeyset(map);
            System.out.println("foreachKeyset 遍历 map耗时: "+(System.currentTimeMillis()-start)+ " ms");
        
            start = System.currentTimeMillis();
            foreachEntry(map2);
            System.out.println("foreachEntry 遍历 map耗时: "+(System.currentTimeMillis()-start)+ " ms");
    
            start = System.currentTimeMillis();
            iteratorEntry(map2);
            System.out.println("iteratorEntry 遍历 map耗时: "+(System.currentTimeMillis()-start)+ " ms");
            System.out.println(map.size());
        }
    
        /**
        * description: 根据 key 找 value
        * @param map
        * @version v1.0
        * @author w
        * @date 2018年10月23日 下午5:10:01
        */
        private void foreachKeyset(Map<Integer, String> map) {
            for(Integer key : map.keySet()){
                String value = map.get(key);
                // System.out.println("foreachKeyset : key :" + key + "---> value :"+ value);
            }
        }
    
        /**
        * description: 根据 key--value 键值对 找键和值 ( foreach 遍历)
        * @param map
        * @version v1.0
        * @author w
        * @date 2018年10月23日 下午5:19:31
        */
        private void foreachEntry(Map<Integer, String> map) {
            for(Entry<Integer, String> entry : map.entrySet()){
            // System.out.println("foreachEntry : key :" + entry.getKey() + "---> value :"+entry.getValue());
            }
        }
    
        /**
        * description: 根据 key--value 键值对 找键和值 ( iterator 遍历)
        * @param map
        * @version v1.0
        * @author w
        * @date 2018年10月23日 下午5:19:01
        */
        private void iteratorEntry(Map<Integer, String> map) {
            Iterator<Entry<Integer, String>> iterator = map.entrySet().iterator();
            while(iterator.hasNext()){
                Entry<Integer, String> entry = iterator.next();
                // System.out.println("iteratorEntry : key :" + entry.getKey() + "---> value :"+entry.getValue());
            }
        }
    
    }

     

    2、运行结果:

    装载map耗时: 2705 ms

    foreachKeyset 遍历 map耗时: 44 ms

    foreachEntry 遍历 map耗时: 22 ms

    iteratorEntry 遍历 map耗时: 17 ms

    1000000

     

    四、总结

    1、遍历 map 集合时,应该同时遍历出 键值对,这样效率更高。

    2、若遍历过程中,需要根据条件删除集合中元素,参考:https://blog.csdn.net/HaHa_Sir/article/details/80295755

     

     

     

    参考资料: https://blog.csdn.net/zhangsify/article/details/52966094#commentBox

     

     

     

     

    展开全文
  • 对于ios项目开发中总会遇见各种集合遍历,出于对各种遍历效率的好奇心,所以准备写个测试程序测试一下 首先:先声明一个NSMutableArray,测试数据量分别是1000条,10000条,100000条。 int testMaxCount =...
  • 测试for,foreach和Iterator遍历效率

    千次阅读 2016-04-22 21:14:48
    今天突然间想起来之前看过一篇博客,说起了for和foreach遍历效率的区别,于是验证一番,得到如下结论。 对于数组而言,for和foreach遍历效率相差不大。 对于List而言,foreach和Iterator遍历效率相差不大(在我的...
  • 按行遍历效率高 首先数组在内存中是按行存储的,按行遍历时可以从数组首元素地址一直走下去,就可以遍历完整个数组,而按列遍历则需要每次指向每一列的第n行元素; 但是指针寻址很快,所以并不会有明显的区别; ...
  • 对于遍历效率, arraylist和iterator都是根据下标获取元素,arraylist使用顺序链表存储数据,因此可以直接获取到元素,而iterator获取元素之前还需要校验等; arraylist使用for循环比使用iterator快 ...
  • 按行遍历效率高。 链接:https://blog.csdn.net/lbwo001/article/details/78817439
  • Java数组和链表三种遍历效率对比

    千次阅读 2019-01-20 12:11:21
    /*数组结构的三种循环遍历效率对比*/ @org.junit.Test public void test13(){ List&lt;Integer&gt; list = new ArrayList&lt;&gt;(10000000); for(int i=0;i&lt;1000;i++){ lis...
  • LinkedList遍历效率

    2017-08-08 15:38:22
    LinkedList通常使用的遍历方式有两种:for循环遍历,即调用get方法;还有就是迭代器循环。建议采用迭代器循环,这个网上有很多比较数据说明,下面简单通过源码看一下原因。本文代码jdk8。 1:for循环遍历时调用...
  • sqlite3树形结构遍历效率对比测试

    千次阅读 2016-03-25 16:09:06
    sqlite3树形结构遍历效率对比测试
  • js 遍历效率比较

    2019-11-29 09:55:50
    for(原始遍历方式) > for-of > forEach > filter > map > for-in
  • java foreach与for遍历效率对比

    千次阅读 2016-09-08 23:10:37
    由于本人在准备秋招,所以在看到foreach和for那个遍历效率更高的问题的时候,我百度了,又谷歌了,但是基本有的人说for更好,foreach更好,但是我无意中看到有人说如果是数组类型的迭代器的话,效率相差不大,如果硬...
  • ArrayList哪种遍历效率最好,你真的弄明白了吗?
  • Map遍历效率比较

    万次阅读 热门讨论 2016-10-30 10:56:27
     上次博客提到了Map的四种遍历方法,其中有的只是获取了key值或者是value值,但我们应该在什么时刻选择什么样的遍历方式呢,必须通过实践的比较才能看到效率。  也看了很多文章,大家建议使用entrySet,认为...
  • OpenCV像素点邻域遍历效率比较,以及访问像素点的几种方法
  • HashMap遍历效率问题

    2010-04-02 10:14:41
    HashMap遍历效率问题 对于HashMap中的Key和Value的遍历有两种方法: 1.通过HashMap.keySet()方法返回key的集合,通过遍历该集合的key得到相应的value值。 Map map = new HashMap(); Iterator iter = map....
  • 昨天敲代码时突然想到一个问题,列表的遍历和生成器的遍历效率哪个高,也就是for i in [0, 1, 2, 3, 4] 和for i in range(5)这两个表达式哪个效率高?话不多说,上代码 1 import time 2 i = 0 3 l1 = [] ...
  • Java 容器类及遍历效率对比

    千次阅读 2013-10-29 19:22:12
    Java 容器类及遍历效率对比 1)Collection Collection是最基本的集合接口,一个Collection代表一组Object,Java SDK不提供直接继承自Collection的类,Java SDK提供的类都是继承自Collection的“子接口”如List和...
  • Map 遍历效率比较

    千次阅读 2019-05-03 15:50:54
    准备测试数据 Map 中添加 1000000 条...遍历 Map 中的 key + value 1、通过 keySet 遍历整个 Map 1)采用 Iterator 进行遍历 long start = System.currentTimeMillis(); Iterator<String> iter = m...
  • Pandas 遍历效率、访问效率对比

    万次阅读 2019-07-22 18:14:48
    不同迭代方式: 1、使用普通的range循环: ...从上面四种访问数据方式来看,明显at方式访问效率最快,但是其主要是直接访问值,如果需要其他属性的话还有按情况而定,这里只讨论访问值的效率。    
  • opencv Mat::forEach 与 for 遍历效率的比较:for 更快 #include <opencv2/core.hpp> #include <opencv2/imgcodecs.hpp> #include <opencv2/highgui.hpp> #include <opencv2/features2d.hpp>...
  • 性能 之 【list遍历效率

    千次阅读 2019-06-25 14:09:54
    这里测试四种遍历方式: 最基础的size(),增强for循环,迭代和stream方式 ,测试5000万次...可以看出,最基础的size()遍历效率最高,其次增强for循环,然后是跌倒,最后是stream 。 测试代码 package perform...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 398,761
精华内容 159,504
关键字:

遍历效率