java 集合框架 - Map集合部分

╰+哭是因爲堅強的太久メ 2022-10-20 12:28 220阅读 0赞

**Map集合**

**一. 概述**  
将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射一个值，该集合存储键值对。一对一对往里存。而且要保证键的唯一性。

二. **特点**  
1. 该集合存储键值对。一对一对往里存。

2. 而且要保证键的唯一性。

三. **Map集合的共性方法  
1. 添加**  
`V``put``(K key, V value)` 将指定的值与此映射中的指定键相关联，如果出现添加相同的键，那么后添加的值会覆盖原有键对应的值，并且该方法返回被覆盖的值即原值。`void``putAll``(Map<? extends K,? extends V> t)` 从指定`集合中`将所有映射关系复制到此映射中。  
2. 删除

`V``remove``(Object key)` 如果存在此键的映射关系，则将其从映射中移除。  
`void clear``()` 从此映射中移除所有映射关系。

`3.``判断`

`boolean``containsKey``(Object key)` 如果此`集合中`包含指定键的映射关系，则返回true。``

`boolean``containsValue``(Object value)` 如果此`集合`为指定值映射一个或多个键，则返回true。``boolean `isEmpty``()` 如果此映射未包含键-值映射关系，则返回  true。

**4. 获取**

`V get``(Object key)` 返回此`集合中`映射到指定键的值，也可以通过此方法的返回值来判断一个键是否存在，不存在返回null。  
`int size``()` 返回此映射中的键-值映射关系数。  
`Collection<V> values()``获取``map``集合中所有的值，`而Map的值是可以重复的，因此values()方法的返回类型是Collection，可以容纳重复的元素`。`  
`Set<K> keySet()` 返回key的集合，因为Map的键是不能重复的，因此keySet()方法的返回类型是Set。  
`Set<Map.Entry<K,V>>entrySet()` 返回此`集合中`包含的映射关系的 set 视图。

**Map集合中的子类  
1. Hashtable:** 底层是哈希表数据结构，不可存入null键和null值。该集合是线程同步的，JDK1.0,效率较低。  
**2. HashMap:** 底层是哈希表数据结构，允许使用 null 值和 null 键，该集合是不同步的。将hashtable替代，jdk1.2.效率高，它是通过键值对中的键(key)的两个方法，hashCode()和equals(Object obj)来完成键值对的唯一性。如果元素的hashcode值相同，才会去判断equals是否为true，如果元素的hashcode值不同，不会调用equals。。  
**3. TreeMap:** 底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序,假如存入的键值对中的键(key)具备比较性，TreeMap内部会自动将这些元素按照自然升序进行排序存放，假如存入的元素自身不具有比较性，程序在运行时会发生Exceptionin thread "main"java.lang.ClassCastException:com.Test1.Car cannot be cast to java.lang.Comparable。

**四. 两种获取或遍历集合的方法  
1. keySet()方法获取元素:**  
将map中所有的键存入到Set集合。因为set具备迭代器, 所以可以迭代方式取出所有的键，在根据get方法。获取每一个键对应的值。

import java.util.*;  
      class KeySetDemo   
      {  
          public static void main(String[] args)   
         {  
              //创建Map集合，并添加元素  
              Map<Integer,String> map = new HashMap<Integer,String>();  
              map.put(2,"zhangsan");            
             map.put(6,"lisi");  
             map.put(3,"wangwu");  
             map.put(4,"heihei");  
             map.put(5,"xixi");  
             //获取map集合中的所有键的Set集合  
             Set<Integer> keySet = map.keySet();  
            //有了Set集合就可以获取其迭代器，取值  
             Iterator<Integer> it = keySet.iterator();  
             while (it.hasNext())  
             {  
                Integer i = it.next();  
                 String s = map.get(i);  
                 System.out.println(i + " = " + s);  
             }  
        }  
     }

**2. Set<Map.Entry<k,v>>entrySet()方法获取元素:**  
将map集合中的映射关系存入到了set集合中，而这个关系的数据类型就是Map.Entry，将这个键值对映射关系关系存入到Set集合中之后，再使用迭代器的方法去遍历没一个键值对映射关系，并通过Map.Entry中的getKey()和getValue()放取出键值 。

entrySet取出方式：

*/  
      import java.util.*;  
      class EntrySetDemo  
      {  
          public static void main(String[] args)   
         {  
              //创建集合，存入元素  
              Map<String,String> map = new HashMap<String,String>();  
             map.put("01","lisi1");  
             map.put("02","lisi2");  
             map.put("03","lisi3");  
             map.put("04","lisi4");  
             //获取map集合中的所有键，存入到Set集合中，  
             Set<Map.Entry<String,String>> entry = map.entrySet();  
             //通过迭代器取出map中的键值关系，迭代器接收的泛型参数应和Set接收的一致  
             Iterator<Map.Entry<String,String>> it = entry.iterator();  
             while (it.hasNext())  
             {  
                 //将键值关系取出存入Map.Entry这个映射关系集合接口中  
                 Map.Entry<String,String>  me = it.next();  
                 //使用Map.Entry中的方法获取键和值  
                 String key = me.getKey();  
                 String value = me.getValue();  
                 System.out.println(key + " : " + value);  
             }  
         }  
     }

**五. 补充:关于Map.Entry**

Map是一个接口，其实，Entry也是一个接口，它是Map的子接口中的一个内部接口，就相当于是类中有内部类一样。为何要定义在其内部呢？

