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

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

1.常见的map子类

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

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

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

 

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

 1 import java.util.Collection;
 2 import java.util.HashMap;
 3 import java.util.Iterator;
 4 import java.util.Map;
 5 
 6 public class Test60 {
 7 
 8     public static void main(String[] args) {
 9         Map<Integer,String> hashMap=new HashMap<>();
10         //增
11         hashMap.put(1, "java1");
12         hashMap.put(2, "java2");
13         hashMap.put(3, "java3");
14         //判断
15         System.out.println(hashMap.containsKey(2));
16         System.out.println(hashMap.containsValue("java2"));
17         System.out.println(hashMap.isEmpty());
18         //删除
19         System.out.println(hashMap.remove(3));
20         //获取1
21         System.out.println(hashMap);
22         System.out.println(hashMap.get(2));
23         //获取2
24         Collection<String> col=hashMap.values();//values方法返回的是Collection，这时候可以使用迭代器迭代出成员。
25         Iterator it=col.iterator();
26         while(it.hasNext()){
27             System.out.println(it.next());
28         }
29     }
30 
31 }

 

3.运行结果

　　

 

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

1.keyset的使用

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

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

 1 import java.util.HashMap;
 2 import java.util.Iterator;
 3 import java.util.Map;
 4 import java.util.Set;
 5 public class Test61 {
 6     public static void main(String[] args) {
 7         Map<Integer,String> hashMap=new HashMap<>();
 8         hashMap.put(1, "java1");
 9         hashMap.put(2, "java2");
10         hashMap.put(3, "java3");
11         Set<Integer> keySet=hashMap.keySet();
12         Iterator<Integer> it=keySet.iterator();
13         while(it.hasNext()){
14             Integer key=it.next();
15             String value=hashMap.get(key);
16             System.out.println(key+":"+value);
17         }
18     }
19 }

 

2.运行结果

　　

 

3.entrySet的使用

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

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

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

 

4.运行结果

　　

 

三：map扩展

1.HashMap

　　保证学生对象的唯一性。

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

 1 import java.util.Iterator;
 2 import java.util.Map;
 3 import java.util.Set;
 4 import java.util.TreeMap;
 5 public class Test63 {    
 6     public static void main(String[] args) {
 7         TreeMap<Student,String> tm=new TreeMap<>();
 8         tm.put(new Student(1,"zhangsan"),"beijing");
 9         tm.put(new Student(2,"lisi"),"shanghai");
10         tm.put(new Student(4,"zhaoliu"),"hangzhou");
11         tm.put(new Student(3,"wangwu"),"shenzhen");
12         tm.put(new Student(2,"lisi"),"shanghai");
13         Set<Map.Entry<Student,String>> set=tm.entrySet();
14         Iterator<Map.Entry<Student,String>> itr=set.iterator();
15         while(itr.hasNext()){
16             Map.Entry<Student, String> me=itr.next();
17             Student stu=me.getKey();
18             String str=me.getValue();
19             System.out.println(stu+"::"+str);
20         }    
21     }
22 }
23 class Student implements Comparable<Student>{
24     private int id;
25     private String name;
26     Student(int id,String name){
27         this.id=id;
28         this.name=name;
29     }
30     public int getId() {
31         return id;
32     }
33     public void setId(int id) {
34         this.id = id;
35     }
36     public String getName() {
37         return name;
38     }
39     public void setName(String name) {
40         this.name = name;
41     }
42     public int compareTo(Student s){
43         int num=new Integer(this.id).compareTo(new Integer(s.id));
44         if(num==0){
45             return name.compareTo(s.name);
46         }
47         return num;
48     }
49     public int hashCode(){
50         return name.hashCode()+id*19;
51     }
52     public boolean equals(Object obj){
53         if(!(obj instanceof Student)){
54             return false;
55         }
56         Student s = (Student) obj;
57         return this.name.equals(s.name)&&this.id==s.id;
58     }
59     @Override
60     public String toString() {
61         return "id=" + id + ", name=" + name;
62     }
63     
64 }

2.运行结果

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

　　

 

3.TreeMap

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

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

 1 import java.util.Comparator;
 2 import java.util.Iterator;
 3 import java.util.Map;
 4 import java.util.Set;
 5 import java.util.TreeMap;
 6 
 7 public class Test64 {
 8     public static void main(String[] args) {
 9         TreeMap<Student,String> tm=new TreeMap<>(new StunameComparator());
10         tm.put(new Student(1,"zhangsan"),"beijing");
11         tm.put(new Student(2,"lisi"),"shanghai");
12         tm.put(new Student(4,"zhaoliu"),"hangzhou");
13         tm.put(new Student(3,"wangwu"),"shenzhen");
14         tm.put(new Student(2,"lisi"),"shanghai");
15         Set<Map.Entry<Student,String>> set=tm.entrySet();
16         Iterator<Map.Entry<Student,String>> itr=set.iterator();
17         while(itr.hasNext()){
18             Map.Entry<Student, String> me=itr.next();
19             Student stu=me.getKey();
20             String str=me.getValue();
21             System.out.println(stu+"::"+str);
22         }    
23     }
24 }
25 class StunameComparator implements Comparator<Student>{
26 
27     @Override
28     public int compare(Student s1, Student s2) {
29         int num=s1.getName().compareTo(s2.getName());
30         if(num==0){
31             return new Integer(s1.getId()).compareTo(s2.getId());
32         }
33         return num;
34     }
35     
36 }

 

4.运行结果

　　

 

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

 1 import java.util.Iterator;
 2 import java.util.Map;
 3 import java.util.Set;
 4 import java.util.TreeMap;
 5 
 6 public class Test65 {
 7     public static void main(String[] args) {
 8         String s=charCount("aaabdd");
 9         System.out.println(s);
10     }
11     private static String charCount(String str) {
12         char[] arr=str.toCharArray();
13         TreeMap<Character,Integer> tm=new TreeMap<>();
14         int count=0;
15         for(int i=0;i<arr.length;i++){
16             if(!(arr[i]>='a'&&arr[i]<='z'||arr[i]>='A'&&arr[i]<='Z'))
17                 continue;
18             Integer value=tm.get(arr[i]);
19             System.out.println("-----"+value);
20             if(value!=null)
21                 count=value;
22             count++;
23             tm.put(arr[i], count);
24             count=0;
25         }
26         StringBuffer sb=new StringBuffer();
27         Set<Map.Entry<Character,Integer>> entry=tm.entrySet();
28         Iterator<Map.Entry<Character, Integer>> itr=entry.iterator();
29         while(itr.hasNext()){
30             Map.Entry<Character, Integer> me=itr.next();
31             Character ch=me.getKey();
32             Integer value=me.getValue();
33             sb.append(ch+"("+value+")");
34         }
35         return sb.toString();
36     }
37 }

 

 6.运行结果