Java_Map_Map详解

1.Map概述

    Map<K,V>  Map集合类用于存储元素对（称作键和值），其中每个键映射到一个值,该接口描述了从不重复的键到值的映射。

2.Map子类

    1).HashTable,底层是哈希表数据结构，不可以存入null键和null值，线程同步，JDK1.0效率低；
    2).HashMap,底层是哈希表数据结构，可以存入null键和null值，不同步，JDK1.2效率高；
    3).TreeMap,底层是二叉树数据结构，线程不同步，可以用于Map键排序.

3.Map集合转为Set集合

    1).Set<K>keySet(),将所有的键存入Set集合，再使用迭代器获取value值
    2).Set<Map.Entry<K,V>>entrySet(), entrySet()方法返回一个实现Map.Entry接口的Set集合,集合中存放的是键/值对应关系，该关系是Map.Entry型。其中Entry是Map接口的内部接口。
        Map.Entry提供的方法:
            A)getKey(): 返回条目的关键字
            B)getValue(): 返回条目的值

4.Map常见操作

    1).添加操作：
        V put(K key, V value):如果key已存在，在关联后，返回替换前该key对应的value值,如果不存在，则返回null;
        void putAll(Map t):将来自特定映像的所有元素添加给该映像.
    2).删除操作：
        V remove(Object key):从此映射中移除指定键的映射关系（如果存在），不存在则返回null;
        void clear() :从此映射中移除所有映射关系. 
    3).查询操作：
        V get(key): 获得与关键字key相关的值，并且返回与关键字key相关的对象，如果没有该关键字，则返回null;判断key是否存在，可以通过返回值是否等于null
        boolean containsKey(key): 判断映像中是否存在关键字key;
        boolean containsValue(Object value): 判断映像中是否存在值value;
        int size(): 返回当前映像中映射的数量;
        boolean isEmpty(): 判断映像中是否有任何映射.
        Collection values():返回映像中所有value值的集，由于值多个，用Collection集合，对其操作可以使用Collection基本方法.

5.Map简单应用

[java] view plain copy
 
  1. import java.util.*;  
  2. //Strawberry2013-04-29  
  3. class MapDemo  
  4. {  
  5.     public static void main(String[] args)  
  6.     {  
  7.         Map<String, String> mp = new HashMap<String, String>();  
  8.         mp.put("02", "zhangsan");  
  9.         mp.put("01", "lisi");  
  10.         mp.put("04", "wangwu");  
  11.         //System.out.println(mp.put("01", "lisi"));     如果key已存在，在关联后，返回替换前该key对应的value值  
  12.         //System.out.println(mp.put("01", "li33si"));   如果不存在，则返回null  
  13.                                                         ////////////////////////////////////////////////////  
  14.         Set<String> setmap = mp.keySet();             //**(1)keySet()取出方式  
  15.         Iterator<String> it = setmap.iterator();  
  16.         while(it.hasNext())  
  17.         {  
  18.             System.out.println(mp.get(it.next()));  //有了键值key=it.next()，再使用get()方法获得value值  
  19.         }  
  20.   
  21.                                                         ////////////////////////////////////////////////////  
  22.         Set<Map.Entry<String, String>> entrySet = mp.entrySet();//**(2)entrySet()取出方式  
  23.         Iterator<Map.Entry<String, String>> it2 = entrySet.iterator();//Entry是Map接口中的内部接口  
  24.         while(it2.hasNext())  
  25.         {  
  26.             Map.Entry<String, String> e = it2.next();  
  27.             System.out.println(e.getKey() +":"+ e.getValue());  //getKey(),getValue是Map.Entry接口提供的方法  
  28.         }  
  29.     }  
  30. }  
[java] view plain copy
 
  1. /* 
  2. 要求： 
  3. 每个学生都有属性，姓名 年龄（姓名年龄作为主键）对应有归属地 
  4.     Strawberry2013-4-29 
  5. */  
  6. import java.util.*;  
  7.   
  8. class Student  
  9. {  
  10.     private int age;  
  11.     private String name;  
  12.     Student(String name, int age)  
  13.     {  
  14.         this.name = name;  
  15.         this.age = age;  
  16.     }  
  17.     public String getName()  
  18.     {  
  19.         return name;  
  20.     }  
  21.     public int getAge()  
  22.     {  
  23.         return age;  
  24.     }  
  25.     public int hashCode()  
  26.     {  
  27.         return name.hashCode()+age*17;  
  28.     }  
  29.     public boolean equals(Object obj)  
  30.     {  
  31.         if(!(obj instanceof Student))  
  32.             throw new ClassCastException("error!");  
  33.         Student s = (Student)obj;  
  34.         return this.age==s.age && this.name.equals(s.name);  
  35.     }  
  36. }  
  37. class MapDemo2  
  38. {  
  39.     public static void main(String[] args)  
  40.     {  
  41.         HashMap<Student, String> hm = new HashMap<Student, String>();  
  42.         hm.put(new Student("java02", 10), "Beijing");  
  43.         hm.put(new Student("java04", 40), "Wuhan");  
  44.         hm.put(new Student("java01", 4), "Zhengzhou");  
  45.   
  46.         Set<Student> s1 = hm.keySet();                        //keySet()取出方式  
  47.         Iterator<Student> it1 = s1.iterator();  
  48.         while(it1.hasNext())  
  49.         {  
  50.             Student t1 = it1.next();  
  51.             System.out.println(t1.getName()+" "+ t1.getAge() +" "+ hm.get(t1));  
  52.         }  
  53.   
  54.         Set<Map.Entry<Student, String>> s2 = hm.entrySet(); //entrySet()取出方式  
  55.         Iterator<Map.Entry<Student, String>> it2 = s2.iterator();  
  56.         while(it2.hasNext())  
  57.         {  
  58.             Map.Entry<Student, String> mp = it2.next();  
  59.             System.out.println(mp.getKey().getName()+".."+ mp.getKey().getAge() +".."+ mp.getValue());  
  60.         }                       //获取key值    和value值  
  61.     }  
  62. }  
