java的map

Map是一种把键对象和值对象进行关联的容器，而一个值对象又可以是一个Map，依次类推，这样就可形成一个多级映射。

这里有详细的论述http://www.oracle.com/technetwork/cn/articles/maps1-100947-zhs.html

map.put("x","y");
map.get("x") == y
就是一一映射关系，每个key对应一个value 知道了key也就知道了value

对于键对象来说，像Set 一样，一个Map容器中的键对象不允许重复，为了保持查找结果的一致性;如果有两个键对象一样，键对象对应的值对象时就无法确定了，造成混乱，所以键的唯一性很重要。当然在使用过程中，某个键所对应的值对象可能会发生变 化，这时会按照最后一次修改的值对象与键对应。

值对象没有唯一性的要求。你可以将任意多个键都映射到一个值对象上，这不会发生任何问题（不过使用上可能会造成不便，你不知道你得到的到底是那一个键所对应的值对象）。
Map有两种比较常用的实现：HashMap和TreeMap，WeakMap。

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

HashMap 用哈希码快速定位一个键，但是元素存储无序。注意：其put（）函数支持null，而如果原位置上有值，则替换为新值后，并返回旧值。其返回过程确定的位置正是get（）函数的实现。参见http://blog.csdn.net/longshenlmj/article/details/17077869

而TreeMap则是对键按序存放，因此有扩展的方法，比如firstKey(),lastKey() 等，你还可以从TreeMap中指定一个范围以取得其子Map。

键和值的关联很简单，用put(Object key,Object value)方法即可将一个键与一个值对象相关联。用get(Object key)可得到与此key对象所对应的值对象，WeakMap这个用于内存自动释放的。

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

官方的非官方的Map事先有好几百个(hibernate、spring、apache等都有实现)。官方的主要用到的就三大类：HashMap(最常见的，内部无序的)、TreeMap(排过序的)及WeakMap（这个用于内存自动释放的）；还有一类是多线程时使用的并发Map。
如需查看具体Map子类。装个Eclipse，ctrl+shit+t输入Map后，在Map的class名那里按ctrl+T可以查看到Map所有的实现类。

使用时，都用HasMap等实现Map接口的类
创建：Map<String,String> map = new HashMap<String,String>();
插入元素：map.put("1","a");
移除元素: map.remove("1");
清空: map.clear();
Map map=new HashMap();
map.put("name","张三");
System.out.print((String)map.get("name"));

循环输出映射：

while(itr.hasNext()){
String key=(String)itr.next();
String value=(String)map.get(key);
System.out.println("key=="+key+",value=="+value);
}

输出还有其它用法：把map看成一个Map.Entry的Set,那么每个Map.Entry就是一个键--值对,遍历这个Set，直接从中获取key和value。

Map map = new HashMap();
Iterator it = map.entrySet().iterator();
while (it.hasNext()) {
Map.Entry entry = (Map.Entry) it.next();
Object key = entry.getKey();
Object value = entry.getValue();

 System.out.println(“key”+key+“：value”+value）；
}

其中，中间生成一个set

// Get a set of the entries
Set set = map.entrySet();
// Get an iterator
Iterator i = set.iterator();
// Display elements

JDK1.5中,应用新特性For-Each循环:
Map m = new HashMap();
for(Object o : map.keySet()){
map.get(o);
}

返回的 set 中的每个元素都是一个 Map.Entry 类型。

private Hashtable<String, String> emails = new Hashtable<String, String>();

//方法一: 用entrySet()
Iterator it = emails.entrySet().iterator();
while(it.hasNext()){
Map.Entry m=(Map.Entry)it.next();
logger.info("email-" + m.getKey() + ":" + m.getValue());
}

// 方法二：jdk1.5支持，用entrySet()和For-Each循环()
for (Map.Entry<String, String> m : emails.entrySet()) {

logger.info("email-" + m.getKey() + ":" + m.getValue());
}

// 方法三：用keySet()
Iterator it = emails.keySet().iterator();
while (it.hasNext()){
String key;
key=(String)it.next();
logger.info("email-" + key + ":" + emails.get(key));
}

// 方法五：jdk1.5支持，用keySEt()和For-Each循环

for(Object m: emails.keySet()){
logger.info("email-" + m+ ":" + emails.get(m));
}

另外 我们可以先把hashMap 转为集合Collection，再迭代输出，不过得到的对象

Map aa = new HashMap();
aa.put("tmp1", new Object()); //追加 替换用同样的函数.
aa.remove("temp1"); //删除
for (Iterator i = aa.values().iterator(); i.hasNext(); ) {
Object temp = i.next();
} //遍历

例子，包含TreeSet的元素内部排序的

public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
HashMap<Object,Object> hash = new HashMap<Object,Object>();
TreeMap<Object,Object> treeMap = new TreeMap<Object,Object>();
list.add("a");
list.add("b");
list.add("c");

hash.put(3, 3);
hash.put(4, 4);
hash.put(5, 5);
hash.put(6, 6);
hash.put(1, 1);
hash.put(2, 2);

treeMap.put(1, 1);
treeMap.put(2, 2);
treeMap.put(3, 3);
treeMap.put(4, 4);
treeMap.put(5, 5);
treeMap.put(6, 6);

//list遍历
for(String m: list){
System.out.println(m);
}
// hashmap entrySet() 遍历
for(Map.Entry<Object,Object> m: hash.entrySet()){
System.out.println(m.getKey()+"---"+m.getValue());
}
//hashmap keySet() 遍历
for(Object m: hash.keySet()){
System.out.println(m+"---"+hash.get(m));
}
// treemap keySet()遍历
for(Object m: treeMap.keySet()){
System.out.println(m+"---"+treeMap.get(m));
}
}