黑马程序员_Java基础_集合（Map类）

一、集合(Map概述)

java.util 

接口 Map<K,V>

类型参数：

K - 此映射所维护的键的类型

V - 映射值的类型

Map

|--Hashtable

|--HashMap

|--TreeMap

1.添加

put(K key, V value) 将指定的值与此映射中的指定键关联（可选操作）。

putAll(Map<? extends K,? extends V> m) 从指定映射中将所有映射关系复制到此映射中（可选操作）。

2.删除

void clear() 从此映射中移除所有映射关系（可选操作）。

V remove(Object key) 如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。 

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() 返回此映射中包含的值的 Collection 视图。

Set<Map.Entry<K,V>> entrySet() 返回此映射中包含的映射关系的 Set 视图。

Set<K> keySet() 返回此映射中包含的键的 Set 视图。 

二、集合(Map子类对象特点)

Map

|--Hashtable:底层是哈希表数据结构，不可以存入null健null值。该集合线程同步。jdk1.0  效 率低

|--HashMap：底层是哈希表数据结构，允许使用null健null值。该集合线程不同步。jdk1.2 效率高

|--TreeMap：底层是二叉树数据结构。线程不同步。可以用于给map集合中的健进行排序。

Map和Set很像，其实Set底层就是使用了Map集合。

三、集合(Map共性方法)

[java]  view plain copy

1. /* 
2. Map共性方法: 
3. */  
4. import java.util.*;  
5. class MapDemo   
6. {  
7.     public static void main(String[] args)   
8.     {  
9.         Map<String,String> map=new HashMap<String,String>();  
10.         /*添加元素，如果出现添加时有相同的健，那么后添加的值会覆盖原有键对应的值。 
11.         并且put会返回原有健的值。 
12.         */  
13.         System.out.println(map.put("001","张三"));  
14.         System.out.println(map.put("001","zhangsan"));  
15.         map.put("002","李四");  
16.         map.put("003","王五");  
17.   
18.         System.out.println("containsKey:"+map.containsKey("002"));  
19.   
20.         System.out.println("remove:"+map.containsKey("0021"));  
21.         System.out.println("remove:"+map.remove("002"));  
22.   
23.         System.out.println(map);  
24.   
25.         System.out.println("get:"+map.get("0012"));//可以通过get方法的返回值来判断一个键是否存在。  
26.           
27.         Collection<String> coll=map.values();  
28.         System.out.println(coll);  
29.         System.out.println(map);  
30.     }  
31. }  

四、集合(Map-keySet)

[java]  view plain copy

1. /* 
2. Map集合的两种取出方式： 
3.  
4. 1. Set<k> keySet():将Map中所有的键存入Set集合。因为Set具备迭代器。 
5. 所以可以用迭代的方式取出所有的健，再根据get方法获取每个键对应的值。 
6.  
7. Map集合的取出原理：将Map集合转成Set集合，再通过迭代器取出。 
8.  
9. */  
10. import java.util.*;  
11. class MapDemo2   
12. {  
13.     public static void main(String[] args)   
14.     {  
15.         Map<String,String> map=new HashMap<String,String>();  
16.   
17.         map.put("001","张三");  
18.         map.put("002","李四");  
19.         map.put("003","王五");  
20.         map.put("004","小明");  
21.   
22.           
23.         Set<String> keySet=map.keySet();//获取map集合所有键的Set集合，keySet();  
24.   
25.         Iterator<String> it=keySet.iterator();  
26.   
27.         while(it.hasNext())  
28.         {  
29.             String key=it.next();  
30.             String value=map.get(key);  
31.             System.out.println("key:"+key+"\tvalue:"+value);  
32.         }  
33.     }  
34. }  

五、集合(Map-entrySet)

[java]  view plain copy

