精华内容
下载资源
问答
  • Iterator<Map.Entry,String>> iter = Map.entrySet().iterator();
    2022-04-07 20:41:22

    map不有个Key和value吗 一个Key对应一个value 而key和value组合起来的一个组就是entry 要想取出这个组里的key和value就用entry的迭代器迭代即可。

    //获得map的迭代器,用作遍历map中的每一个键值对
    Iterator是迭代器,map之前应该定义过,姑且认为是HashMap。
    <Entry<String,String>>表示map中的键值对都是String类型的。
    map.entrySet()是把HashMap类型的数据转换成集合类型
    map.entrySet().iterator()是去获得这个集合的迭代器,保存在iter里面。。
    迭代器这么用:
    while(iter.hasNext()) {  // 判断下一个元素是否有后值
    Entry obj = it.next();//就能获得map中的每一个键值对了
    }

    //代码段
    
    import java.util.*;
     
    public class Test{
         public static void main(String[] args) {
          Map<String, String> map = new HashMap<String, String>();
          map.put("1", "value1");
          map.put("2", "value2");
          map.put("3", "value3");
          
          //第一种:普遍使用,二次取值
          System.out.println("通过Map.keySet遍历key和value:");
          for (String key : map.keySet()) {
           System.out.println("key= "+ key + " and value= " + map.get(key));
          }
          
          //第二种
          System.out.println("通过Map.entrySet使用iterator遍历key和value:");
          Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
          while (it.hasNext()) {
           Map.Entry<String, String> entry = it.next();
           System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
          }
          
          //第三种:推荐,尤其是容量大时
          System.out.println("通过Map.entrySet遍历key和value");
          for (Map.Entry<String, String> entry : map.entrySet()) {
           System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
          }
        
          //第四种
          System.out.println("通过Map.values()遍历所有的value,但不能遍历key");
          for (String v : map.values()) {
           System.out.println("value= " + v);
          }
         }
    }

    更多相关内容
  • Map.entrySet()方法返回的是一个Set<Map.Entry<K,V>>类型的值,首先该返回值是一个集合Set,集合中的元素是Map.Entry<K,V>类型的,每个Map.Entry可以看作是一个键值对对象,可以通过getKey()和...

    Map.entrySet()方法返回的是一个Set<Map.Entry<K,V>>类型的值,首先该返回值是一个集合Set,集合中的元素是Map.Entry<K,V>类型的,每个Map.Entry可以看作是一个键值对对象,可以通过getKey()和getValue()方法分别获取其键和值。

    Map.entrySet()方法主要用在对Map的键和值的遍历上,你可能会问了,既然已经有了更简便的方法去访问Map的键和值,为什么又要弄一个相对复杂的东西呢?答案就是速度更快,特别是在对大容量的Map进行键值对的遍历时。先看下面例子中的两种遍历方式。

    package ecnu.cn;
    
    import java.util.HashMap;
    import java.util.Map;
    
    public class MyTest {
    
        public static void main(String[] args) {
            Map<Integer, String> map = new HashMap<>();
            map.put(1, "value1");
            map.put(2, "value2");
            map.put(3, "value3");
            map.put(4, "value4");
            map.put(5, "value5");
    
            for (Integer key : map.keySet()) {
                System.out.println("key: " + key + "  value: " + map.get(key));
            }
            System.out.println();
    
            for(Map.Entry<Integer,String> entry:map.entrySet()){
                System.out.println("key: "+entry.getKey()+"  value: "+entry.getValue());
            }
        }
    }
    

    那为什么第一种常用的遍历方式会更慢呢?我的理解是:该种方式是先取出所有键的集合,然后拿着每个键再去Map中查找对应的值。而第二种方法是直接遍历每个键值对,直接用getKey()和getValue()方法分别获取其键和值即可。所以很明显第一种方式是多了一步的,也就更慢一些了。

    展开全文
  • Java Map Map中不能包含相同的键,每个键只能映射一个值。 HashMap:并不能保证它的元素的顺序,元素加入散列映射的顺序并不一定是它们被迭代方法读出的顺序。 Map.Entry Map.Entry 是Map中的一个接口,他的用途是...

    Java Map

    Map中不能包含相同的键,每个键只能映射一个值。

    HashMap:并不能保证它的元素的顺序,元素加入散列映射的顺序并不一定是它们被迭代方法读出的顺序。

    • Map.Entry

    Map.Entry 是Map中的一个接口,他的用途是表示一个映射项(里面有Key和Value)

    Map.Entry里有相应的getKey和getValue方法,即JavaBean,让我们能够从一个项中取出Key和Value。

    • Map.entrySet()

    Map.entrySet() 这个方法返回的是一个Set<Map.Entry<K,V>>。Set里面的类型是Map.Entry,里面存放的是键值对。一个K对应一个V。

    • Map.keyset()

    keySet是键的集合,Set里面的类型即key的类型。

    package Map.test;
    
    
    import java.util.*;
    
    public class Test {
    	public static void main(String args[]) {
    		// 创建HashMap 对象
    		HashMap hm = new HashMap();
    		// 加入元素到HashMap 中
    		hm.put("John Doe", new Double(3434.34));
    		hm.put("Tom Smith", new Double(123.22));
    		hm.put("Jane Baker", new Double(1378.00));
    		hm.put("Todd Hall", new Double(99.22));
    		hm.put("Ralph Smith", new Double(-19.08));
    		// 返回包含映射项的集合
    		Set set = hm.entrySet();
    		// 用Iterator 得到HashMap 中的内容
    		Iterator i = set.iterator();
    		// 显示元素
    		while (i.hasNext()) {
    			// Map.Entry 可以操作映射的输入
    			Map.Entry me = (Map.Entry) i.next();
    			System.out.print(me.getKey() + ": ");
    			System.out.println(me.getValue());
    		}
    		System.out.println();
    		// 让John Doe 中的值增加1000
    		double balance = ((Double) hm.get("John Doe")).doubleValue();//得到旧值
    		// 用新的值替换旧的值
    		hm.put("John Doe", new Double(balance + 1000));
    		System.out.println("John Doe's 现在的资金:" + hm.get("John Doe"));
    	}
    }
    /*
    Todd Hall: 99.22
    John Doe: 3434.34
    Ralph Smith: -19.08
    Tom Smith: 123.22
    Jane Baker: 1378.0
    
    John Doe's 现在的资金:4434.34
    */
    
    //四种遍历Map
    public static void main(String[] args) {
     
        Map<String, String> map = new HashMap<String, String>();
        map.put("1", "value1");
        map.put("2", "value2");
        map.put("3", "value3");
      
        //第一种:普遍使用,二次取值
        System.out.println("通过Map.keySet遍历key和value:");
        for (String key : map.keySet()) {
            System.out.println("key= "+ key + " and value= " + map.get(key));
        }
      
        //第二种
        System.out.println("通过Map.entrySet使用iterator遍历key和value:");
        Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry<String, String> entry = it.next();
            System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
        }
      
        //第三种:推荐,尤其是容量大时
        System.out.println("通过Map.entrySet遍历key和value");
        for (Map.Entry<String, String> entry : map.entrySet()) {
            System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
        }
     
        //第四种
        System.out.println("通过Map.values()遍历所有的value,但不能遍历key");
        for (String v : map.values()) {
            System.out.println("value= " + v);
        }
     }
    
    展开全文
  • Map.entrySet() 实现原理

    2019-07-11 16:56:41
    Map.entrySet() 这个方法返回的是一个Set<Map.Entry<K,V>>,Map.Entry 是Map中的一个接口,他的用途是表示一个映射项(里面有Key和Value),而Set<Map.Entry<K,V>>表示一个映射项的Set。Map...

     Map.entrySet() 这个方法返回的是一个Set<Map.Entry<K,V>>,Map.Entry 是Map中的一个接口,他的用途是表示一个映射项(里面有Key和Value),而Set<Map.Entry<K,V>>表示一个映射项的Set。Map.Entry里有相应的getKey和getValue方法,即JavaBean,让我们能够从一个项中取出Key和Value。

    下面是遍历Map的四种方法:

    public static void main(String[] args) {
     
     
      Map<String, String> map = new HashMap<String, String>();
      map.put("1", "value1");
      map.put("2", "value2");
      map.put("3", "value3");
      
      //第一种:普遍使用,二次取值
      System.out.println("通过Map.keySet遍历key和value:");
      for (String key : map.keySet()) {
       System.out.println("key= "+ key + " and value= " + map.get(key));
      }
      
      //第二种
      System.out.println("通过Map.entrySet使用iterator遍历key和value:");
      Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
      while (it.hasNext()) {
       Map.Entry<String, String> entry = it.next();
       System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
      }
      
      //第三种:推荐,尤其是容量大时
      System.out.println("通过Map.entrySet遍历key和value");
      for (Map.Entry<String, String> entry : map.entrySet()) {
       System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
      }
     
      //第四种
      System.out.println("通过Map.values()遍历所有的value,但不能遍历key");
      for (String v : map.values()) {
       System.out.println("value= " + v);
      }
     }

    下面是HashMap的源代码:
    首先HashMap的底层实现用的时候一个Entry数组
     

    <pre name="code" class="java">
    
        /** 
         * The table, resized as necessary. Length MUST Always be a power of two. 
         */  
        transient Entry[] table; //声明了一个数组  
       ........  
       public HashMap() {  
            this.loadFactor = DEFAULT_LOAD_FACTOR;  
            threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);  
            table = new Entry[DEFAULT_INITIAL_CAPACITY];//初始化数组的大小为DEFAULT_INITIAL_CAPACITY(这里是16)  
            init();  
        }</pre><br>  

    再来看一下Entry是在什么地方定义的,继续上源码,我们在HashMap的源码的674行发现了它的定义,原来他是HashMap的一个内部类,并且实现了Map.Entry接口,以下有些地方是转载

    static class Entry<K,V> implements Map.Entry<K,V> {  
        final K key;  
        V value;  
        Entry<K,V> next;  
        final int hash;  
      
        /** 
         * Creates new entry. 
         */  
        Entry(int h, K k, V v, Entry<K,V> n) {  
            value = v;  
            next = n;  
            key = k;  
            hash = h;  
        }  
      
        public final K getKey() {  
            return key;  
        }  
      
        public final V getValue() {  
            return value;  
        }  
      
        public final V setValue(V newValue) {  
     V oldValue = value;  
            value = newValue;  
            return oldValue;  
        }  
      
        public final boolean equals(Object o) {  
            if (!(o instanceof Map.Entry))  
                return false;  
            Map.Entry e = (Map.Entry)o;  
            Object k1 = getKey();  
            Object k2 = e.getKey();  
            if (k1 == k2 || (k1 != null && k1.equals(k2))) {  
                Object v1 = getValue();  
                Object v2 = e.getValue();  
                if (v1 == v2 || (v1 != null && v1.equals(v2)))  
                    return true;  
            }  
            return false;  
        }  
      
        public final int hashCode() {  
            return (key==null   ? 0 : key.hashCode()) ^  
                   (value==null ? 0 : value.hashCode());  
        }  
      
        public final String toString() {  
            return getKey() + "=" + getValue();  
        }  
      
        /** 
         * This method is invoked whenever the value in an entry is 
         * overwritten by an invocation of put(k,v) for a key k that's already 
         * in the HashMap. 
         */  
        void recordAccess(HashMap<K,V> m) {  
        }  
      
        /** 
         * This method is invoked whenever the entry is 
         * removed from the table. 
         */  
        void recordRemoval(HashMap<K,V> m) {  
        }  
    }  


    既然这样那我们再看一下Map.Entry这个接口是怎么定义的,原来他是Map的一个内部接口并且定义了一些方法

     

     interface Entry<K,V> {  
        /** 
     * Returns the key corresponding to this entry. 
     * 
     * @return the key corresponding to this entry 
            * @throws IllegalStateException implementations may, but are not 
            *         required to, throw this exception if the entry has been 
            *         removed from the backing map. 
     */  
    K getKey();  
      
        /** 
     * Returns the value corresponding to this entry.  If the mapping 
     * has been removed from the backing map (by the iterator's 
     * <tt>remove</tt> operation), the results of this call are undefined. 
     * 
     * @return the value corresponding to this entry 
            * @throws IllegalStateException implementations may, but are not 
            *         required to, throw this exception if the entry has been 
            *         removed from the backing map. 
     */  
    V getValue();  
      
        /** 
     * Replaces the value corresponding to this entry with the specified 
     * value (optional operation).  (Writes through to the map.)  The 
     * behavior of this call is undefined if the mapping has already been 
     * removed from the map (by the iterator's <tt>remove</tt> operation). 
     * 
            * @param value new value to be stored in this entry 
            * @return old value corresponding to the entry 
            * @throws UnsupportedOperationException if the <tt>put</tt> operation 
            *         is not supported by the backing map 
            * @throws ClassCastException if the class of the specified value 
            *         prevents it from being stored in the backing map 
            * @throws NullPointerException if the backing map does not permit 
            *         null values, and the specified value is null 
            * @throws IllegalArgumentException if some property of this value 
            *         prevents it from being stored in the backing map 
            * @throws IllegalStateException implementations may, but are not 
            *         required to, throw this exception if the entry has been 
            *         removed from the backing map. 
            */  
    V setValue(V value);  
      
    /** 
     * Compares the specified object with this entry for equality. 
     * Returns <tt>true</tt> if the given object is also a map entry and 
     * the two entries represent the same mapping.  More formally, two 
     * entries <tt>e1</tt> and <tt>e2</tt> represent the same mapping 
     * if<pre> 
            *     (e1.getKey()==null ? 
            *      e2.getKey()==null : e1.getKey().equals(e2.getKey()))  && 
            *     (e1.getValue()==null ? 
            *      e2.getValue()==null : e1.getValue().equals(e2.getValue())) 
            * </pre> 
     * This ensures that the <tt>equals</tt> method works properly across 
     * different implementations of the <tt>Map.Entry</tt> interface. 
     * 
     * @param o object to be compared for equality with this map entry 
     * @return <tt>true</tt> if the specified object is equal to this map 
     *         entry 
            */  
    boolean equals(Object o);  
      
    /** 
     * Returns the hash code value for this map entry.  The hash code 
     * of a map entry <tt>e</tt> is defined to be: <pre> 
     *     (e.getKey()==null   ? 0 : e.getKey().hashCode()) ^ 
     *     (e.getValue()==null ? 0 : e.getValue().hashCode()) 
            * </pre> 
     * This ensures that <tt>e1.equals(e2)</tt> implies that 
     * <tt>e1.hashCode()==e2.hashCode()</tt> for any two Entries 
     * <tt>e1</tt> and <tt>e2</tt>, as required by the general 
     * contract of <tt>Object.hashCode</tt>. 
     * 
     * @return the hash code value for this map entry 
     * @see Object#hashCode() 
     * @see Object#equals(Object) 
     * @see #equals(Object) 
     */  
    int hashCode();  
       }  

         看到这里的时候大伙儿估计都明白得差不多了为什么HashMap为什么要选择Entry数组来存放key-value对了吧,因为Entry实现的Map.Entry接口里面定义了getKey(),getValue(),setKey(),setValue()等方法相当于一个javaBean,对键值对进行了一个封装便于后面的操作,从这里我们其实也可以联想到不光是HashMap,譬如LinkedHashMap,TreeMap 等继承自map的容器存储key-value对都应该使用的是Entry只不过组织Entry的形式不一样,HashMap用的是数组加链表的形式,LinkedHashMap用的是链表的形式,TreeMap应该使用的二叉树的形式,不信的话上源码


    LinkedHashMap:

       /** 
        * The head of the doubly linked list. 
        * 定义了链头  
        */
       private transient Entry<K,V> header;  

    初始化链表的方法:

    void init() {  
        header = new Entry<K,V>(-1, null, null, null);  
        header.before = header.after = header;  
    }  


    TreeMap:

    //定义根节点  
     private transient Entry<K,V> root = null;  


    再看他的put方法,是不是很面熟(二叉排序树的插入操作)

    public V put(K key, V value) {  
        Entry<K,V> t = root;  
        if (t == null) {  
     // TBD:  
     // 5045147: (coll) Adding null to an empty TreeSet should  
     // throw NullPointerException  
     //  
     // compare(key, key); // type check  
            root = new Entry<K,V>(key, value, null);  
            size = 1;  
            modCount++;  
            return null;  
        }  
        int cmp;  
        Entry<K,V> parent;  
        // split comparator and comparable paths  
        Comparator<? super K> cpr = comparator;  
        if (cpr != null) {  
            do {  
                parent = t;  
                cmp = cpr.compare(key, t.key);  
                if (cmp < 0)  
                    t = t.left;  
                else if (cmp > 0)  
                    t = t.right;  
                else  
                    return t.setValue(value);  
            } while (t != null);  
        }  
        else {  
            if (key == null)  
                throw new NullPointerException();  
            Comparable<? super K> k = (Comparable<? super K>) key;  
            do {  
                parent = t;  
                cmp = k.compareTo(t.key);  
                if (cmp < 0)  
                    t = t.left;  
                else if (cmp > 0)  
                    t = t.right;  
                else  
                    return t.setValue(value);  
            } while (t != null);  
        }  
        Entry<K,V> e = new Entry<K,V>(key, value, parent);  
        if (cmp < 0)  
            parent.left = e;  
        else  
            parent.right = e;  
        fixAfterInsertion(e);  
        size++;  
        modCount++;  
        return null;  
    }  

    ok,明白了各种Map的底层存储key-value对的方式后,再来看看如何遍历map吧,这里用HashMap来演示吧
     Map提供了一些常用方法,如keySet()、entrySet()等方法,keySet()方法返回值是Map中key值的集合;entrySet()的返回值也是返回一个Set集合,此集合的类型为Map.Entry。

    so,很容易写出如下的遍历代码

    1.  Map map = new HashMap();  
      
             Irerator iterator = map.entrySet().iterator();  
      
             while(iterator.hasNext()) {  
      
                     Map.Entry entry = iterator.next();  
      
                     Object key = entry.getKey();  
      
                     //  
      
             }  
      
         2.Map map = new HashMap();   
      
             Set  keySet= map.keySet();  
      
             Irerator iterator = keySet.iterator;  
      
             while(iterator.hasNext()) {  
      
                     Object key = iterator.next();  
      
                     Object value = map.get(key);  
      
                     //  
      
             }  


    另外,还有一种遍历方法是,单纯的遍历value值,Map有一个values方法,返回的是value的Collection集合。通过遍历collection也可以遍历value,如
     

    Map map = new HashMap();  
      
    Collection c = map.values();  
      
    Iterator iterator = c.iterator();  
      
    while(iterator.hasNext()) {  
      
           Object value = iterator.next();   
    }

    展开全文
  • //获得map的迭代器,用作遍历map中的每一个键值对...map.entrySet()是把HashMap类型的数据转换成集合类型map.entrySet().iterator()是去获得这个集合的迭代器,保存在iter里面。。迭代器这么用:while(iter.hasNext(...
  • Map.Entry<String, String>的意思是一个泛型,表示Entry里装的是两个... Map.entrySet()是将map里的每一个键值对取出来封装成一个Entry对象在存到一个Set里面。Map提供了一 些常用方法,如keySet()、en...
  • 对于Map中提供的一些常用方法,如map.keySet()、map.entrySet()、map.values()等方法。 map.keySet()方法返回值是Map中key值的集合; Map<String, String> map = new HashMap<String, String>(); ma...
  • List&lt;Map.Entry&lt;String, Object&...(map.entrySet()); map里面有一个内部接口,用于返回类似于 [key1=value1, key2=value2] 其中【分隔符为 逗号加空格 】【前后均有中括号】...
  • Map.entrySet是直接一次性获取map的所有键值对,可以通过getKey和getValue来获取健和值。 Map.keySet获取map的健,获取值需要再一次使用map.get()方法来获取对应的值。 所以可以看出,Map.entrySetMap.keySet少...
  • 代码: Map<String,String> map = new HashMap<>(); ... set:map.entrySet()){ System.out.println(set);//{张三=1212,王五=js} System.out.println(set.getKey()+set.getValue())
  • map.entrySet().iterator();是什么意思

    千次阅读 2019-04-25 09:09:09
    Iterator<Entry<String,String>... iter=map.entrySet().iterator();是什么意思 //获得map的迭代器,用作遍历map中的每一个键值对 Iterator是迭代器,map之前应该定义过,姑且认为是HashMap。 &...
  • Map 转为 List<Map.entey>,便于前端json处理。 即,从 {"id2":"ddd","id1":"lxf"} 到 ...Map.entrySet().toArray() @RequestMapping("/testListMap") public Object testListMap(){ ...
  • map.entrySet().iterator()

    千次阅读 2019-06-03 11:58:11
    map.entrySet().iterator()是去获得这个集合的迭代器,保存在iter里面。 迭代器这么用: while(iter.hasNext()) { Entry obj = it.next();//就能获得map中的每一个键值对了 } Iterator<String> iter; // ...
  • 在LeetCode刷题的时候,在一道返回 字符串中最早出现的只出现一次的字符下标的题目中,使用大HashMap的遍历方式,我选择了使用map.entrySet()获取节点集合的方式进行遍历。 题目和代码如下: 在一个字符串(0<=...
  • 源网址: http://blog.csdn.net/mageshuai/article/details/3523116 今天看Think in java 的GUI这一章的时候,里面的TextArea这个例子在遍历Map时用到了Map.Entry 和 Map....于是到API中一看,Map.entrySet()...
  • package ... import java.util.ArrayList; import java.util.HashMap; /** * 用lamdba 一次性遍历 list<map> * * @author wangxl * @date 2019-09-20 */ public class T { /** ...
  • Map.EntrySet的用法

    2017-06-10 11:10:12
    [java] view plain copy 1.package edu.smc.test;  2.  3.import java.util.HashMap;  4.import java.util.Iterator;...5.import java.util.Map;...6.import java.util.Map.Entry; 
  • 今天看Think injava 的GUI这一章的时候,里面的TextArea这个例子在遍历Map时用到了Map.Entry 和 Map.entrySet(),记得只见过Map.KeySet()和values()这两个方法,于是到API中一看,Map.entrySet()这个方法返回的是一...
  • 对于Map中提供的一些常用方法,如map.keySet()、map.entrySet()、map.values()等方法大多数人都不是很熟悉。map.keySet()方法返回值是Map中key值的集合;map.entrySet()的返回值是一个Set集合,此集合的类型为Map....
  • listArrayList《Map.Entry《Integer,Integer》》 entryList = new ArrayList《》(map.entrySet());这样写是将map转list吗?直接转了?不用遍历吗?
  • package com.day15.Map; import java.util....import java.util.Map; public class MapFive {  public static void main(String[] args) {  Map<String, Integer> ma=new HashMap<>();  ...
  • 你是否已经对每次从Map中取得关键字然后再取得相应的值感觉厌倦?使用Map.Entry类,你可以得到在同一时间得到所有的信息。标准的Map访问方法如下: Set keys = map.keySet( ); if(keys != null) { Iterator ...
  • Map.Entryset获取每个元素的Key,value

    千次阅读 2017-04-10 16:17:58
    1.package edu.smc.test;  2.  3.import java.util.HashMap;  4.import java.util.Iterator;...5.import java.util.Map;  6.import java.util.Map.Entry;  7.  8.public class TestEntrySe
  • System.out.println("通过Map.entrySet遍历key和value"); for(Map.Entry<String,String>entry:map.entrySet()){ System.out.println("key="+entry.getKey()+"andvalue="+entry.getValue()); } ...
  • Map.Entry 你是否已经对每次从Map中取得关键字然后再取得相应的值感觉厌倦?使用Map.Entry类,你可以得到在同一时间得到所有的信息。标准的Map访问方法如下: Set keys = map.keySet(); If(keys !=null){ for...
  • Java的Map中的map.keySet()方法

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 159,020
精华内容 63,608
关键字:

map.entryset