entryset和keyset的区别

entrySet和keySet的小小区别
千次阅读

2017-10-12 10:32:13

Java中的Map遍历

推荐使用entrySet遍历Map类集合KV，而不是keySet方式进行遍历。

说明：keySet其实是遍历了2次，一次是转为Iterator对象，另一次是从hashMap中取出key所对应的value。

而entrySet只是遍历了一次就把key和value都放到了entry中，效率更高。如果是JDK8，使用Map.foreach方法。

Map java 遍历

更多相关内容
高效编程之HashMap的entryset和keyset比较
千次阅读 2017-04-11 14:32:21
最近看了一点spring的源码，甚是苦涩；对spring稍微有了点整体的认识，但对很多细节的地方还是懵逼啊。。。太多不懂了的，只能慢慢去读，先把简单的不懂的解决；...再往下面走的，这个entryset方法我不
最近看了一点spring的源码，甚是苦涩；对spring稍微有了点整体的认识，但对很多细节的地方还是懵逼啊。。。太多不懂了的，只能慢慢去读，先把简单的不懂的解决；

比如beanfactory通过扫描器拿到了注解标记的那些类，都是放到一个hashmap中，然后文件名就是key，文件就是value；首先都会有一个 "map".entryset的操作；再往下面走的，这个entryset方法我不太明白是啥意思，看了1.6的API，告诉我返回一个set视图，这样的翻译感觉略水...直接告诉我返回set集合不就好了么...

废话不多说，进入正题；

hashmap里存的是entry对象，一个entry对象由key,value组成；

我们会把数据放到value,如果想拿的话可以通过key去取，也可以直接从entry对象里去拿；

所以如果我们拿到了一个有"东西"的hashmap的时候，我们可以有两种方式拿到里面的value；

一种是keyset()，一种是entryset()，但是这两个方法哪个效率更高，使你的代码更棒呢？

看jvm给我们的答案；

上代码！
```
public class HashMapTest { 
	public static void main(String[] args) { 
		HashMap<Integer,String> hashmap = new HashMap<Integer,String>(); 
		for (int i = 0; i < 10000000; i++ ){ 
				hashmap.put(i, "glsx"); 
		} 

		long bs = Calendar.getInstance().getTimeInMillis(); 
		Iterator iterator = hashmap.keySet().iterator();   
		while (iterator.hasNext()) {    
			hashmap.get(iterator.next()); 
		} 
			System.out.print("keyset:"); 
			System.out.println(Calendar.getInstance().getTimeInMillis() - bs); 
			listHashMap(); 
} 
	 public static void listHashMap(){ 
		 HashMap<Integer,String> hashmap = new HashMap<Integer,String>();
		  for (int i = 0; i < 10000000; i++ ) { 
		   hashmap.put(i, "glsx"); 
		  } 
		  long bs = Calendar.getInstance().getTimeInMillis();   
		  Iterator it = hashmap.entrySet().iterator(); 
		  while (it.hasNext()) { 
		  Map.Entry entry = (Map.Entry) it.next(); 
		  entry.getValue(); 
		  } 
		  System.out.print("entryset:"); 
		  System.out.println(Calendar.getInstance().getTimeInMillis() - bs); 
		} 	
}
```
输入结果：
```
keyset:168
entryset:76
```
多测试几次的输入结果：
```
keyset:171
entryset:70
=======
keyset:169
entryset:81
=======
keyset:175
entryset:74
```
结果很明显，entryset速度比keyset快了两倍多点；
hashmap.entryset，在set集合中存放的是entry对象。而在hashmap中的key 和 value 是存放在entry对象里面的；然后用迭代器，遍历set集合，就可以拿到每一个entry对象；得到entry对象就可以直接从entry拿到value了；
而hashmap.keyset只是把hashmap中key放到一个set集合中去，还是通过迭代器去遍历，然后再通过 hashmap.get(key)方法拿到value；

差别在哪里呢？源码给我们答案了。
```
public V get(Object key) {
        if (key == null)
            return getForNullKey();
        Entry<K,V> entry = getEntry(key);

        return null == entry ? null : entry.getValue();
    }
```
entry.getvalue可以直接拿到value,hashmap.get(key)是先得到Entry对象，再通过entry.getvalue去拿，直白点说就是hashmap.get(key)走了一个弯路，所以它慢一些；