1. /* 
2. map集合的两种取出方式： 
3.  
4. 2.Set<Map.Entry<K,V>>entrySet():将Map集合中的映射关系存入Set集合中，而这个关系的 
5. 数据类型是：Map.Entry 
6.  
7. Map.Entry其实Entry也是一个接口，他是Map接口中的内部接口。 
8.  
9. interface Map 
10. { 
11.     public static interface Entry 
12.     { 
13.         public abstract Object getKey(); 
14.         public abstract Object getValue(); 
15.     } 
16. } 
17.  
18. class HashMap implements Map 
19. { 
20.     class Hahs implements Map.Entry 
21.     { 
22.         public abstract Object getKey(){} 
23.         public abstract Object getValue(){} 
24.     } 
25. }    
26.  
27. */  
28. import java.util.*;  
29. class MapDemo2   
30. {  
31.     public static void main(String[] args)   
32.     {  
33.         Map<String,String> map=new HashMap<String,String>();  
34.   
35.         map.put("001","张三");  
36.         map.put("002","李四");  
37.         map.put("003","王五");  
38.         map.put("004","小明");  
39.   
40.           
41.         Set<Map.Entry<String,String>> entrySet=map.entrySet();//将Map集合中的映射关系取出存入Set集合中。  
42.   
43.         Iterator<Map.Entry<String,String>> it=entrySet.iterator();  
44.   
45.         while(it.hasNext())  
46.         {  
47.             Map.Entry<String,String> me=it.next();  
48.             String key=me.getKey();  
49.             String value=me.getValue();  
50.             System.out.println("key:"+key+"\tvalue:"+value);  
51.         }  
52.     }  
53. }  

六、集合(Map练习)

[java]  view plain copy

1. /* 
2. 每个学生都有对应的归属地。 
3. 学生Student 地址String 
4. 学生属性：姓名，年龄 
5. 注意：姓名和年龄相同的视为同一个学生。 
6. 保证学生的唯一性。 
7.  
8. 1.描述学生。 
9. 2.定义Map容器将学生作为健，地址作为值存入。 
10. 3.获取Map集合中的元素。 
11. */  
12. import java.util.*;  
13. class Student implements Comparable<Student>  
14. {  
15.     private String name;  
16.     private int age;  
17.     Student(String name,int age)  
18.     {  
19.         this.name=name;  
20.         this.age=age;  
21.     }  
22.     public int compareTo(Student s)  
23.     {  
24.         int num=new Integer(this.age).compareTo(new Integer(s.age));  
25.         if(num==0)  
26.             return this.name.compareTo(s.name);  
27.         return num;  
28.     }  
29.   
30.     public int hashCode()  
31.     {  
32.         return name.hashCode()+age*34;  
33.     }  
34.     public boolean equals(Object obj)  
35.     {  
36.         if(!(obj instanceof Student))  
37.             throw new ClassCastException("类型不匹配");  
38.   
39.         Student s=(Student)obj;  
40.         return this.name.equals(s.name)&&this.age==s.age;  
41.     }  
42.     public String getName()  
43.     {  
44.         return name;  
45.     }  
46.     public int getAge()  
47.     {  
48.         return age;  
49.     }  
50.     public String toString()  
51.     {  
52.         return name+":"+age;  
53.     }  
54. }  
55.   
56. class MapTest   
57. {  
58.     public static void main(String[] args)   
59.     {  
60.         HashMap<Student,String> hm=new HashMap<Student,String>();  
61.   
62.         hm.put(new Student("zhangsan01",20),"beijing");  
63.         hm.put(new Student("zhangsan02",23),"shanghai");  
64.         hm.put(new Student("zhangsan03",24),"nanjing");  
65.         hm.put(new Student("zhangsan04",22),"wuhan");  
66.   
67.         //第一种取出方式：  
68.   
69.         Set<Student> keySet=hm.keySet();  
70.         Iterator<Student> it=keySet.iterator();  
71.   
72.         while(it.hasNext())  
73.         {  
74.             Student stu=it.next();  
75.             String addr=hm.get(stu);  
76.             System.out.println("姓名："+stu.getName()+"\t年龄："+stu.getAge()+"\t地址："+addr);  
77.         }  
78.   
79.         //第二种取出方式：  
80.           
81.         Set<Map.Entry<Student,String>> entrySet=hm.entrySet();  
82.         Iterator<Map.Entry<Student,String>> itr=entrySet.iterator();  
83.         while(itr.hasNext())  
84.         {  
85.             Map.Entry<Student,String> me=itr.next();  
86.             Student stu=me.getKey();  
87.             String addr=me.getValue();  
88.             System.out.println("姓名："+stu.getName()+"\t年龄："+stu.getAge()+"\t地址："+addr);  
89.         }  
90.     }  
91. }  

七、集合(TreeMap练习)

[java]  view plain copy