[java] view plain copy
 
  1. /* 
  2. 要求： 
  3. 一字符串分别输出该字符串每个字符出现的次数 
  4.     Strawberry2013-4-29 
  5. */  
  6. import java.util.*;  
  7.   
  8. class MapDemo2  
  9. {  
  10.     public static void main(String[] args)  
  11.     {  
  12.         String str = "abddkdsadjljasdak";  
  13.         char[] ch = str.toCharArray();  
  14.   
  15.         TreeMap<Character, Integer> hm = new TreeMap<Character, Integer>(new Comp());  
  16.         //此处泛型应该使用类名，不可以使用TreeMap<char, int>  
  17.         for(int i=0; i<str.length(); i++)  
  18.         {  
  19.             if(hm.get(ch[i]) == null)  
  20.                 hm.put(ch[i], 1);  
  21.             else  
  22.                 hm.put(ch[i], hm.get(ch[i])+1);  
  23.         }  
  24.   
  25.         Set<Character> s = hm.keySet();     
  26.         Iterator<Character> it = s.iterator();  
  27.         while(it.hasNext())  
  28.         {  
  29.             char c = it.next();  
  30.             System.out.print(c +"("+ hm.get(c) +") ");  
  31.         }  
  32.     }  
  33. }  
  34. class Comp implements Comparator<Character>   //定义一个比较器，使其按降序排列  
  35. {  
  36.     public int compare(Character c1, Character c2)  
  37.     {  
  38.         return c2.compareTo(c1);  
  39.     }  
  40. }  
[java] view plain copy
 
    1. /* 
    2. 要求： 
    3.     一个学校 有n多个教室， 一个教室有n多个学生 
    4.     Strawberry2013-4-29 
    5. 分析： 
    6.     一个学校和n多个教室是实际存在的事先必须定义完全，在使用school.put()来关联学校和教室 
    7. */  
    8. import java.util.*;  
    9.   
    10. class MapDemo2  
    11. {  
    12.     public static void main(String[] args)  
    13.     {  
    14.         Comp comp = new Comp();         //定义一个比较器，降序排列  
    15.         TreeMap<String, TreeMap<String, String>> school = new TreeMap<String, TreeMap<String, String>>();   //默认序列  
    16.                   
    17.         TreeMap<String, String> room1 = new TreeMap<String, String>(comp);  //降序  
    18.         TreeMap<String, String> room2 = new TreeMap<String, String>(comp);  
    19.         TreeMap<String, String> room3 = new TreeMap<String, String>(comp);  
    20.   
    21.         school.put("class01", room1);   //关联教室与学校  
    22.         school.put("class02", room2);  
    23.         school.put("class03", room3);  
    24.   
    25.         room1.put("04","zhang");        //关联学生和教室  
    26.         room1.put("02","li");  
    27.   
    28.         room2.put("01","liu");  
    29.         room2.put("02","zhang");  
    30.   
    31.         room3.put("07","wang");  
    32.         room3.put("03","zhao");  
    33.   
    34.         Iterator<String> it1 = school.keySet().iterator();    //遍历教室  
    35.         while(it1.hasNext())  
    36.         {  
    37.             String className = it1.next();  
    38.             TreeMap<String, String> c = school.get(className);  
    39.   
    40.             System.out.println(className +"....");  
    41.             Iterator<String> it2 = c.keySet().iterator(); //遍历学生  
    42.             while(it2.hasNext())  
    43.             {  
    44.                 String studentId = it2.next();  
    45.                 System.out.println(studentId +","+ c.get(studentId));  
    46.             }  
    47.         }  
    48.     }  
    49. }  
    50. class Comp implements Comparator<String>                  //String比较器类  
    51. {  
    52.     public int compare(String s1, String s2)  
    53.     {  
    54.         return s2.compareTo(s1);  
    55.     }  
    56. }  
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/hanfeihanfei/p/6123344.html