map集合键值对存储，键值不重复，值可以重复

1. import java.util.HashMap;
2. import java.util.Hashtable;
3. import java.util.Iterator;
4. import java.util.LinkedHashMap;
5. import java.util.Map;
6. import java.util.TreeMap;
7. /**
8. * Map用于存储键值对，不允许键重复，值可以重复。
9. * （1）HashMap是一个最常用的Map，它根据键的hashCode值存储数据，根据键可以直接获取它的值，具有很快的访问速度。
10. * HashMap最多只允许一条记录的键为null，允许多条记录的值为null。
11. * HashMap不支持线程的同步，即任一时刻可以有多个线程同时写HashMap，可能会导致数据的不一致。
12. * 如果需要同步，可以用Collections.synchronizedMap(HashMap map)方法使HashMap具有同步的能力。
13. * （2）Hashtable与HashMap类似，不同的是：它不允许记录的键或者值为空；
14. * 它支持线程的同步，即任一时刻只有一个线程能写Hashtable，然而，这也导致了Hashtable在写入时会比较慢。
15. * （3）LinkedHashMap保存了记录的插入顺序，在用Iteraor遍历LinkedHashMap时，先得到的记录肯定是先插入的。
16. * 在遍历的时候会比HashMap慢。
17. * （4）TreeMap能够把它保存的记录根据键排序，默认是按升序排序，也可以指定排序的比较器。当用Iteraor遍历TreeMap时，
18. * 得到的记录是排过序的。
19. */
20. /**
21. * 演示各个Map的实现类
22. */
23. public class TestMap {
24. /**
25. * 初始化一个Map
26. * @param map
27. */
28. public static void init(Map map){
29. if (map != null){
30. String key = null;
31. for (int i=5; i>0; i--){
32. key = new Integer(i).toString() + ".0";
33. map.put(key, key.toString());
34. //Map中的键是不重复的，如果插入两个键值一样的记录，
35. //那么后插入的记录会覆盖先插入的记录
36. map.put(key, key.toString() + "0");         }
37. }
38. }
39. /**
40. * 输出一个Map
41. * @param map
42. */
43. public static void output(Map map){
44. if (map != null){
45. Object key = null;
46. Object value = null;
47. //使用迭代器遍历Map的键，根据键取值
48. Iterator it = map.keySet().iterator();
49. while (it.hasNext()){
50. key = it.next();
51. value = map.get(key);
52. System.out.println("key: " + key + "; value: " + value );
53. }
54. //或者使用迭代器遍历Map的记录Map.Entry
55. Map.Entry entry = null;
56. it = map.entrySet().iterator();
57. while (it.hasNext()){
58. //一个Map.Entry代表一条记录
59. entry = (Map.Entry)it.next();
60. //通过entry可以获得记录的键和值
61. System.out.println("key: " + entry.getKey() + "; value: " + entry.getValue());
62. }
63. }
64. }
65. /**
66. * 判断map是否包含某个键
67. * @param map
68. * @param key
69. * @return
70. */
71. public static boolean containsKey(Map map, Object key){
72. if (map != null){
73. return map.containsKey(key);
74. }
75. return false;
76. }
77. /**
78. * 判断map是否包含某个值
79. * @param map
80. * @param value
81. * @return
82. */
83. public static boolean containsValue(Map map, Object value){
84. if (map != null){
85. return map.containsValue(value);
86. }
87. return false;
88. }
89. /**
90. * 演示HashMap
91. */
92. public static void testHashMap(){
93. Map myMap = new HashMap();
94. init(myMap);
95. //HashMap的键可以为null
96. myMap.put(null,"ddd");
97. //HashMap的值可以为null
98. myMap.put("aaa", null);
99. output(myMap);
100. }
101. /**
102. * 演示Hashtable
103. */
104. public static void testHashtable(){
105. Map myMap = new Hashtable();
106. init(myMap);
107. //Hashtable的键不能为null
108. //myMap.put(null,"ddd");
109. //Hashtable的值不能为null
110. //myMap.put("aaa", null);
111. output(myMap);
112. }
113. /**
114. * 演示LinkedHashMap
115. */
116. public static void testLinkedHashMap(){
117. Map myMap = new LinkedHashMap();
118. init(myMap);
119. //LinkedHashMap的键可以为null
120. myMap.put(null,"ddd");
121. //LinkedHashMap的值可以为null
122. myMap.put("aaa", null);
123. output(myMap);
124. }
125. /**
126. * 演示TreeMap
127. */
128. public static void testTreeMap(){
129. Map myMap = new TreeMap();
130. init(myMap);
131. //TreeMap的键不能为null
132. //myMap.put(null,"ddd");
133. //TreeMap的值不能为null
134. //myMap.put("aaa", null);
135. output(myMap);
136. }
137. public static void main(String[] args) {
138. System.out.println("采用HashMap");
139. TestMap.testHashMap();
140. System.out.println("采用Hashtable");
141. TestMap.testHashtable();
142. System.out.println("采用LinkedHashMap");
143. TestMap.testLinkedHashMap();
144. System.out.println("采用TreeMap");
145. TestMap.testTreeMap();
146. Map myMap = new HashMap();
147. TestMap.init(myMap);
148. System.out.println("新初始化一个Map: myMap");
149. TestMap.output(myMap);
150. //清空Map
151. myMap.clear();
152. System.out.println("将myMap clear后，myMap空了么?  " + myMap.isEmpty());
153. TestMap.output(myMap);
154. myMap.put("aaa", "aaaa");
155. myMap.put("bbb", "bbbb");
156. //判断Map是否包含某键或者某值
157. System.out.println("myMap包含键aaa?  "+ TestMap.containsKey(myMap, "aaa"));
158. System.out.println("myMap包含值aaaa?  "+ TestMap.containsValue(myMap, "aaaa"));
159. //根据键删除Map中的记录
160. myMap.remove("aaa");
161. System.out.println("删除键aaa后，myMap包含键aaa?  "+ TestMap.containsKey(myMap, "aaa"));
162. //获取Map的记录数
163. System.out.println("myMap包含的记录数:  " + myMap.size());
164. }
165. }