1. /* 
2. 需求：对学生对象的年龄进行升序排序。 
3.  
4. 因为数据是以键值对的形式存在的，所以要使用判续的Map集合TreeMap 
5. */  
6. import java.util.*;  
7. class Student implements Comparable<Student>  
8. {  
9.     private String name;  
10.     private int age;  
11.     Student(String name,int age)  
12.     {  
13.         this.name=name;  
14.         this.age=age;  
15.     }  
16.     public int compareTo(Student s)  
17.     {  
18.         int num=new Integer(this.age).compareTo(new Integer(s.age));  
19.         if(num==0)  
20.             return this.name.compareTo(s.name);  
21.         return num;  
22.     }  
23.   
24.     public int hashCode()  
25.     {  
26.         return name.hashCode()+age*34;  
27.     }  
28.     public boolean equals(Object obj)  
29.     {  
30.         if(!(obj instanceof Student))  
31.             throw new ClassCastException("类型不匹配");  
32.   
33.         Student s=(Student)obj;  
34.         return this.name.equals(s.name)&&this.age==s.age;  
35.     }  
36.     public String getName()  
37.     {  
38.         return name;  
39.     }  
40.     public int getAge()  
41.     {  
42.         return age;  
43.     }  
44.     public String toString()  
45.     {  
46.         return name+":"+age;  
47.     }  
48. }  
49. class StuNameComparator implements Comparator<Student>  
50. {  
51.     public int compare(Student s1,Student s2)  
52.     {  
53.         int num=s1.getName().compareTo(s2.getName());  
54.         if(num==0)  
55.             return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));  
56.           
57.         return num;  
58.     }  
59. }  
60. class MapTest2   
61. {  
62.     public static void main(String[] args)   
63.     {  
64.         TreeMap<Student,String> tm=new TreeMap<Student,String>(new StuNameComparator());  
65.   
66.         tm.put(new Student("zhangsan01",20),"beijing");  
67.         tm.put(new Student("zhangsan03",24),"nanjing");  
68.         tm.put(new Student("zhangsan02",23),"shanghai");  
69.         tm.put(new Student("zhangsan04",22),"wuhan");  
70.         tm.put(new Student("zhangsan04",20),"wuhan");  
71.   
72.         Set<Map.Entry<Student,String>> entrySet=tm.entrySet();  
73.         Iterator<Map.Entry<Student,String>> it=entrySet.iterator();  
74.   
75.         while(it.hasNext())  
76.         {  
77.             Map.Entry<Student,String> me=it.next();  
78.             Student stu=me.getKey();  
79.             String addr=me.getValue();  
80.             System.out.println(stu+"..."+addr);  
81.         }  
82.     }  
83. }  

八、集合(TreeMap练习-字母出现的次数)

[java]  view plain copy

1. /* 
2. 练习： 
3. "asfdjhsadkjfhskfsad"获取该字符串中的字母出现的次数。 
4. 打印形式：a(1)b(2).... 
5.  
6. 通过结果发现，每一个字母都有对应的次数。 
7. 说明字母和次数之间都有映射关系。 
8. 注意： 
9. 当发现有映射关系时，可以选择Map集合。因为Map集合中存放的就是映射关系。 
10.  
11. 什么时候使用Map集合呢？ 
12. 当数据之间存在着映射关系时，就要先想到Map集合。 
13.  
14. 思路: 
15. 1.将字符串转换为字符数组。 
16. 2.定义一个Map集合，因为打印结构的字母有顺序，所以使用TreeMap集合 
17. 3.遍历字符数组。将每一个字母作为键去查Map集合。如果返回null，将 
18. 该字母和1存入到Map集合中。如果返回不是null，说明该字母在Map集合已经 
19. 存在并有对应的次数。那么就获取该次数并进行自增，然后将字母和自增后的次序 
20. 数存入到Map集合中，覆盖掉原来键所对应的值。 
21. 4.将Map集合中的数据编程指定的字符串形式返回。 
22.  
23. */  
24. import java.util.*;  
25. class MapTest3   
26. {  
27.     public static void main(String[] args)   
28.     {  
29.         String s=charCount("asdasd");  
30.         System.out.println(s);  
31.     }  
32.     public static String charCount(String str)  
33.     {  
34.         int count=0;  
35.   
36.         char[] chs=str.toCharArray();  
37.   
38.         TreeMap<Character,Integer> tm=new TreeMap<Character,Integer>();  
39.   
40.         for(int i=0;i<chs.length;i++)  
41.         {  
42.             if(!(chs[i]>='a'&&chs[i]<='z'||chs[i]>='A'&&chs[i]<='Z'))  
43.                 continue;  
44.   
45.   
46.             Integer value=tm.get(chs[i]);  
47.   
48.             if(value!=null)  
49.                 count=value;  
50.             count++;  
51.             tm.put(chs[i],count);  
52.   
53.             count=0;//清0  
54.             /* 
55.             if(value==null) 
56.             { 
57.                 tm.put(chs[i],1); 
58.             } 
59.             else 
60.             { 
61.                 value=value+1; 
62.                 tm.put(chs[i],value); 
63.             } 
64.             */  
65.         }  
66.         StringBuilder sb=new StringBuilder();  
67.   
68.         Set<Map.Entry<Character,Integer>> entrySet=tm.entrySet();  
69.         Iterator<Map.Entry<Character,Integer>> it=entrySet.iterator();  
70.   
71.         while(it.hasNext())  
72.         {  
73.             Map.Entry<Character,Integer> me=it.next();  
74.             Character ch=me.getKey();  
75.             Integer value=me.getValue();  
76.             sb.append(ch+"("+value+")");  
77.         }  
78.   
79.         return sb.toString();  
80.     }  
81. }  

