java 集合框架 - Map集合部分

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();      
         }
}