Map双列集合，Map接口常用方法，Map六大遍历，HashMap

1. Map接口实现类的特点
   1. Map与Collection并列存在，用于保存具有映射关系的数据：Key-Value
   2. Map中的key和value可以是任何引用类型的数据，会封装到HashMap$Node对象中。
   3. Map中的key不允许重复【把原先的value替换了】，原因和HashSet一样
   4. Map中的Value可以重复
   5. Map的key可以为null，value也可以为null，注意key为null，只能有一个【key不可以重复】，value为null，可以多个
   6. 常用String类作为Map的key，其实key是Object类型，任何类型都可以当做key
   7. key和value之间存在单向一对一关系，即通过指定的key总能找到对应的value
   8. Map存放数据一对k-v是放在Node中的，因为Node实现了Entry接口【底层原码不理解】
2. Map接口常用方法

   1. package com.jshedu.map_;
      
      import java.util.HashMap;
      import java.util.Map;
      
      /**
       * @author 韩顺平
       * @version 1.0
       */
      @SuppressWarnings({"all"})
      public class MapMethod {
          public static void main(String[] args) {
              //演示map接口常用方法
      
              Map map = new HashMap();
              map.put("邓超", new Book("", 100));//OK
              map.put("邓超", "孙俪");//替换-> 一会分析源码
              map.put("王宝强", "马蓉");//OK
              map.put("宋喆", "马蓉");//OK
              map.put("刘令博", null);//OK
              map.put(null, "刘亦菲");//OK
              map.put("鹿晗", "关晓彤");//OK
              map.put("hsp", "hsp的老婆");
      
              System.out.println("map=" + map);
              //map={邓超=孙俪, 宋喆=马蓉, 刘令博=null, null=刘亦菲, hsp=hsp的老婆, 王宝强=马蓉, 鹿晗=关晓彤}
      
      //        remove:根据键删除映射关系
              map.remove(null);
              System.out.println("map=" + map);
              //map={邓超=孙俪, 宋喆=马蓉, 刘令博=null, hsp=hsp的老婆, 王宝强=马蓉, 鹿晗=关晓彤}
      //        get：根据键获取值
              Object val = map.get("鹿晗");
              System.out.println("val=" + val);
              //val=关晓彤
      //        size:获取元素个数
              System.out.println("k-v=" + map.size());//k-v=6
      //        isEmpty:判断个数是否为0
              System.out.println(map.isEmpty());//F
      //        clear:清除k-v
              //map.clear();
              System.out.println("map=" + map);
      //        containsKey:查找键是否存在
              System.out.println("结果=" + map.containsKey("hsp"));//T
              //结果=true
      
          }
      }
      
      class Book {
          private String name;
          private int num;
      
          public Book(String name, int num) {
              this.name = name;
              this.num = num;
          }
      }
      

      get提供key参数，返回value

