Java集合---Map

Map集合

​ Map集合是Java提供的用来存放键值对的，是双列集合，用以处理一一对应关系的数据。

1. Map特点

   • Collection中元素是单列的，Map集合的元素是双列的，有key和value
   • Map集合中不能包含重复的键，值可以重复，每个键只能对应一个值。

2. Map常用子类

   Map接口有多个子类，这里主要介绍常用的HashMap集合和LinkedHashMap集合。

   • HashMap

     HashMap采用哈希表结构存储数据，元素无序，同HashSet一样，要保证键的唯一，需要重写键的HashCode()和equals()方法。

   • LinkedHashMap

     LinkedHashMap是HashMap的子类，存储数据采用的是哈希表+链表的结构，能够保证元素有序，同样需要保证键的唯一，需要重写键的HashCode()和equals()方法。

3. Map接口中常用的方法

   • public V put(K key, V value)：将指定的值与集合中指定的键关联
   • public V remove(Object key)：如果存在，则从集合中移除一个键的映射，返回被删除的元素
   • public V get(Object key)：返回指定键的值，如果键不存在，则返回null
   • public Set keySet()：获取Map集合中所有的键，存储到Set集合中
   • public Set> entrySet()：获取Map集合中所有的键值对对象的集合（Set集合）

   public class MapDemo1 {
       public static void main(String[] args) {
           HashMap<String, String> m = new HashMap<String,String>();
           // 添加元素
           m.put("邓超", "孙俪");
           m.put("罗晋", "唐嫣");
           m.put("霍建华", "林心如");
           // 获取所有的键
           Set<String> kSet = m.keySet();
           System.out.println(kSet); // 输出：[邓超, 霍建华, 罗晋]
   
           // 获取指定键的值
           System.out.println(m.get("罗晋")); // 输出: 唐嫣
   
           // 遍历键集合，获取每一个值
           for (String s : kSet) {
               String value = m.get(s);
               System.out.print(value + " ");
           } // 输出：孙俪 林心如 唐嫣
   
           // 删除键值对
           System.out.println(m.remove("邓超")); // 输出：孙俪
           System.out.println(m.remove("胡歌")); // 输出：null
   
           // put方法，如果key不存在，则是新添加一个键值对，返回null
           // 如果key存在，则是修改对应key的值，返回修改前的值
           System.out.println(m.put("黄晓明","杨颖"));  // 输出：null
           System.out.println(m.put("霍建华", "胡歌")); // 输出：林心如
       }
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30

4. Map集合的遍历方式

   • 使用键找值的方式：通过元素的键，获取键所对应的值

     使用步骤：

     1. 获取Map中所有的键，使用keySet()方法，返回一个存储所有键的Set集合
     2. 遍历Set集合，获取每一个键
     3. 使用get()方法，通过键获取对应的值

     public class MapDemo2 {
         public static void main(String[] args) {
             HashMap<String, String> m = new HashMap<>();
             // 添加元素
             m.put("邓超", "孙俪");
             m.put("罗晋", "唐嫣");
             m.put("霍建华", "林心如");
             // 获取所有的键
             Set<String> kSet = m.keySet();
     
             // 遍历键集合，获取每一个值
             for (String s : kSet) {
                 String value = m.get(s);
                 System.out.print(value + " ");
             } // 输出：孙俪 林心如 唐嫣
         }
     }
     1
     2
     3
     4
     5
     6
     7
     8
     9
     10
     11
     12
     13
     14
     15
     16
     17

   • 通过Entry键值对对象的方式

     Entry接口是Map接口的一个内部接口，所以在调用时候需要使用Map.Entry.

     Entry是一个键值对对象，将Map中的每一个键值对封装成了一个对象，所以Map集合中每一个键值对对应一个Entry对象，那么在遍历的时候就可以通过获取所有的键值对对象Entry，再从每一个Entry对象中获取对应的键和值。

     Map集合中提供了获取所有的Entry对象的方法：

     ​ public Set> entrySet()：获取到Map集合中所有的键值对对象的集合。

     既然要从Entry对象中获取对应的键和值，那么Entry对象肯定要提供方法供获取，有以下两个方法：

     1. public K getKey()：获取Entry对象中的键
     2. public V getValue()：获取Entry对象中的值

     使用Entry对象遍历Map集合的步骤：

     1. 使用方法entrySet()获取Map集合中所有的Entry对象，返回一个Set集合
     2. 遍历Set集合，获取每一个Entry对象
     3. 通过Entry对象方法getKey()和getValue()获取对应的键和值

     public class MapDemo3 {
         public static void main(String[] args) {
             HashMap<String, String> m = new HashMap<>();
             // 添加元素
             m.put("邓超", "孙俪");
             m.put("罗晋", "唐嫣");
             m.put("霍建华", "林心如");
     
             // 获取所有的Entry对象
             Set<Map.Entry<String,String>> entrySet = m.entrySet();
     
             // 遍历Entry对象集合，获取Map集合的键和值
             for (Map.Entry<String,String> e : entrySet) {
                 String key = e.getKey();
                 String value = e.getValue();
                 System.out.println("key = " + key + ",value = " + value);
             }
             /*
             输出：
             key = 邓超,value = 孙俪
             key = 霍建华,value = 林心如
             key = 罗晋,value = 唐嫣
             */
         }
     }
     1
     2
     3
     4
     5
     6
     7
     8
     9
     10
     11
     12
     13
     14
     15
     16
     17
     18
     19
     20
     21
     22
     23
     24
     25

5. Map集合小练习

   需求：计算一个字符串中每个字符出现的字数。

   public class MapDemo4 {
       public static void main(String[] args) {
           Scanner in = new Scanner(System.in);
   
           System.out.print("请输入字符串：");
           String str = in.nextLine();
   
           findChar(str);
       }
   
       public static void findChar(String str) {
           HashMap<Character, Integer> hm = new HashMap<>();
   
           // 遍历字符串
           for (int i = 0; i < str.length(); i++) {
               Character c = str.charAt(i);
               if (hm.get(c) == null) {    // 字符不存在
                   hm.put(c,1);
               } else {
                   int count = hm.get(c);
                   hm.put(c, count+1);
               }
           }
   
           // 遍历Map集合
           Set<Map.Entry<Character,Integer>> entrySet = hm.entrySet();
           for (Map.Entry<Character,Integer> e:entrySet) {
               System.out.println(e.getKey() + " = " + e.getValue());
           }
       }
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31