所以我们以后遍历hashmap想要拿value的时候能记得多用entryset()哈~
收起
展开全文
hashmap

HashMap使用EntrySet与KeySet的区别(快慢比较)，你测试方法对了么？

千次阅读 2021-01-13 17:12:30

最近在csdn搜索了关于EntrySet与KeySet的效率问题，发现很多说entrySet快，但是都是好几年前的，而且... * 测试Map的keySet和entrySet的性能 * * @author yangbiao * @date 2021/1/13 15:31 */ public class Test {

最近在csdn搜索了关于EntrySet与KeySet的效率问题，发现很多说entrySet快，但是都是好几年前的，而且看他给的源码跟我点开jdk的源码不一致应该是jdk版本不同，另外也有说自己测试结果发现keySet快的，那么到底如何呢？还是得自己验证一下。

我用的是jdk1.8测试的，代码如下

/**
 * 测试Map的keySet和entrySet的性能
 *
 * @author yangbiao
 * @date 2021/1/13 15:31
 */
public class Test {
    HashMap<String,String> map;

    @BeforeEach
    void setUp() {
        map = new HashMap<>();
        for(int i = 0; i <= 1000000; i++){
            map.put("key-" + i, "value-" + i);
        }
    }

    @org.junit.jupiter.api.Test
    void testKeySet() {

        StringBuilder sb = new StringBuilder();
        long startTime = System.currentTimeMillis();
        for( String s : map.keySet()){
            sb.append(s).append(map.get(s));
        }
        long kTime = System.currentTimeMillis() - startTime;

        System.out.println("字符串长度:"+sb.length());

        System.out.println("keySet花费: " + kTime);
    }

    @org.junit.jupiter.api.Test
    void testEntrySet() {
        StringBuilder sb = new StringBuilder();
        long startTime = System.currentTimeMillis();
        for( Map.Entry<String, String> e : map.entrySet()){
            //将map的key和value进行拼接
            sb.append(e.getKey()).append(e.getValue());
        }
        long eTime = System.currentTimeMillis() - startTime;

        System.out.println("字符串长度:"+sb.length());

        System.out.println("entrySet花费: " + eTime);
    }

    @org.junit.jupiter.api.Test
    void testTogether() {
        System.out.println("先测试keySet再测试entrySet");
        testKeySet();
        testEntrySet();
    }

    @org.junit.jupiter.api.Test
    void testTogetherAgain() {
        System.out.println("先测试entrySet再测试keySet");
        testEntrySet();
        testKeySet();
    }

    @org.junit.jupiter.api.Test
    void testTogetherBy2Thread() throws InterruptedException {
        //创建两个线程分别测试
        Thread thread1 = new Thread(this::testKeySet);
        Thread thread2 = new Thread(this::testEntrySet);
        thread1.start();
        thread2.start();
        Thread.sleep(4000);
    }

    @org.junit.jupiter.api.Test
    void testTogetherBy2ThreadAgain() throws InterruptedException {
        //创建两个线程分别测试
        Thread thread1 = new Thread(this::testEntrySet);
        Thread thread2 = new Thread(this::testKeySet);
        thread1.start();
        thread2.start();
        Thread.sleep(4000);
    }
}

定义一个HashMap，每个测试方法都初始化一次，有6个测试方法，分别是测试keySet，entrySet，keySet+entrySet，entrySet+keySet，keySet+entrySet两个线程执行，entrySet+keySet两个线程执行。

为什么要这样写测试方法，因为我发现网上给的很多测试是在同一个方法里进行测试的，我就交换了下顺序，发现结果竟然是后面的总是慢于前面的。这或许是java编译器优化了？我也不清楚。单个方法进行测试结果会有误差不好判断，所以方法1和2的结果都没有参考性可言。

运行方法3和4即testTogether()跟testTogetherAgain()是截然相反的结果。
在这里插入图片描述

运行方法5和6即testTogetherBy2Thread()跟testTogetherBy2ThreadAgain()，用两个线程不同加入顺序执行测试。
在这里插入图片描述

表明entrySet略快于keySet，再增加一倍的数据，测试如下

证明entrySet快于keySet。

收起

展开全文

java hashmap