Map集合的特点

map集合：该集合存储键值对。一对一对的往里存。而且要保证键的唯一性。

1，添加

put(K key, V value) 
将指定值与此映射中的指定键进行关联。
putAll(Map<? extends K,? extends V> map) 
将指定映射中的所有映射关系复制到此映射中。

2，删除   

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

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

3，判断

containsKey(Object key) 
如果此映射包含指定键的映射关系，则返回 true。

containsValue(Object value) 
  如果此映射将一个或多个键映射到指定值，则返回 true。

4，获取

get(Object key) 
返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。

values() 
返回此映射中包含的值的 Collection 视图。

entrySet() 
返回此映射中包含的映射关系的 Set 视图

Hashtable：底层是哈希表数据结构，不可以存入null键null值，该集合是线程同步的。

HashMap：底层是哈希表结构，可以存入null键null值，该集合是不同步的。除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。

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

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

源码应用：

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


public class MapDemo {
 public static void main(String[] args) {
  HashMap<MapClass, String> hm = new HashMap<MapClass, String>();
  hm.put(new MapClass("1hao", 19), "beijing");
  hm.put(new MapClass("2hao", 14), "shagnhai");
  hm.put(new MapClass("6hao", 15), "tianjin");
  hm.put(new MapClass("4hao", 17), "guangxi");
  
  
  Set<MapClass> s = hm.keySet();   //这是第一种方式枚举hashMap集合
  Iterator<MapClass> it = s.iterator();
  while(it.hasNext()){
   MapClass md = it.next();
   System.out.println(md + ":" + hm.get(md));
  }
  
  System.out.println();
  
  Set<Map.Entry<MapClass,String>> ss = hm.entrySet();        //这是第二种方式枚举hashMap
  Iterator<Map.Entry<MapClass,String>> it2 = ss.iterator();
  
  while(it2.hasNext()){
   Map.Entry<MapClass,String> me = it2.next();
   System.out.println(me.getKey() + "..." + me.getValue());
  }
  //通过输出数据可以看出 hashMap是无序的
  
  TreeMap<MapClass, String> tm = new TreeMap<MapClass, String>();
  tm.put(new MapClass("1hao", 19), "beijing");
  tm.put(new MapClass("2hao", 20), "shagnhai");
  tm.put(new MapClass("6hao", 15), "tianjin");
  tm.put(new MapClass("4hao", 17), "guangxi");     
  
  System.out.println();
  
  Set<MapClass> sss = tm.keySet();   //TreeMap集合里面元素枚举方法是跟HashMap一样的
  Iterator<MapClass> it3 = sss.iterator();
  while(it3.hasNext()){
   MapClass md = it3.next();
   System.out.println(md + ":" + tm.get(md));
  }
  //通过输出数据可以看出TreeMap是有序的，可以通过实现Comparable接口中的compareTo方法进行排序。
  
  
 }
}
 


class MapClass implements Comparable<MapClass>{
 private String name;
 private int age;
 public MapClass(String name,int age) {
  this.name = name;
  this.age = age;
 }
 
 public String getName(){
  return name;
 }
 public int getAge(){
  return age;
 }

 public int compareTo(MapClass o) {
  int num = this.getAge()>o.getAge() ? 1 : (this.getAge()== o.getAge()? 0:-1);
  if (num == 0)
   num = this.getName().compareTo(o.getName());
  return num;
 }
 
 public int hashCode() {
  return name.hashCode() + age*30;
 }

 public boolean equals(MapClass mc) {
  return this.getName().equals(mc.getName()) && this.getAge() == mc.getAge();
 }
 public String toString(){
  return name + " ... " + age;
 }

}