九、集合(Map扩展)

[java]  view plain copy

1. /* 
2. Map扩展知识： 
3.  
4. Map集合被使用是因为具备映射关系。 
5.  
6. 1. 
7. "yureban" "01" "zhangsan" 
8. "yureban" "02" "lisi" 
9. "jiuyeban" "01" "wangwu" 
10. "jiuyeban" "02" "zhaoliu" 
11.  
12.  
13. 2. 
14. "yureban" Student("01" "zhangsan") 
15. "yureban" Student("02" "lisi") 
16. "jiuyeban" Student("01" "wangwu") 
17. "jiuyeban" Student("02" "zhaoliu") 
18.  
19.  
20. 一个学校有多个教室，每个教室有个名称。 
21.  
22. */  
23. import java.util.*;  
24. class Student  
25. {  
26.     private String id;  
27.     private String name;  
28.     Student(String id,String name)  
29.     {  
30.         this.id=id;  
31.         this.name=name;  
32.     }  
33.     public String toString()  
34.     {  
35.         return "学号："+id+"\t姓名："+name;  
36.     }  
37. }  
38. class MapDemo3   
39. {  
40.     public static void main(String[] args)   
41.     {  
42.           
43.         System.out.println("1.");  
44.   
45.         HashMap<String,String> yure=new HashMap<String,String>();  
46.           
47.         yure.put("0001","张三");  
48.         yure.put("0002","李四");  
49.   
50.         HashMap<String,String> jiuye=new HashMap<String,String>();  
51.           
52.         jiuye.put("0001","王五");  
53.         jiuye.put("0002","赵六");  
54.   
55.         HashMap<String,HashMap<String,String>> czbk=new HashMap<String,HashMap<String,String>>();  
56.         czbk.put("预热班",yure);  
57.         czbk.put("就业班",jiuye);  
58.   
59.         //遍历czbk集合。获取所有的教室  
60.         Iterator<String> it=czbk.keySet().iterator();  
61.         while(it.hasNext())  
62.         {  
63.             String roomName=it.next();  
64.             HashMap<String,String> room=czbk.get(roomName);  
65.   
66.             System.out.println(roomName);  
67.             getStudentInfo(room);  
68.         }  
69.   
70.         System.out.println("2.");  
71.         demo();  
72.     }  
73.     public static void demo()  
74.     {  
75.         HashMap<String,List<Student>> czbk=new HashMap<String,List<Student>>();  
76.         List<Student> yure=new ArrayList<Student>();  
77.         List<Student> jiuye=new ArrayList<Student>();  
78.   
79.         czbk.put("预热班",yure);  
80.         czbk.put("就业班",jiuye);  
81.   
82.         yure.add(new Student("0001","张三"));  
83.         yure.add(new Student("0002","李四"));  
84.   
85.         jiuye.add(new Student("0001","王五"));  
86.         jiuye.add(new Student("0002","赵六"));  
87.   
88.   
89.         Iterator<String> it=czbk.keySet().iterator();  
90.         while(it.hasNext())  
91.         {  
92.             String roomName=it.next();  
93.             List<Student> room=czbk.get(roomName);  
94.   
95.             System.out.println(roomName);  
96.             getInfos(room);  
97.         }  
98.     }  
99.     public static void getInfos(List<Student> list)  
100.     {  
101.         Iterator<Student> it=list.iterator();  
102.         while(it.hasNext())  
103.         {  
104.             Student s=it.next();  
105.             System.out.println(s);  
106.         }  
107.     }  
108.     public static void getStudentInfo(HashMap<String,String> roomMap)  
109.     {  
110.         Iterator<String> it=roomMap.keySet().iterator();  
111.         while(it.hasNext())  
112.         {  
113.             String id=it.next();  
114.             String name=roomMap.get(id);  
115.             System.out.println("学号："+id+"\t姓名："+name);  
116.         }  
117.     }  
118. }