原因：  
**a.** Map集合中存储的是映射关系这样的两个数据，是先有Map这个集合，因为只有有了Map集合，有了键值对，才会有键值的映射关系。

**b.** 关系属于Map集合中的一个内部事物。 而且该事物在直接访问Map集合中的元素。

**练习及应用  
示例1:  
在很多项目中，应用比较多的是一对多的映射关系，这就可以通过嵌套的形式将多个映射定义到一个大的集合中，并将大的集合分级处理，形成一个体系。**

package com.map;
    import java.util.*;
    public class HashMapDemo
    {
    /*
    * 一个Map集合(公司)存放了key(部门)
    * 与key对应的 value又是一个嵌套的Map集合(key（员工工号）,与key对应的是员工的姓名)
    */
    
    public static void main(String[] args)
    {
    //创建一个公司集合，才能在公司里面成立各司其政的部门（key=部门名称，value=部门集合）。
    HashMap<String,HashMap<String,String>>Corp = new HashMap<String,HashMap<String,String>>();
    
    //创建一个部门集合，才能招募人才，员工为部门出谋划策（key=员工号称，value=员工姓名）
    HashMap<String,String> EE = newHashMap<String,String>();
    HashMap<String,String> ME = newHashMap<String,String>();
    
    List<Student> Soft3 = newArrayList<Student>();
    List<Student> Soft1 = newArrayList<Student>();
    
    //将部门放在公司里面，正式成立
    Corp.put("电子工程部",EE);
    Corp.put("机构工程部",ME);
    
    school.put("软件3班",Soft3);
    school.put("软件1班",Soft1);
    
    //招募员工在部门工作
    EE.put("S13006540","Ansen");
    EE.put("S13006530","Kaka");
    EE.put("S13006480","Hahn");
    
    ME.put("S13006240","Kevil");
    ME.put("S13006960","Hank");
    ME.put("S13006550","Rudy");
    
    getDepinfo(Corp);
    System.out.println(getDepEmpInfo(ME));
    System.out.println(getAllEmpInfo(Corp));
    
    }
    
    public static voidgetDepinfo(HashMap<String,HashMap<String,String>> corp)
    {
    Iterator<Map.Entry<String,HashMap<String,String>>>depIter = corp.entrySet().iterator();
    StringBuilder sb = new StringBuilder();
    while(depIter.hasNext())
    {
    Map.Entry<String,HashMap<String,String>>depMap = depIter.next();
    String DepName=depMap.getKey();
    System.out.println("部门名称: "+DepName+"\n"); 
    }
    }
    public static StringgetDepEmpInfo(HashMap<String,String> dep)
    {
    StringBuilder sb = new StringBuilder();
    Iterator<Map.Entry<String,String>>Empiter = dep.entrySet().iterator();
    while(Empiter.hasNext())
    {
    Map.Entry<String,String> depMe =Empiter.next();
    String workid = depMe.getKey();
    String name = depMe.getValue();
    sb.append("员工工号:"+workid+" 员工姓名:"+name+"\n");
    }
    return sb.toString();
    }
    public static StringgetAllEmpInfo(HashMap<String,HashMap<String,String>> c)
    {
    StringBuilder strb = new StringBuilder();
    Iterator<Map.Entry<String,HashMap<String,String>>>allMap = c.entrySet().iterator();
    while(allMap.hasNext())
    {
    Map.Entry<String,HashMap<String,String>>map = allMap.next();
    String DepName=map.getKey();
    strb.append("部门名称:"+DepName+"\n");
    strb.append(getDepEmpInfo(map.getValue()));
    
    }
    return strb.toString();
    }

**示例2  
获取没一个字母出现的次数**

package com.map;
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Set;
    import java.util.TreeMap;
    public class TreeMapDemo
    {
     
     
           public staticvoid main(String[] args)
           {
                 
                  //System.out.println(getCount("AAC-A+=BBB/CEDD"));
           }
           public staticString getCount() throws Exception
           {
                             BufferedReader br = new BufferedReader(newInputStreamReader(System.in));
                                       String s = null;
                                       while((s =br.readLine())!= null)
                                       {
                                                break;
                                       }
                 
                      //将传入的字符串利用String类的toCharArray()转变为字符数组并赋值给chs
                                   char[]chs = s.toCharArray();
                              TreeMap<Character,Integer> tp = new TreeMap<Character,Integer>();
                                   for(int i= 0; i<chs.length; i++)
                                   {
                                          if(!(chs[i] >= 'a' && chs[i] <= 'z' || chs[i] >= 'A' &&chs[i] <= 'Z'))
                                          {
                                                 continue;
                                             
                                          }
                                          Integervalue = tp.get(chs[i]);
                                          int count= 0;
                                         if(!(value == null))
                                          {
                                                count=value;
                                          }
                                                 count++;
                 
                                         tp.put(chs[i],count);          
                 
                                   }
                                  Set<Map.Entry<Character,Integer>> set = tp.entrySet();
                                  Iterator<Map.Entry<Character,Integer>> mapit = set.iterator();
                                  StringBuilder sb = new StringBuilder();
                                  while(mapit.hasNext())
                                   {
                                         Map.Entry<Character,Integer>  map = mapit.next();
                                          Characterkey = map.getKey();
                                          Integervalue = map.getValue();
                                         sb.append(key+" 出现 "+value+"次。"+"\n");
                                   }
                          returnsb.toString();      
             }
    }