3. Map六大遍历

   1. containsKey:查找键是否存在

   2. keySet:获取所有键

   3. entrySet：获取所有关系k-v

   4. values：获取所有的值

   5. package com.hspedu.map_;
      
      import java.util.*;
      
      /**
       * @author 韩顺平
       * @version 1.0
       */
      @SuppressWarnings({"all"})
      public class MapFor {
          public static void main(String[] args) {
      
              Map map = new HashMap();
              map.put("邓超", "孙俪");
              map.put("王宝强", "马蓉");
              map.put("宋喆", "马蓉");
              map.put("刘令博", null);
              map.put(null, "刘亦菲");
              map.put("鹿晗", "关晓彤");
      
              //第一组: 先取出 所有的Key , 通过Key 取出对应的Value
              Set keyset = map.keySet();
              //编译类型为什么是Set，因为keySet()返回一个Set集合
              //Set又有迭代器，增强for，for三种遍历方式
              //(1) 增强for
              System.out.println("-----第一种方式-------");
              for (Object key : keyset) {
                  System.out.println(key + "-" + map.get(key));
              }
              //(2) 迭代器
              System.out.println("----第二种方式--------");
              Iterator iterator = keyset.iterator();
              while (iterator.hasNext()) {
                  Object key =  iterator.next();
                  System.out.println(key + "-" + map.get(key));
              }
      
              //第二组: 把所有的values取出
              Collection values = map.values();
              //这为什么用Collection编译类型，因为value值里面有重复的，Set里不能有重复的
              //这里可以使用所有的Collections使用的遍历方法
              //(1) 增强for
              System.out.println("---取出所有的value 增强for----");
              for (Object value : values) {
                  System.out.println(value);
              }
              //(2) 迭代器
              System.out.println("---取出所有的value 迭代器----");
              Iterator iterator2 = values.iterator();
              while (iterator2.hasNext()) {
                  Object value =  iterator2.next();
                  System.out.println(value);
      
              }
      
              //第三组: 通过EntrySet 来获取 k-v
              Set entrySet = map.entrySet();// EntrySet>
              //(1) 增强for
              System.out.println("----使用EntrySet 的 for增强(第3种)----");
              for (Object entry : entrySet) {
                  //将entry 转成 Map.Entry
                  Map.Entry m = (Map.Entry) entry;
                  System.out.println(m.getKey() + "-" + m.getValue());
              }
              //(2) 迭代器
              System.out.println("----使用EntrySet 的 迭代器(第4种)----");
              Iterator iterator3 = entrySet.iterator();
              while (iterator3.hasNext()) {
                  Object entry =  iterator3.next();
                  //System.out.println(next.getClass());//HashMap$Node -实现-> Map.Entry (getKey,getValue)
                  //向下转型 Map.Entry
                  Map.Entry m = (Map.Entry) entry;
                  System.out.println(m.getKey() + "-" + m.getValue());
              }
      
      
          }
      }
      

4. 例题

   package com.hspedu.map_;
   
   import java.util.HashMap;
   import java.util.Iterator;
   import java.util.Map;
   import java.util.Set;
   
   /**
    * @author 韩顺平
    * @version 1.0
    */
   @SuppressWarnings({"all"})
   public class MapExercise {
       public static void main(String[] args) {
           //完成代码
           Map hashMap = new HashMap();
           //添加对象
           hashMap.put(1, new Emp("jack", 300000, 1));
           hashMap.put(2, new Emp("tom", 21000, 2));
           hashMap.put(3, new Emp("milan", 12000, 3));
   
   
           //遍历2种方式
           //并遍历显示工资>18000的员工(遍历方式最少两种)
           //1. 使用keySet  -> 增强for
           Set keySet = hashMap.keySet();
           System.out.println("====第一种遍历方式====");
           for (Object key : keySet) {
               //先获取value
               Emp emp = (Emp) hashMap.get(key);
               if(emp.getSal() >18000) {
                   System.out.println(emp);
               }
           }
   
           //2. 使用EntrySet -> 迭代器
           //   体现比较难的知识点
           //   慢慢品，越品越有味道.
           Set entrySet = hashMap.entrySet();
           System.out.println("======迭代器======");
           Iterator iterator = entrySet.iterator();
           while (iterator.hasNext()) {
               Map.Entry entry =  (Map.Entry)iterator.next();
               //通过entry 取得key 和 value
               Emp emp = (Emp) entry.getValue();
               if(emp.getSal() > 18000) {
                   System.out.println(emp);
               }
           }
   
       }
   }
   /**
    * 使用HashMap添加3个员工对象，要求
    * 键：员工id
    * 值：员工对象
    *
    * 并遍历显示工资>18000的员工(遍历方式最少两种)
    * 员工类：姓名、工资、员工id
    */
   class Emp {
       private String name;
       private double sal;
       private int id;
   
       public Emp(String name, double sal, int id) {
           this.name = name;
           this.sal = sal;
           this.id = id;
       }
   
       public String getName() {
           return name;
       }
   
       public void setName(String name) {
           this.name = name;
       }
   
       public double getSal() {
           return sal;
       }
   
       public void setSal(double sal) {
           this.sal = sal;
       }
   
       public int getId() {
           return id;
       }
   
       public void setId(int id) {
           this.id = id;
       }
   
       @Override
       public String toString() {
           return "Emp{" +
                   "name='" + name + '\'' +
                   ", sal=" + sal +
                   ", id=" + id +
                   '}';
       }
   }
   

   使用EntrySet