Map的知识点梳理（不包含collections工具类）

一：基础公共方法（map不再是简单的加索引，可以直接命名key，通过key进行遍历）

1.常见的map子类

　　HashTable：底层是哈希表结构。不允许null键和null值，线程同步

　　HashMap：底层是哈希表结构，可以允许null键和null值，线程不同步

　　TreeMap：底层是二叉树结构，线程不同步，可以给map的键排序

2.map程序--公共的方法

 import java.util.Collection;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map;

 public class Test60 {

     public static void main(String[] args) {
         Map<Integer,String> hashMap=new HashMap<>();
         //增
         hashMap.put(1, "java1");
         hashMap.put(2, "java2");
         hashMap.put(3, "java3");
         //判断
         System.out.println(hashMap.containsKey(2));
         System.out.println(hashMap.containsValue("java2"));
         System.out.println(hashMap.isEmpty());
         //删除
         System.out.println(hashMap.remove(3));
         //获取1
         System.out.println(hashMap);
         System.out.println(hashMap.get(2));
         //获取2
         Collection<String> col=hashMap.values();//values方法返回的是Collection，这时候可以使用迭代器迭代出成员。
         Iterator it=col.iterator();
         while(it.hasNext()){
             System.out.println(it.next());
         }
     }

 }

3.运行结果

　　

二：map遍历的两个重要方法

1.keyset的使用

　　把map转换成Set类型，就是将所有的键存入到Set<K>中。

　　再使用get（K）来获得对应的value值。

 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.Set;
 public class Test61 {
     public static void main(String[] args) {
         Map<Integer,String> hashMap=new HashMap<>();
         hashMap.put(1, "java1");
         hashMap.put(2, "java2");
         hashMap.put(3, "java3");
         Set<Integer> keySet=hashMap.keySet();
         Iterator<Integer> it=keySet.iterator();
         while(it.hasNext()){
             Integer key=it.next();
             String value=hashMap.get(key);
             System.out.println(key+":"+value);
         }
     }
 }

2.运行结果

　　

3.entrySet的使用

　　返回包含键值关系的Set视图，返回值放入Set中，类型是Map.Entry<K,V>。

　　得到映射关系后，可以选择的方法是getKey与getValue分别取出key与value。

 public static void main(String[] args) {
         Map<Integer,String> hashMap=new HashMap<>();
         hashMap.put(1, "java1");
         hashMap.put(2, "java2");
         hashMap.put(3, "java3");
         Set<Map.Entry<Integer,String>> set=hashMap.entrySet();
         Iterator<Map.Entry<Integer, String>> itr=set.iterator();
         while(itr.hasNext()){
             Map.Entry<Integer, String> mapentry= itr.next();
             Integer key=mapentry.getKey();
             String value=mapentry.getValue();
             System.out.println(key+"::"+value);
         }
     }

4.运行结果

　　

三：map扩展

1.HashMap

　　保证学生对象的唯一性。

　　对学生对象的id进行排序。

 import java.util.Iterator;
 import java.util.Map;
 import java.util.Set;
 import java.util.TreeMap;
 public class Test63 {
     public static void main(String[] args) {
         TreeMap<Student,String> tm=new TreeMap<>();
         tm.put(new Student(1,"zhangsan"),"beijing");
         tm.put(new Student(2,"lisi"),"shanghai");
         tm.put(new Student(4,"zhaoliu"),"hangzhou");
         tm.put(new Student(3,"wangwu"),"shenzhen");
         tm.put(new Student(2,"lisi"),"shanghai");
         Set<Map.Entry<Student,String>> set=tm.entrySet();
         Iterator<Map.Entry<Student,String>> itr=set.iterator();
         while(itr.hasNext()){
             Map.Entry<Student, String> me=itr.next();
             Student stu=me.getKey();
             String str=me.getValue();
             System.out.println(stu+"::"+str);
         }
     }
 }
 class Student implements Comparable<Student>{
     private int id;
     private String name;
     Student(int id,String name){
         this.id=id;
         this.name=name;
     }
     public int getId() {
         return id;
     }
     public void setId(int id) {
         this.id = id;
     }
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public int compareTo(Student s){
         int num=new Integer(this.id).compareTo(new Integer(s.id));
         if(num==0){
             return name.compareTo(s.name);
         }
         return num;
     }
     public int hashCode(){
         return name.hashCode()+id*19;
     }
     public boolean equals(Object obj){
         if(!(obj instanceof Student)){
             return false;
         }
         Student s = (Student) obj;
         return this.name.equals(s.name)&&this.id==s.id;
     }
     @Override
     public String toString() {
         return "id=" + id + ", name=" + name;
     }

 }

2.运行结果

　　可以进行排序，学生具备了自然排序的功能（comparable接口），并且对于重复的记录只会保存一条

　　

3.TreeMap

　　对学生对象的name进行排序，同时保持id具备自身的比较性。

　　student对象仍然是上面例子中的对象，不再改动。

 import java.util.Comparator;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.Set;
 import java.util.TreeMap;

 public class Test64 {
     public static void main(String[] args) {
         TreeMap<Student,String> tm=new TreeMap<>(new StunameComparator());
         tm.put(new Student(1,"zhangsan"),"beijing");
         tm.put(new Student(2,"lisi"),"shanghai");
         tm.put(new Student(4,"zhaoliu"),"hangzhou");
         tm.put(new Student(3,"wangwu"),"shenzhen");
         tm.put(new Student(2,"lisi"),"shanghai");
         Set<Map.Entry<Student,String>> set=tm.entrySet();
         Iterator<Map.Entry<Student,String>> itr=set.iterator();
         while(itr.hasNext()){
             Map.Entry<Student, String> me=itr.next();
             Student stu=me.getKey();
             String str=me.getValue();
             System.out.println(stu+"::"+str);
         }
     }
 }
 class StunameComparator implements Comparator<Student>{

     @Override
     public int compare(Student s1, Student s2) {
         int num=s1.getName().compareTo(s2.getName());
         if(num==0){
             return new Integer(s1.getId()).compareTo(s2.getId());
         }
         return num;
     }

 }

4.运行结果

　　

5.小练习（统计字符串中出现的字符次数）

 import java.util.Iterator;
 import java.util.Map;
 import java.util.Set;
 import java.util.TreeMap;

 public class Test65 {
     public static void main(String[] args) {
         String s=charCount("aaabdd");
         System.out.println(s);
     }
     private static String charCount(String str) {
         char[] arr=str.toCharArray();
         TreeMap<Character,Integer> tm=new TreeMap<>();
         int count=0;
         for(int i=0;i<arr.length;i++){
             if(!(arr[i]>='a'&&arr[i]<='z'||arr[i]>='A'&&arr[i]<='Z'))
                 continue;
             Integer value=tm.get(arr[i]);
             System.out.println("-----"+value);
             if(value!=null)
                 count=value;
             count++;
             tm.put(arr[i], count);
             count=0;
         }
         StringBuffer sb=new StringBuffer();
         Set<Map.Entry<Character,Integer>> entry=tm.entrySet();
         Iterator<Map.Entry<Character, Integer>> itr=entry.iterator();
         while(itr.hasNext()){
             Map.Entry<Character, Integer> me=itr.next();
             Character ch=me.getKey();
             Integer value=me.getValue();
             sb.append(ch+"("+value+")");
         }
         return sb.toString();
     }
 }

6.运行结果