• 44、Map

    一、基本介绍：

    1、Map接口实现类的特点［很实用］

    注意：这里讲的是JDK8的Map接口特点

    1）Map与Collection并列存在。用于保存具有映射关系的数据：Key-Value

    2）Map 中的 key和value 可以是任何引用类型的数据，会封装到HashMap＄Node 对象中

    3） Map 中的 key 不允许重复，原因和HashSet 一样，如果有重复的，后面的key的value会把前面的相同的key的value替换掉

    4） Map 中的 value 可以重复

    5） Map 的key 可以为 null，value 也可以为null ，注意 key 为null， 只能有一个， value 为null，可以多个.

    6）常用String类作为Map的 key，即key不一定得是String

    7）key和value之间存在单向一对一关系，即通过指定的 key 总能找到对应的 value，使用get()方法

    1. package Collection_;
    2.  
    3. import java.util.HashMap;
    4. import java.util.Map;
    5.  
    6. @SuppressWarnings({"all"})
    7. public class Map_ {
    8.     public static void main(String[] args) {
    9.         Map map=new HashMap();
    10.         map.put("no1","韩顺平");
    11.         map.put("no2","张无忌");
    12.  
    13.         map.put("no1","张三丰");//当有相同的k，就等价于替换
    14.         map.put("no3","张三丰");
    15.  
    16.         map.put(null,null);
    17.         map.put(null,"abc");//替换上面的null
    18.  
    19.         map.put("no4",null);
    20.         map.put("no5",null);
    21.  
    22.         map.put(1,"赵敏");
    23.         map.put(new Object(),"金毛狮王");
    24.  
    25.         //通过get()方法，传入key，会返回对应的value
    26.         System.out.println(map.get("no2"));
    27.         System.out.println("map="+map);
    28.     }
    29. }
    30. //张无忌
    31. //map={no2=张无忌, null=abc, no1=张三丰, 1=赵敏, no4=null, no3=张三丰, no5=null, java.lang.Object@7ef20235=金毛狮王}
    32. //输出的顺序与hash值有关，所以是无序的

    2、Map接口的特点：（看源码）

    （1）Map存放数据，一对k-v是放在一个HashMap$Node中的，有因为Node实现了Entry接口，有些书上也说，一对k-v就是一个Entry

    3、Map接口的常用方法

     

     4、Map接口的遍历方法：

    二、HashMap 

    1. package Collection_;
    2.  
    3. import java.util.*;
    4.  
    5. @SuppressWarnings({"all"})
    6. public class MapFor {
    7.     public static void main(String[] args) {
    8.         Map map=new HashMap();
    9.         map.put("邓超","孙俪");
    10.         map.put("王宝强","马蓉");
    11.         map.put("宋喆","马蓉");
    12.         map.put("刘令博",null);
    13.         map.put(null,"刘亦菲");
    14.         map.put("鹿晗","关晓彤");
    15.  
    16.         //第一组：先取出所有的Key，通过Key取出对应的Value
    17.         Set keyset=map.keySet();
    18.         //（1）增强for
    19.         System.out.println("------------1.1增强for----------");
    20.         for (Object key :keyset) {
    21.             System.out.println(key+"-"+map.get(key));
    22.         }
    23.         //（2）迭代器
    24.         System.out.println("------------1.2迭代器----------");
    25.         Iterator iterator=keyset.iterator();
    26.         while (iterator.hasNext()) {
    27.             Object key =  iterator.next();
    28.             System.out.println(key+"-"+map.get(key));
    29.         }
    30.  
    31.         //第二组：把所有的values取出
    32.         Collection values=map.values();
    33.         //这里可以使用所有的Collections使用的遍历方法
    34.         //（1）增强for
    35.         System.out.println("------------2.1增强for----------");
    36.         for (Object value :values) {
    37.             System.out.println(value);
    38.         }
    39.         //（2）迭代器
    40.         System.out.println("------------2.2迭代器----------");
    41.         Iterator iterator1=values.iterator();
    42.         while (iterator1.hasNext()) {
    43.             Object value =  iterator1.next();
    44.             System.out.println(value);
    45.         }
    46.  
    47.         //第三组：EntrySet
    48.         Set entrySet=map.entrySet();
    49.         System.out.println("------------3.1增强for----------");
    50.         for (Object entry :entrySet) {
    51.             Map.Entry m=(Map.Entry)entry;//将entry向下转型成Map.Entry
    52.             System.out.println(m.getKey()+"-"+m.getValue());
    53.         }
    54.         System.out.println("------------3.2迭代器----------");
    55.         Iterator iterator2=entrySet.iterator();
    56.         while (iterator2.hasNext()) {
    57.             Object entry =  iterator2.next();
    58.             //System.out.println(next.getClass());//HashMap$Node-->实现-->Map.Entry(getKey,getValue);
    59.             Map.Entry m=(Map.Entry) entry;//向下转型成Map.Entry
    60.             System.out.println(m.getKey()+"-"+m.getValue());
    61.         }
    62.     }
    63. }
    64. //------------1.1增强for----------
    65. //邓超-孙俪
    66. //宋喆-马蓉
    67. //刘令博-null
    68. //null-刘亦菲
    69. //王宝强-马蓉
    70. //鹿晗-关晓彤
    71. //------------1.2迭代器----------
    72. //邓超-孙俪
    73. //宋喆-马蓉
    74. //刘令博-null
    75. //null-刘亦菲
    76. //王宝强-马蓉
    77. //鹿晗-关晓彤
    78. //------------2.1增强for----------
    79. //孙俪
    80. //马蓉
    81. //null
    82. //刘亦菲
    83. //马蓉
    84. //关晓彤
    85. //------------2.2迭代器----------
    86. //孙俪
    87. //马蓉
    88. //null
    89. //刘亦菲
    90. //马蓉
    91. //关晓彤
    92. //------------3.1增强for----------
    93. //邓超-孙俪
    94. //宋喆-马蓉
    95. //刘令博-null
    96. //null-刘亦菲
    97. //王宝强-马蓉
    98. //鹿晗-关晓彤
    99. //------------3.2迭代器----------
    100. //邓超-孙俪
    101. //宋喆-马蓉
    102. //刘令博-null
    103. //null-刘亦菲
    104. //王宝强-马蓉
    105. //鹿晗-关晓彤

    1、练习题：

     //我的代码：

    1. package Collection_;
    2.  
    3. import java.util.*;
    4.  
    5. @SuppressWarnings({"all"})
    6. public class MapExercise {
    7.     public static void main(String[] args) {
    8.         Map map=new HashMap();
    9.         map.put(1234,new Employee("jack",10000,"1234"));
    10.         map.put(1235,new Employee("tom",20000,"1235"));
    11.         map.put(1236,new Employee("smith",30000,"1236"));
    12.         System.out.println("========第一种遍历方式========");
    13.         Set keyset=map.keySet();
    14.         System.out.println("========增强for循环========");
    15.         for (Object key :keyset) {
    16.             Employee employee=(Employee) map.get(key);
    17.             if(employee.getSal()>18000) {
    18.                 System.out.println(employee);
    19.             }
    20.         }
    21.         System.out.println("========迭代器========");
    22.         Iterator iterator=keyset.iterator();
    23.         while (iterator.hasNext()) {
    24.             Object key =  iterator.next();
    25.             Employee employee=(Employee) map.get(key);
    26.             if(employee.getSal()>18000) {
    27.                 System.out.println(employee);
    28.             }
    29.         }
    30.         System.out.println("========第二种遍历方式========");
    31.         Set entrySet=map.entrySet();
    32.         System.out.println("========增强for循环========");
    33.         for (Object entry :entrySet) {
    34.             Map.Entry m=(Map.Entry) entry;
    35.             Employee employee=(Employee) m.getValue();
    36.             if(employee.getSal()>18000) {
    37.                 System.out.println(employee);
    38.             }
    39.         }
    40.         System.out.println("========迭代器========");
    41.         Iterator iterator1=entrySet.iterator();
    42.         while (iterator1.hasNext()) {
    43.             Object entry =  iterator1.next();
    44.             Map.Entry m=(Map.Entry) entry;
    45.             Employee employee=(Employee) m.getValue();
    46.             if(employee.getSal()>18000) {
    47.                 System.out.println(employee);
    48.             }
    49.         }
    50.  
    51.     }
    52. }
    53. class Employee{
    54.     private String name;
    55.     private double sal;
    56.     private String id;
    57.  
    58.     public Employee(String name, double sal, String id) {
    59.         this.name = name;
    60.         this.sal = sal;
    61.         this.id = id;
    62.     }
    63.  
    64.     public String getName() {
    65.         return name;
    66.     }
    67.  
    68.     public void setName(String name) {
    69.         this.name = name;
    70.     }
    71.  
    72.     public double getSal() {
    73.         return sal;
    74.     }
    75.  
    76.     public void setSal(double sal) {
    77.         this.sal = sal;
    78.     }
    79.  
    80.     public String getId() {
    81.         return id;
    82.     }
    83.  
    84.     public void setId(String id) {
    85.         this.id = id;
    86.     }
    87.  
    88.     @Override
    89.     public String toString() {
    90.         return "Employee{" +
    91.                 "name='" + name + '\'' +
    92.                 ", sal=" + sal +
    93.                 ", id='" + id + '\'' +
    94.                 '}';
    95.     }
    96. }
    97. //========第一种遍历方式========
    98. //========增强for循环========
    99. //Employee{name='tom', sal=20000.0, id='1235'}
    100. //Employee{name='smith', sal=30000.0, id='1236'}
    101. //========迭代器========
    102. //Employee{name='tom', sal=20000.0, id='1235'}
    103. //Employee{name='smith', sal=30000.0, id='1236'}
    104. //========第二种遍历方式========
    105. //========增强for循环========
    106. //Employee{name='tom', sal=20000.0, id='1235'}
    107. //Employee{name='smith', sal=30000.0, id='1236'}
    108. //========迭代器========
    109. //Employee{name='tom', sal=20000.0, id='1235'}
    110. //Employee{name='smith', sal=30000.0, id='1236'}

    2、HashMap小结：

    1）Map接口的常用实现类：HashMap、Hashtable和Properties。

    2）HashMap是Map 接口使用频率最高的实现类。

    3）HashMap 是以 key-val 对的方式来存储数据（HashMap$Node类型）

    4） key 不能重复，但是是值可以重复，允许使用null键和null值。

    5）如果添加相同的key，则会覆盖原来的key—val，等同于修改．（key不会替换，val会替换）

    6）与HashSet一样，不保证映射的顺序，因为底层是以hash表的方式来存储的．

    7）HashMap没有实现同步，因此是线程不安全的，方法没有做同步互斥的操作，没有synchronized 

    3、HashMap底层机制及源码剖析：

      （1）扩容机制[和HashSet相同]
    1）HashMap底层维护了Node类型的数组table，默认为null
    2）当创建对象时，将加载因子（loadfactor）初始化为0.75.
    3）当添加key-val时，通过key的哈希值得到在table的索引。然后判断该索引处是否有元素，如果没有元素直接添加。如果该索引处有元素，继续判断元素的key是否和准备加入的key相等，如果相等，则直接替换val；如果不相等需要判断是树结构还是链表结构，做出相应处理。如果添加时发现容量不够，则需要扩容
    4）第1次添加，则需要扩容table容量为16，临界值（threshold）为12（16*0.75）
    5）以后再扩容，则需要扩容table容量为原来的2倍，临界值为原来的2倍，即24，依次类推

    6）在Java8中，如果一条链表的元素个数超过TREEIFYTHRESHOLD（默认是8），并且table的大小>=MINTREEIFYCAPACITY（默认64），就会进行树化（红黑树）

    1. //解读源码：
    2. package Collection_;
    3.  
    4. import java.util.Comparator;
    5. import java.util.TreeMap;
    6. @SuppressWarnings({"all"})
    7. public class TreeMap_ {
    8.     public static void main(String[] args) {
    9. //        TreeMap treeMap=new TreeMap();
    10. //        treeMap.put("dddjack","杰克");
    11. //        treeMap.put("aaatom","汤姆");
    12. //        treeMap.put("ccckristina","克瑞斯提诺");
    13. //        treeMap.put("bbbsmith","史密斯");
    14. //
    15. //        System.out.println("treemap="+treeMap);
    16.           //输出：treemap={aaatom=汤姆, bbbsmith=史密斯, ccckristina=克瑞斯提诺, dddjack=杰克}
    17.           //使用默认构造器，则是按首字母前后排序
    18.  
    19.         TreeMap treeMap=new TreeMap(new Comparator() {
    20.             @Override
    21.             public int compare(Object o1, Object o2) {
    22.                 //按照传入的k(String)的大小进行排序
    23.                 return ((String)o1).compareTo((String)o2);//从小到大
    24.  
    25.                 //return ((String)o2).compareTo((String)o1);
    26.                 //从大到小
    27.                 //输出：treemap={dddjack=杰克, ccckristina=克瑞斯提诺, bbbsmith=史密斯, aaatom=汤姆}
    28.  
    29.                 //return ((String)o1).length()-((String)o2).length();
    30.                 //按照传入的k(String)的长度大小进行排序
    31.                 //输出：treemap={aaatom=汤姆, dddjack=杰克, bbbsmith=史密斯, ccckristina=克瑞斯提诺}
    32.                 //注意：如果要添加的key的长度和已有的某个key的长度一样，那这个key就添加不进去，
    33.                 //cmp = cpr.compare(key, t.key);
    34.     //                else {
    35.     //                    V oldValue = t.value;
    36.     //                    if (replaceOld || oldValue == null) {
    37.     //                        t.value = value;
    38.     //                    }
    39.     //                    return oldValue;
    40.     //                }
    41.                 //但是它的值会替换已有的那个key的值
    42.             }
    43.         });
    44.         treeMap.put("dddjack","杰克");
    45.         treeMap.put("aaatom","汤姆");
    46.         treeMap.put("ccckristina","克瑞斯提诺");
    47.         treeMap.put("bbbsmith","史密斯");
    48.         System.out.println("treemap="+treeMap);
    49.         //输出：treemap={aaatom=汤姆, bbbsmith=史密斯, ccckristina=克瑞斯提诺, dddjack=杰克}
    50.         //跟使用默认情况时一样，说明默认情况下的底层机制即为这个
    51.     }
    52. }
    53. /*
    54. 源码剖析：
    55.     //1、构造器，把传入的实现了Comparator接口的匿名内部（对象），传给TreeMap的comparator
    56.     public TreeMap(Comparator comparator) {
    57.         this.comparator = comparator;
    58.     }
    59.     //2、调用put方法
    60.     //2.1 第一次添加，把k-v封装到Entry对象，放入root
    61.     Entry t = root;
    62.         if (t == null) {
    63.             addEntryToEmptyMap(key, value);
    64.             return null;
    65.         }
    66.     //2.2
    67.     Comparator cpr = comparator;
    68.         if (cpr != null) {
    69.             do {//遍历所有的key，给当前的key找到适当的位置，
    70.                 parent = t;
    71.                 cmp = cpr.compare(key, t.key);//动态绑定到我们的匿名内部类的compare()方法
    72.                 if (cmp < 0)
    73.                     t = t.left;
    74.                 else if (cmp > 0)
    75.                     t = t.right;
    76.                 else {//如果遍历过程中，发现准备添加的key和当前已有的key相等，就不添加了
    77.                     V oldValue = t.value;
    78.                     if (replaceOld || oldValue == null) {
    79.                         t.value = value;
    80.                     }
    81.                     return oldValue;
    82.                 }
    83.             } while (t != null);
    84.         }
    85.  */

  • 相关阅读:
    猿创征文｜Cglib代理之代理类方法的动态传递
    Python正则表达式(一看就懂)
    基于ssm+Vue音乐播放器管理系统java源码
    零代码—无代码到底有什么影响，谁会胜出？
    Kafka复习计划 - 客户端实践及原理（消费者组/位移/请求处理过程）
    django rest framework 学习笔记-实战商城3
    Java中常见包装类型Integer、BigDecimal等特点说明
    Ubuntu自启动设置
    如何使用 Spring Data JPA 在存储过程中使用 IN、OUT 和 INOUT 参数
    《论文阅读》R-Drop:Regularized Dropout for Neural Network
  • 原文地址：https://blog.csdn.net/weixin_72052233/article/details/128035632