精华内容
下载资源
问答
  • Java map

    万次阅读 2017-12-04 19:30:11
    Java8增强的Map集合Map接口中定义了如下常用的方法。 void clear():删除该Map对象中的所有key-value对。 boolean containsKey(Object key):查询Map中是否包含指定的key,如果包含则返回true。 boolean contains...

    Java8增强的Map集合

    Map接口中定义了如下常用的方法。

    void clear():删除该Map对象中的所有key-value对。
    boolean containsKey(Object key):查询Map中是否包含指定的key,如果包含则返回true。
    boolean containsValue(Object value):查询Map中是否包含一个或多个value,如果包含则返回true。
    Set entrySet():返回map中包含的key-value对所组成的Set集合,每个集合元素都是map.Entry对象
    Object get(Object key):返回指定key所对应的value;如果此map中不包含该key,则返回null。
    boolean isEmpty():查询该map是否为空,如果为空,则返回true。
    Set keySet():返回该map中所有key组成的set集合
    Object put(Object key,Object value):添加一个key-value对,如果当前map中已有一个与该key相等的key-value对,则新的key-value对会覆盖原来的key-value对。
    void putAll(Map m):将指定map中的key-value对复制到本map中
    Object remove(Object key):删除指定key所对应的key-value对,返回被删除key所关联的value,如果该key不存在,则返回null。
    boolean remove(Object key,Object value):这是java8新增的方法,删除指定key,value所对应的key-value对,如果从该map中成功地删除该key-value对,该方法返回true,否则返回false。
    int size():返回该map里的key-value对的个数。
    collection values():返回该map里所有value组成的collection。
    Map中包括了一个内部类Entry,该类封装了一个key-value对。Entry包含如下三个方法。
    Object getKey():返回该Entry里包含的key值
    Object getValue():返回该Entry里包含的value值。
    Object setValue(V value):设置该Entry里包含的value值,并返回新设置的value值。

    下面程序示范了map的基本功能

    import java.util.*;
    public class MapTest
    {
        public static void main(String[] args)
        {
            Map map = new HashMap();
            // 成对放入多个key-value对
            map.put("疯狂Java讲义" , 109);
            map.put("疯狂iOS讲义" , 10);
            map.put("疯狂Ajax讲义" , 79);
            // 多次放入的key-value对中value可以重复
            map.put("轻量级Java EE企业应用实战" , 99);
            // 放入重复的key时,新的value会覆盖原有的value
            // 如果新的value覆盖了原有的value,该方法返回被覆盖的value
            System.out.println(map.put("疯狂iOS讲义" , 99)); // 输出10
            System.out.println(map); // 输出的Map集合包含4个key-value对
            // 判断是否包含指定key
            System.out.println("是否包含值为 疯狂iOS讲义 key:"
                + map.containsKey("疯狂iOS讲义")); // 输出true
            // 判断是否包含指定value
            System.out.println("是否包含值为 99 value:"
                + map.containsValue(99)); // 输出true
            // 获取Map集合的所有key组成的集合,通过遍历key来实现遍历所有key-value对
            for (Object key : map.keySet() )
            {
                // map.get(key)方法获取指定key对应的value
                System.out.println(key + "-->" + map.get(key));
            }
            map.remove("疯狂Ajax讲义"); // 根据key来删除key-value对。
            System.out.println(map); // 输出结果不再包含 疯狂Ajax讲义=79 的key-value对
        }
    }

    Java8 为Map新增的方法

    1) Object compute(Object key,BiFunction remappingFunction);
    2) Object computeIfAbsent(Object key,Function mappingFunction);
    3) Object computeIfPresent(Object key,BiFunction remappingFunction);
    4) void forEach(BiConsumer action);
    5) Object getOrDefault(Object key,V defaultValue);
    6) Object merge(Object key,Object value,Bifunction remappingFunction);
    7) Object putIfAbsent(Object key,Object value);
    8) Object replace(Object key,Object value);
    9) boolean replace(K key,V oldValue,V newValue);
    10) replaceAll(BiFunction function);

    public class MapTest2
    {
        public static void main(String[] args)
        {
            Map map = new HashMap();
            // 成对放入多个key-value对
            map.put("疯狂Java讲义" , 109);
            map.put("疯狂iOS讲义" , 99);
            map.put("疯狂Ajax讲义" , 79);
            // 尝试替换key为"疯狂XML讲义"的value,由于原Map中没有对应的key,
            // 因此对Map没有改变,不会添加新的key-value对
            map.replace("疯狂XML讲义" , 66);
            System.out.println(map);
            // 使用原value与参数计算出来的结果覆盖原有的value
            map.merge("疯狂iOS讲义" , 10 ,
                (oldVal , param) -> (Integer)oldVal + (Integer)param);
            System.out.println(map); // "疯狂iOS讲义"的value增大了10
            // 当key为"Java"对应的value为null(或不存在时),使用计算的结果作为新value
            map.computeIfAbsent("Java" , (key)->((String)key).length());
            System.out.println(map); // map中添加了 Java=4 这组key-value对
            // 当key为"Java"对应的value存在时,使用计算的结果作为新value
            map.computeIfPresent("Java",
                (key , value) -> (Integer)value * (Integer)value);
            System.out.println(map); // map中 Java=4 变成 Java=16
        }
    }

    Java 8改进的HashMap和Hashtable实现类

    HashMap和Hashtable存在两点典型区别
      1.Hashtable是一个线程安全的Map实现,但HashMap是线程不安全的实现,所以HashMap比Hashtable的性能高一点。
      2.Hashtable不允许使用null作为key和value,如果试图把null值放Hashtable中,将会引发NullPointerException异常;但HashMap可以使用null作为key或value。
      为了成功地在HashMap、Hashtable中存储、获取对象,用作key的对象必须实现hashCode()方法和equals()方法。

    LinkedHashMap实现类

    LinkedHashMap使用双向链表来维护key-value对的次序。

    public class LinkedHashMapTest
    {
        public static void main(String[] args)
        {
            LinkedHashMap scores = new LinkedHashMap();
            scores.put("语文" , 80);
            scores.put("英文" , 82);
            scores.put("数学" , 76);
            // 调用forEach方法遍历scores里的所有key-value对
            scores.forEach((key, value) -> System.out.println(key + "-->" + value));
        }
    }

    TreeMap

      TreeMap就是一个红黑树数据结构,每个key-value对即作为红黑树的一个节点。TreeMap也有两种排序方法。
       自然排序:TreeMap的所有key必须实现Comparable接口,而且所有的key应该是同一个类的对象,否则将会抛出ClassCastException异常。
       定制排序:创建TreeMap时,传入一个Comparator对象,该对象负责对TreeMap中的所有key进行排序。采用定制排序时,不要求Map的key实现Comparable接口。
       如果使用自定义类作为TreeMap的key,则重写该类的equals()方法和comparaTo()方法时应保持一致的返回结果。

    class R implements Comparable
    {
        int count;
        public R(int count)
        {
            this.count = count;
        }
        public String toString()
        {
            return "R[count:" + count + "]";
        }
        // 根据count来判断两个对象是否相等。
        public boolean equals(Object obj)
        {
            if (this == obj)
                return true;
            if (obj != null && obj.getClass() == R.class)
            {
                R r = (R)obj;
                return r.count == this.count;
            }
            return false;
        }
        // 根据count属性值来判断两个对象的大小。
        public int compareTo(Object obj)
        {
            R r = (R)obj;
            return count > r.count ? 1 :
                count < r.count ? -1 : 0;
        }
    }
    public class TreeMapTest
    {
        public static void main(String[] args)
        {
            TreeMap tm = new TreeMap();
            tm.put(new R(3) , "轻量级Java EE企业应用实战");
            tm.put(new R(-5) , "疯狂Java讲义");
            tm.put(new R(9) , "疯狂Android讲义");
            System.out.println(tm);
            // 返回该TreeMap的第一个Entry对象
            System.out.println(tm.firstEntry());
            // 返回该TreeMap的最后一个key值
            System.out.println(tm.lastKey());
            // 返回该TreeMap的比new R(2)大的最小key值。
            System.out.println(tm.higherKey(new R(2)));
            // 返回该TreeMap的比new R(2)小的最大的key-value对。
            System.out.println(tm.lowerEntry(new R(2)));
            // 返回该TreeMap的子TreeMap
            System.out.println(tm.subMap(new R(-1) , new R(4)));
        }
    }

    WeakHashMap和IdentityHashMap

       WeakHashMap与HashMap的用法基本相似,与HashMap的区别在于,HashMap的key保留了对实际对象的强引用,这意味着只要该HashMap对象不被销毁,该HashMap的所有key所引用的对象就不会被垃圾回收,HashMap也不会自动删除这些key所对应的key-value对;但WeakHashMap的key只保留了对实际对象的弱引用,这意味着如果WeakHashMap对象的key所引用的对象没有被其他强引用变量所引用,则这些key所引用的对象可能被垃圾回收,WeakHashMap也可能自动删除这些key所对应的key-value对。
       在IdentityHashMap中,当且仅当两个key严格相等(key1==key2)时,IdentityHashMap才认为两个key相等;对于普通的HashMap而言,只要key1和key2通过equals()方法比较返回true,且它们的hashCode值相等即可。

    展开全文
  • java map集合如何遍历效率高javaMap遍历的方式 一、前言 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

     

     

     

     

    展开全文
  • Java map集合深入学习

    万次阅读 多人点赞 2018-10-29 00:12:48
      概要: java.util 中的集合类包含 Java 中某些最常用的类。...本文主要介绍java map的初始化、用法、map的四种常用的遍历方式、map的排序以及常用api。 目录 1Map用法 类型介绍 类型区别 ...

     

     

    概要:

    java.util 中的集合类包含 Java 中某些最常用的类。最常用的集合类是 List 和 Map。

    Map 提供了一个更通用的元素存储方法。Map 集合类用于存储元素对(称作“键”和“值”),其中每个键映射到一个值。

    本文主要介绍java map的初始化、用法、map的四种常用的遍历方式、map的排序以及常用api。

    目录

    1Map用法

    类型介绍

    类型区别

    Map 初始化

    插入元素

    获取元素

    移除元素

    清空map

    2四种常用Map插入与读取性能比较

    测试环境

    测试结果

    测试代码

    3Map 遍历

    初始化数据

    增强for循环遍历

    迭代器遍历

    HashMap四种便利方式性能比较

    4Map 排序

    HashMap、Hashtable、LinkedHashMap排序

    TreeMap排序

    按value排序(通用)

    5常用API


    1Map用法

    类型介绍

    Java 自带了各种 Map 类。这些 Map 类可归为三种类型:

    1. 通用Map,用于在应用程序中管理映射,通常在 java.util 程序包中实现

    HashMap、Hashtable、Properties、LinkedHashMap、IdentityHashMap、TreeMap、WeakHashMap、ConcurrentHashMap

    2. 专用Map,通常我们不必亲自创建此类Map,而是通过某些其他类对其进行访问

    java.util.jar.Attributes、javax.print.attribute.standard.PrinterStateReasons、java.security.Provider、java.awt.RenderingHints、javax.swing.UIDefaults

    3. 一个用于帮助我们实现自己的Map类的抽象类

    AbstractMap

    类型区别

    HashMap

    最常用的Map,它根据键的HashCode 值存储数据,根据键可以直接获取它的值,具有很快的访问速度。HashMap最多只允许一条记录的键为Null(多条会覆盖);允许多条记录的值为 Null。非同步的。

    TreeMap

    能够把它保存的记录根据键(key)排序,默认是按升序排序,也可以指定排序的比较器,当用Iterator 遍历TreeMap时,得到的记录是排过序的。TreeMap不允许key的值为null。非同步的。 
    Hashtable

    与 HashMap类似,不同的是:key和value的值均不允许为null;它支持线程的同步,即任一时刻只有一个线程能写Hashtable,因此也导致了Hashtale在写入时会比较慢。 
    LinkedHashMap

    保存了记录的插入顺序,在用Iterator遍历LinkedHashMap时,先得到的记录肯定是先插入的.在遍历的时候会比HashMap慢。key和value均允许为空,非同步的。 

    Map 初始化

    Map<String, String> map = new HashMap<String, String>();

    插入元素

    map.put("key1", "value1");

    获取元素

    	map.get("key1")

    移除元素

    map.remove("key1");

    清空map

    map.clear();

    2四种常用Map插入与读取性能比较

    测试环境

    jdk1.7.0_80

    测试结果

      插入10次平均(ms) 读取10次平均(ms)
      1W 10W 100W 1W 10W 100W
    HashMap 56 261 3030 2 21 220
    LinkedHashMap 25 229 3069 2 20 216
    TreeMap 29 295 4117 5 103 1446
    Hashtable 24 234 3275 2 22 259

    测试代码

     

    public class Test {
    
        static int hashMapW = 0;
    
        static int hashMapR = 0;
    
        static int linkMapW = 0;
    
        static int linkMapR = 0;
    
        static int treeMapW = 0;
    
        static int treeMapR = 0;
    
        static int hashTableW = 0;
    
        static int hashTableR = 0;
    
    
    
        public static void main(String[] args) {
    
            for (int i = 0; i < 10; i++) {
    
                Test test = new Test();
    
                test.test(100 * 10000);
    
                System.out.println();
    
            }
    
    
    
            System.out.println("hashMapW = " + hashMapW / 10);
    
            System.out.println("hashMapR = " + hashMapR / 10);
    
            System.out.println("linkMapW = " + linkMapW / 10);
    
            System.out.println("linkMapR = " + linkMapR / 10);
    
            System.out.println("treeMapW = " + treeMapW / 10);
    
            System.out.println("treeMapR = " + treeMapR / 10);
    
            System.out.println("hashTableW = " + hashTableW / 10);
    
            System.out.println("hashTableR = " + hashTableR / 10);
    
        }
    
    
    
        public void test(int size) {
    
            int index;
    
            Random random = new Random();
    
            String[] key = new String[size];
    
    
    
            // HashMap 插入
    
            Map<String, String> map = new HashMap<String, String>();
    
            long start = System.currentTimeMillis();
    
            for (int i = 0; i < size; i++) {
    
                key[i] = UUID.randomUUID().toString();
    
                map.put(key[i], UUID.randomUUID().toString());
    
            }
    
            long end = System.currentTimeMillis();
    
            hashMapW += (end - start);
    
            System.out.println("HashMap插入耗时 = " + (end - start) + " ms");
    
    
    
            // HashMap 读取
    
            start = System.currentTimeMillis();
    
            for (int i = 0; i < size; i++) {
    
                index = random.nextInt(size);
    
                map.get(key[index]);
    
            }
    
            end = System.currentTimeMillis();
    
            hashMapR += (end - start);
    
            System.out.println("HashMap读取耗时 = " + (end - start) + " ms");
    
    
    
            // LinkedHashMap 插入
    
            map = new LinkedHashMap<String, String>();
    
            start = System.currentTimeMillis();
    
            for (int i = 0; i < size; i++) {
    
                key[i] = UUID.randomUUID().toString();
    
                map.put(key[i], UUID.randomUUID().toString());
    
            }
    
            end = System.currentTimeMillis();
    
            linkMapW += (end - start);
    
            System.out.println("LinkedHashMap插入耗时 = " + (end - start) + " ms");
    
    
    
            // LinkedHashMap 读取
    
            start = System.currentTimeMillis();
    
            for (int i = 0; i < size; i++) {
    
                index = random.nextInt(size);
    
                map.get(key[index]);
    
            }
    
            end = System.currentTimeMillis();
    
            linkMapR += (end - start);
    
            System.out.println("LinkedHashMap读取耗时 = " + (end - start) + " ms");
    
    
    
            // TreeMap 插入
    
            key = new String[size];
    
            map = new TreeMap<String, String>();
    
            start = System.currentTimeMillis();
    
            for (int i = 0; i < size; i++) {
    
                key[i] = UUID.randomUUID().toString();
    
                map.put(key[i], UUID.randomUUID().toString());
    
            }
    
            end = System.currentTimeMillis();
    
            treeMapW += (end - start);
    
            System.out.println("TreeMap插入耗时 = " + (end - start) + " ms");
    
    
    
            // TreeMap 读取
    
            start = System.currentTimeMillis();
    
            for (int i = 0; i < size; i++) {
    
                index = random.nextInt(size);
    
                map.get(key[index]);
    
            }
    
            end = System.currentTimeMillis();
    
            treeMapR += (end - start);
    
            System.out.println("TreeMap读取耗时 = " + (end - start) + " ms");
    
    
    
            // Hashtable 插入
    
            key = new String[size];
    
            map = new Hashtable<String, String>();
    
            start = System.currentTimeMillis();
    
            for (int i = 0; i < size; i++) {
    
                key[i] = UUID.randomUUID().toString();
    
                map.put(key[i], UUID.randomUUID().toString());
    
            }
    
            end = System.currentTimeMillis();
    
            hashTableW += (end - start);
    
            System.out.println("Hashtable插入耗时 = " + (end - start) + " ms");
    
    
    
            // Hashtable 读取
    
            start = System.currentTimeMillis();
    
            for (int i = 0; i < size; i++) {
    
                index = random.nextInt(size);
    
                map.get(key[index]);
    
            }
    
            end = System.currentTimeMillis();
    
            hashTableR += (end - start);
    
            System.out.println("Hashtable读取耗时 = " + (end - start) + " ms");
    
        }
    
    }

    3Map 遍历

    初始化数据

     

    Map<String, String> map = new HashMap<String, String>();
    
    map.put("key1", "value1");
    
    map.put("key2", "value2");

    增强for循环遍历

    使用keySet()遍历

     

    for (String key : map.keySet()) {
    
        System.out.println(key + " :" + map.get(key));
    
    }

    使用entrySet()遍历

     

    for (Map.Entry<String, String> entry : map.entrySet()) {
    
        System.out.println(entry.getKey() + " :" + entry.getValue());
    
    }

    迭代器遍历

    使用keySet()遍历

     

    Iterator<String> iterator = map.keySet().iterator();
    
    while (iterator.hasNext()) {
    
        String key = iterator.next();
    
        System.out.println(key + " :" + map.get(key));
    
    }

    使用entrySet()遍历

    Iterator<Map.Entry<String, String>> iterator = map.entrySet().iterator();
    
    while (iterator.hasNext()) {
    
        Map.Entry<String, String> entry = iterator.next();
    
        System.out.println(entry.getKey() + " :" + entry.getValue());
    
    }

    HashMap四种便利方式性能比较

    比较方式

    分别对四种遍历方式进行10W次迭代,比较用时。

    代码

    package net.xsoftlab.baike;
    
    import java.util.HashMap;
    
    import java.util.Iterator;
    
    import java.util.Map;
    import java.util.Map.Entry;
    
    public class TestMap {
    
        public static void main(String[] args) {
    
            // 初始化,10W次赋值
    
            Map<Integer, Integer> map = new HashMap<Integer, Integer>();
    
            for (int i = 0; i < 100000; i++)
    
                map.put(i, i);
    
            /** 增强for循环,keySet迭代 */
    
            long start = System.currentTimeMillis();
    
            for (Integer key : map.keySet()) {
    
                map.get(key);
    
            }
    
            long end = System.currentTimeMillis();
    
            System.out.println("增强for循环,keySet迭代 -> " + (end - start) + " ms");
    
            /** 增强for循环,entrySet迭代 */
    
            start = System.currentTimeMillis();
    
            for (Entry<Integer, Integer> entry : map.entrySet()) {
    
                entry.getKey();
    
                entry.getValue();
    
            }
    
            end = System.currentTimeMillis();
    
            System.out.println("增强for循环,entrySet迭代 -> " + (end - start) + " ms");
    
            /** 迭代器,keySet迭代 */
    
            start = System.currentTimeMillis();
    
            Iterator<Integer> iterator = map.keySet().iterator();
    
            Integer key;
    
            while (iterator.hasNext()) {
    
                key = iterator.next();
    
                map.get(key);
    
            }
    
            end = System.currentTimeMillis();
    
            System.out.println("迭代器,keySet迭代 -> " + (end - start) + " ms");
    
            /** 迭代器,entrySet迭代 */
    
            start = System.currentTimeMillis();
    
            Iterator<Map.Entry<Integer, Integer>> iterator1 = map.entrySet().iterator();
    
            Map.Entry<Integer, Integer> entry;
    
            while (iterator1.hasNext()) {
    
                entry = iterator1.next();
    
                entry.getKey();
    
                entry.getValue();
    
            }
    
            end = System.currentTimeMillis();
    
            System.out.println("迭代器,entrySet迭代 -> " + (end - start) + " ms");
    
        }
    
    }

    运行三次,比较结果

    第一次

     

    增强for循环,keySet迭代 -> 37 ms
    
    增强for循环,entrySet迭代 -> 19 ms
    
    迭代器,keySet迭代 -> 14 ms
    
    迭代器,entrySet迭代 -> 9 ms

    第二次

     

    增强for循环,keySet迭代 -> 29 ms
    
    增强for循环,entrySet迭代 -> 22 ms
    
    迭代器,keySet迭代 -> 19 ms
    
    迭代器,entrySet迭代 -> 12 ms

    第三次

     

    增强for循环,keySet迭代 -> 27 ms
    
    增强for循环,entrySet迭代 -> 19 ms
    
    迭代器,keySet迭代 -> 18 ms
    
    迭代器,entrySet迭代 -> 10 ms

    平均值

     

    增强for循环,keySet迭代 -> 31 ms
    
    增强for循环,entrySet迭代 -> 20 ms
    
    迭代器,keySet迭代 -> 17 ms
    
    迭代器,entrySet迭代 -> 10.33 ms

    总结

    1. 增强for循环使用方便,但性能较差,不适合处理超大量级的数据。

    2. 迭代器的遍历速度要比增强for循环快很多,是增强for循环的2倍左右。

    3. 使用entrySet遍历的速度要比keySet快很多,是keySet的1.5倍左右。

    4Map 排序

    HashMap、Hashtable、LinkedHashMap排序

    注:

    TreeMap也可以使用此方法进行排序,但是更推荐下面的方法。

    Map<String, String> map = new HashMap<String, String>();
    
    map.put("a", "c");
    map.put("b", "b");
    map.put("c", "a");
    
    // 通过ArrayList构造函数把map.entrySet()转换成list
    
    List<Map.Entry<String, String>> list = new ArrayList<Map.Entry<String, String>>(map.entrySet());
    
    // 通过比较器实现比较排序
    
    Collections.sort(list, new Comparator<Map.Entry<String, String>>() {
    
        public int compare(Map.Entry<String, String> mapping1, Map.Entry<String, String> mapping2) {
    
            return mapping1.getKey().compareTo(mapping2.getKey());
    
        }
    
    });
    
    for (Map.Entry<String, String> mapping : list) {
    
        System.out.println(mapping.getKey() + " :" + mapping.getValue());
    
    }

    TreeMap排序

    TreeMap默认按key进行升序排序,如果想改变默认的顺序,可以使用比较器:

     

    Map<String, String> map = new TreeMap<String, String>(new Comparator<String>() {
    
        public int compare(String obj1, String obj2) {
    
            return obj2.compareTo(obj1);// 降序排序
    
        }
    });
    
    map.put("a", "c");
    
    map.put("b", "b");
    
    map.put("c", "a");
    
    for (String key : map.keySet()) {
    
        System.out.println(key + " :" + map.get(key));
    
    }

    按value排序(通用)

     

    Map<String, String> map = new TreeMap<String, String>();
    
            map.put("a", "c");
    
            map.put("b", "b");
    
            map.put("c", "a");
    
    
            // 通过ArrayList构造函数把map.entrySet()转换成list
    
            List<Map.Entry<String, String>> list = new ArrayList<Map.Entry<String, String>>(map.entrySet());
    
            // 通过比较器实现比较排序
    
            Collections.sort(list, new Comparator<Map.Entry<String, String>>() {
    
                public int compare(Map.Entry<String, String> mapping1, Map.Entry<String, String> mapping2) {
    
                    return mapping1.getValue().compareTo(mapping2.getValue());
    
                }
    
            });
    
    
            for (String key : map.keySet()) {
    
                System.out.println(key + " :" + map.get(key));
    
            }

    5常用API

     

    clear() 从 Map 中删除所有映射
    remove(Object key) 从 Map 中删除键和关联的值
    put(Object key, Object value) 将指定值与指定键相关联
    putAll(Map t) 将指定 Map 中的所有映射复制到此 map
    entrySet() 返回 Map 中所包含映射的 Set 视图。Set 中的每个元素都是一个 Map.Entry 对象,可以使用 getKey() 和 getValue() 方法(还有一个 setValue() 方法)访问后者的键元素和值元素
    keySet() 返回 Map 中所包含键的 Set 视图。删除 Set 中的元素还将删除 Map 中相应的映射(键和值)
    values() 返回 map 中所包含值的 Collection 视图。删除 Collection 中的元素还将删除 Map 中相应的映射(键和值)
    get(Object key) 返回与指定键关联的值
    containsKey(Object key) 如果 Map 包含指定键的映射,则返回 true
    containsValue(Object value) 如果此 Map 将一个或多个键映射到指定值,则返回 true
    isEmpty() 如果 Map 不包含键-值映射,则返回 true
    size() 返回 Map 中的键-值映射的数目

     转自:Java初级码农 

    出处https://www.cnblogs.com/lzq198754/p/5780165.html

     

    展开全文
  • Java Map按值排序的正确姿势

    万次阅读 2019-03-23 01:35:06
    在实际业务开发中,可能会遇到Java Map按值排序的需要。 Java Map按值排序的常见思路是: 1、 将map中的entry放到List中 2、 对List中的entry通过比较器按值排序 3 、将排序后的entry放到linkedhashmap中 ...

     

    在实际业务开发中,可能会遇到Java Map按值排序的需要。

    Java Map按值排序的常见思路是

    1、 将map中的entry放到List中

    2、 对List中的entry通过比较器按值排序

    3 、将排序后的entry放到linkedhashmap中

     

    Java 8利用Stream

    import java.util.Collections;
    import java.util.HashMap;
    import java.util.LinkedHashMap;
    import java.util.Map;
    
    import static java.util.Map.Entry.comparingByValue;
    import static java.util.stream.Collectors.toMap;
    
    public class SortTest {
    
        public static void main(String[] args) throws Exception {
    
            // 创建一个字符串为Key,数字为值的map
            Map<String, Integer> budget = new HashMap<>();
            budget.put("clothes", 120);
            budget.put("grocery", 150);
            budget.put("transportation", 100);
            budget.put("utility", 130);
            budget.put("rent", 1150);
            budget.put("miscellneous", 90);
            System.out.println("排序前: " + budget);
    
            // 按值排序 升序
            Map<String, Integer> sorted = budget
                    .entrySet()
                    .stream()
                    .sorted(comparingByValue())
                    .collect(
                            toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e2,
                                    LinkedHashMap::new));
    
            System.out.println("升序按值排序后的map: " + sorted);
    
            // 按值排序降序
            sorted = budget
                    .entrySet()
                    .stream()
                    .sorted(Collections.reverseOrder(comparingByValue()))
                    .collect(
                            toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e2,
                                    LinkedHashMap::new));
    
            System.out.println("降序按值排序后的map: " + sorted);
        }
    
    
    }
    

    可以封装成工具类

    /**
     * Map排序工具类
     *
     * @author liuwangyanghdu@163.com  明明如月
     */
    public class MapSortUtil {
        
        private static Comparator<Map.Entry> comparatorByKeyAsc = (Map.Entry o1, Map.Entry o2) -> {
            if (o1.getKey() instanceof Comparable) {
                return ((Comparable) o1.getKey()).compareTo(o2.getKey());
            }
            throw new UnsupportedOperationException("键的类型尚未实现Comparable接口");
        };
    
    
        private static Comparator<Map.Entry> comparatorByKeyDesc = (Map.Entry o1, Map.Entry o2) -> {
            if (o1.getKey() instanceof Comparable) {
                return ((Comparable) o2.getKey()).compareTo(o1.getKey());
            }
            throw new UnsupportedOperationException("键的类型尚未实现Comparable接口");
        };
    
    
        private static Comparator<Map.Entry> comparatorByValueAsc = (Map.Entry o1, Map.Entry o2) -> {
            if (o1.getValue() instanceof Comparable) {
                return ((Comparable) o1.getValue()).compareTo(o2.getValue());
            }
            throw new UnsupportedOperationException("值的类型尚未实现Comparable接口");
        };
    
    
        private static Comparator<Map.Entry> comparatorByValueDesc = (Map.Entry o1, Map.Entry o2) -> {
            if (o1.getValue() instanceof Comparable) {
                return ((Comparable) o2.getValue()).compareTo(o1.getValue());
            }
            throw new UnsupportedOperationException("值的类型尚未实现Comparable接口");
        };
    
        /**
         * 按键升序排列
         */
        public static <K, V> Map<K, V> sortByKeyAsc(Map<K, V> originMap) {
            if (originMap == null) {
                return null;
            }
            return sort(originMap, comparatorByKeyAsc);
        }
    
        /**
         * 按键降序排列
         */
        public static <K, V> Map<K, V> sortByKeyDesc(Map<K, V> originMap) {
            if (originMap == null) {
                return null;
            }
            return sort(originMap, comparatorByKeyDesc);
        }
    
    
        /**
         * 按值升序排列
         */
        public static <K, V> Map<K, V> sortByValueAsc(Map<K, V> originMap) {
            if (originMap == null) {
                return null;
            }
            return sort(originMap, comparatorByValueAsc);
        }
    
        /**
         * 按值降序排列
         */
        public static <K, V> Map<K, V> sortByValueDesc(Map<K, V> originMap) {
            if (originMap == null) {
                return null;
            }
            return sort(originMap, comparatorByValueDesc);
        }
    
        private static <K, V> Map<K, V> sort(Map<K, V> originMap, Comparator<Map.Entry> comparator) {
            return originMap.entrySet()
                    .stream()
                    .sorted(comparator)
                    .collect(
                            Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e2,
                                    LinkedHashMap::new));
        }
    
    }
    

    测试类

    package com.chujianyun.common.map;
    
    import org.junit.jupiter.api.BeforeAll;
    import org.junit.jupiter.api.Test;
    import org.junit.jupiter.api.TestInstance;
    
    import java.util.HashMap;
    import java.util.Map;
    
    
    /**
     * Map排序工具类
     *
     * @author liuwangyanghdu@163.com  明明如月
     */
    @TestInstance(TestInstance.Lifecycle.PER_CLASS)
    class MapSortUtilTest {
        // 创建一个字符串为Key,数字为值的map
        Map<String, Integer> budget = new HashMap<>();
    
        @BeforeAll
        public void init() {
            budget.put("clothes", 120);
            budget.put("grocery", 150);
            budget.put("transportation", 100);
            budget.put("utility", 130);
            budget.put("rent", 1150);
            budget.put("miscellneous", 90);
            System.out.println("排序前: " + budget);
        }
    
        @Test
        void sortByKeyAsc() {
            System.out.println("按键升序" + MapSortUtil.sortByKeyAsc(budget));
        }
    
        @Test
        void sortByKeyDesc() {
            System.out.println("按键降序" + MapSortUtil.sortByKeyDesc(budget));
        }
    
        @Test
        void sortByValueAsc() {
            System.out.println("按值升序" + MapSortUtil.sortByValueAsc(budget));
        }
    
        @Test
        void sortByValueDesc() {
            System.out.println("按值降序" + MapSortUtil.sortByValueDesc(budget));
        }
    }

     

    Java 7版本

    
    import java.util.*; 
    import java.lang.*; 
    
    public class GFG { 
    
    	//  hashmap按值排序
    	public static HashMap<String, Integer> sortByValue(HashMap<String, Integer> hm) 
    	{ 
    		// HashMap的entry放到List中
    		List<Map.Entry<String, Integer> > list = 
    			new LinkedList<Map.Entry<String, Integer> >(hm.entrySet()); 
    
    		//  对List按entry的value排序
    		Collections.sort(list, new Comparator<Map.Entry<String, Integer> >() { 
    			public int compare(Map.Entry<String, Integer> o1, 
    							Map.Entry<String, Integer> o2) 
    			{ 
    				return (o1.getValue()).compareTo(o2.getValue()); 
    			} 
    		}); 
    		
    		// 将排序后的元素放到LinkedHashMap中
    		HashMap<String, Integer> temp = new LinkedHashMap<String, Integer>(); 
    		for (Map.Entry<String, Integer> aa : list) { 
    			temp.put(aa.getKey(), aa.getValue()); 
    		} 
    		return temp; 
    	} 
    
    	
    	public static void main(String[] args) 
    	{ 
    
    		HashMap<String, Integer> hm = new HashMap<String, Integer>(); 
    
    		// 填充测试数据
    		hm.put("Math", 98); 
    		hm.put("Data Structure", 85); 
    		hm.put("Database", 91); 
    		hm.put("Java", 95); 
    		hm.put("Operating System", 79); 
    		hm.put("Networking", 80); 
    		Map<String, Integer> hm1 = sortByValue(hm); 
    
    		// 打印按值排序后的数据
    		for (Map.Entry<String, Integer> en : hm1.entrySet()) { 
    			System.out.println("Key = " + en.getKey() + 
    						", Value = " + en.getValue()); 
    		} 
    	} 
    } 
    

    参考文章:

    1、 Java 8 – Sorting HashMap by values in ascending and descending order

    2、 Sort a Map<Key, Value> by values

    3、Sorting a Hashmap according to values

     

    如果文章对你有帮助,欢迎点赞,关注,你的鼓励是我创作的最大动力!!

    展开全文
  • JAVA Map集合转String,String转Map集合 当前两个转换方法主要用作支付宝,微信支付额外参数转换 先看效果是不是诸君想要的 map转string的值 id=1&amp;amp;amp;amp;name=哆啦A梦丶幻想 string转...
  • Scala-scalaMap转JSON字符串和javaMap

    千次阅读 2019-03-27 14:50:05
    Scala-scalaMap转JSON字符串和javaMap
  • java map 添加数据

    2016-08-29 03:31:08
    java map 添加key 和 value, 动态添加key和value,key和value是分别每个数组中某一个值,key是a数组中的值a[i],而value是b数组中的一个值b[j], 他们这2个数组不再一个循环,而map的put需要放一个a[i],时,也要放...
  • Java Map的几种类型

    万次阅读 2017-09-04 10:04:24
    Java Map的几种类型
  • java Map集合嵌套,value为Map和value为List 2013年12月13日 23:13:34wuer0520阅读数:12476 import java.util.ArrayList; import java.util.HashMap; import java.util.Iterator; import ...
  • java map复制 浅拷贝 深拷贝

    千次阅读 2019-07-09 22:13:50
    java map深浅拷贝区分 参考链接:https://www.cnblogs.com/Marydon20170307/p/9132042.html java map深拷贝实现 参考链接:https://www.cnblogs.com/Marydon20170307/p/9131893.html 个人实现 最简单的方式就是定义...
  • Java Map put 方法别用于覆盖操作

    千次阅读 2019-04-20 16:21:10
    Java Map put 方法别用于覆盖操作
  • java Map接口定义和常用方法

    千次阅读 2018-11-07 22:36:37
    java Map接口定义和常用方法1.Map接口的定义2.Map常用方法 1.Map接口的定义 Map与Collection并列存在。用于保存具有映射关系的数据:Key-Value Map 中的 key 和 value 都可以是任何引用类型的数据 Map 中的 key...
  • JAVA map排序实现

    万次阅读 2019-06-03 14:19:14
    Map排序的方式有很多种,这里记录下自己总结的两种比较常用的方式:按键排序(sort by key), 按值排序(sort by value)。 1、按键排序 jdk内置的java.util包下的TreeMap<K,V>既可满足此类需求,向其构造...
  • Java Map的几种循环方式学习总结

    万次阅读 2016-02-16 17:29:04
    java Map的几种循环总结
  • java map求和

    千次阅读 2020-05-11 14:34:57
    for(Long value : map.values()){ sum= sum+value; } 先在将map转换为set 通过stream+lambda表达式转换为list ,使用lambda 表达式求和 System.out.println(endOffsetsSUm); //先在将map转换为set 通过stream+...
  • java map .put 方法

    千次阅读 2016-04-14 17:35:14
    java map .put 方法 put("1","111");再put一次: put("1","222");get("1") >>结果是222,求解释 111 呢?? 一个Map中不能包含相同的key,每个key只能映射一个value,你的“1”映射了两个value(“111”和"222"),...
  • java MapMap.Entry详解

    千次阅读 2018-07-15 20:33:55
    Mapjava中的接口,Map.Entry是Map的一个内部接口。Map提供了一些常用方法,如keySet()、entrySet()等方法。keySet()方法返回值是Map中key值的集合;entrySet()的返回值也是返回一个Set集合,此集合的类型为Map....
  • Java Map 按照值排序(按照value排序)

    万次阅读 多人点赞 2018-11-17 11:26:15
    需求:Java Map 按照值排序(按照value排序,本实例为倒叙排列) 方法:利用 java1.8 Stream 实现 返回接受的参数最好用LinkedHashMap,保证不会打乱排好之后的顺序。 public static &lt;K extends ...
  • Java Map foreach效率

    万次阅读 2010-09-06 20:13:00
    Java Map foreach效率通过比较源码和字节码,查看在Map 的entrySet在foreach中Java到底做了些什么。源码:public class ForEachTest { public void inForEach(int count) { Map map = new HashMap(); for ...
  • Java map转JSON

    千次阅读 2019-02-22 05:59:30
    map 转json数据并返给前端,前端可以用JSON.parse()序列化 ...import java.util.Map public class MapToJson { public static String toJson(boolean success,String key,Integer val){ Map<Strin...
  • Java map转scala map

    万次阅读 2017-01-03 21:07:58
    public static void main(String[] args) { Map, String> map = new HashMap,String>(){{put("1","2");}}; scala.collection.mutable.Map, String> mapTest = JavaConverters.mapAsScalaMapConverter(map).a
  • Java map集合的两种取出方式

    千次阅读 2016-04-22 15:59:08
    Java map集合的两种取出方式
  • Java Map集合遍历的三种方法

    千次阅读 2016-07-22 19:39:54
    java集合的一个很重要的操作—遍历,下面来看看Java map集合遍历的几种方法 预先创建一个Map Map, Student> map = new HashMap, Student>(); map.put("1001", "小张"); map.put("1002", "小明"); map.put("1003...
  • java Map根据value得到key值

    万次阅读 2014-01-08 10:19:22
    java Map根据value得到key值
  • Java Map values 方法

    千次阅读 2017-09-17 18:54:38
    package Map.Demo; import java.util.Collection; import java.util.HashMap; import java.util.Iterator;...import java.util.Map; import java.util.Set; public class MapDemo { public static void main(String
  • Java Map的常用Map实现类之:TreeMap1.TreeMap的特点2.自然排序3.定制排序 1.TreeMap的特点 TreeMap存储 Key-Value 对时,需要根据 key-value 对进行排序。 TreeMap 可以保证所有的 Key-Value 对处于有序状态。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 112,258
精华内容 44,903
关键字:

javamap

java 订阅