Java：关于使用Map的一些知识

Map是JAVA中比较常用的存储类，下面来介绍一下它常用的方法：

遍历Map：

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

排序Map：

List list = new ArrayList(map.entrySet());
		Collections.sort(list, new Comparator() {
			public int compare(Object o1, Object o2) {
				Entry obj1 = (Entry) o1;
				Entry obj2 = (Entry) o2;
				// 比较Map中数值getValue()的大小:
				return ((Integer) (obj2.getValue()) - (Integer) (obj1
						.getValue()));
			}
		});

以下是完整的测试类：

public class TestMap {
	public static void main(String[] args) {
		HashMap<String, Integer> map = new HashMap<String, Integer>();
		map.put("1", 1);
		map.put("2", 2);
		map.put("7", 7);
		map.put("4", 4);
		map.put("3", 3);

		List list = new ArrayList(map.entrySet());
		Collections.sort(list, new Comparator() {
			public int compare(Object o1, Object o2) {
				Entry obj1 = (Entry) o1;
				Entry obj2 = (Entry) o2;
				// 比较Map中数值getValue()的大小:
				return ((Integer) (obj2.getValue()) - (Integer) (obj1
						.getValue()));
			}
		});

		// 遍历一下数据
		for (Iterator iter = list.iterator(); iter.hasNext();) {
			Entry element = (Entry) iter.next();
			Object strKey = element.getKey(); // 键值
			Object strValue = element.getValue(); // value值

			System.out.println(strValue);
		}
	}
}

打印结果：
7
4
3
2
1


如果按照保存插入顺序得到遍历的话，需要改用LinkedHashMap。

LinkedHashMap 是HashMap的一个子类，保存了记录的插入顺序，在用Iterator遍历LinkedHashMap时，先得到的记录肯定是先插入的.也可以在构造时用带参数，按照应用次数排序。

给一个例子：

import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;

public class TestMap {
	public static void main(String[] args) {
		HashMap<String, Integer> map = new HashMap<String, Integer>();
		map.put("1", 1);
		map.put("2", 2);
		map.put("7", 7);
		map.put("4", 4);
		map.put("3", 3);

		// 遍历一下数据
		System.out.println("=====HashMap=====");
		for (Iterator<String> it = map.keySet().iterator(); it.hasNext();) {
			Object key = it.next();
			System.out.println(key + "=" + map.get(key));
		}

		LinkedHashMap<String, Integer> map2 = new LinkedHashMap<String, Integer>();
		map2.put("1", 1);
		map2.put("2", 2);
		map2.put("7", 7);
		map2.put("4", 4);
		map2.put("3", 3);

		// 遍历一下数据
		System.out.println("=====LinkedHashMap=====");
		for (Iterator<String> it = map2.keySet().iterator(); it.hasNext();) {
			Object key = it.next();
			System.out.println(key + "=" + map2.get(key));
		}
	}
}

输出的结果：
=====HashMap=====
3=3
2=2
1=1
7=7
4=4
=====LinkedHashMap=====
1=1
2=2
7=7
4=4
3=3

可以看到HashMap遍历后，顺序与之前不一致，而采用LinkedHashMap的顺序是一致的。但LinkedHashMap在遍历的时候要比HashMap慢，不过有种情况例外：当HashMap容量很大，且实际数据较少的时候，遍历起来可能会比 LinkedHashMap慢，因为LinkedHashMap的遍历速度只和实际数据有关，和容量无关，而HashMap的遍历速度和他的容量有关。

补充点相关知识（源自百度百科）：

Map

　　 Map是一种把键对象和值对象进行关联的容器

　　一个值对象又可以是一个Map，依次类推，这样就可形成一个多级映射。对于键对象来说，像Set一样，一个Map容器中的键对象不允许重复，这是为了保持查找结果的一致性;如果有两个键对象一样，那你想得到那个键对象所对应的值对象时就有问题了，可能你得到的并不是你想的那个值对象，结果会造成混乱，所以键的唯一性很重要，也是符合集合的性质的。当然在使用过程中，某个键所对应的值对象可能会发生变化，这时会按照最后一次修改的值对象与键对应。对于值对象则没有唯一性的要求。你可以将任意多个键都映射到一个值对象上，这不会发生任何问题（不过对你的使用却可能会造成不便，你不知道你得到的到底是那一个键所对应的值对象）。Map有两种比较常用的实现：HashMap和TreeMap。HashMap也用到了哈希码的算法，以便快速查找一个键，TreeMap则是对键按序存放，因此它便有一些扩展的方法，比如firstKey(),lastKey()等，你还可以从TreeMap中指定一个范围以取得其子Map。键和值的关联很简单，用put(Object key,Object value)方法即可将一个键与一个值对象相关联。用get(Object key)可得到与此key对象所对应的值对象。Map的功能

　　ArrayList能让你用数字在一愕嘎对象序列里面进行选择，所以从某种意义上讲，它是将数字和对象关联起来。但是，如果你想根据其他条件在一个对象序列里面进行选择的话，那又该怎么做呢？栈就是一个例子。它的标准是“选取最后一个被压入栈的对象”。我们常用的术语map，dictionary，或associative array就是一种非常强大的，能在序列里面进行挑选的工具。从概念上讲，它看上去像是一个ArrayList，但它不用数字，而是用另一个对象来查找对象！这是一种至关重要的编程技巧。

　　这一概念在Java中表现为Map。put(Object key, Object value)方法会往Map里面加一个值，并且把这个值同键（你查找时所用的对象）联系起来。给出键之后，get(Object key)就会返回与之相关的值。你也可以用containsKey()和containsValue()测试Map是否包含有某个键或值。

　　Java标准类库里有好几种Map：HashMap，TreeMap，LinkedHashMap，WeakHashMap，以及IdentityHashMap。它们都实现了Map的基本接口，但是在行为方式方面有着明显的诧异。这些差异体现在，效率，持有和表示对象pair的顺序，持有对象的时间长短，以及如何决定键的相等性。

　　性能时Map所要面对的一个大问题。如果你知道get()时怎么工作的，你就会发觉（比方说）在ArrayList里面找对象会是相当慢的。而这正是HashMap的强项。它不是慢慢地一个个地找这个键，而是用了一种被称为hash code的特殊值来进行查找的。散列（hash）时一种算法，它会从目标对象当中提取一些信息，然后生成一个表示这个对象的“相对独特”的int。hashCode()是Object根类的方法，因此所有Java对象都能生成hash code。HashMap则利用对象的hashCode()来进行快速的查找。这样性能就有了急剧的提高。

　　Map（接口）：维持键－－值的关系（既pairs），这样就能用键来找值了。

　　HashMap*：基于hash表的实现。（用它来代替Hashtable。）提供时间恒定的插入与查询。在构造函数种可以设置hash表的capacity和load factor。可以通过构造函数来调节其性能。

　　LinkedHashMap(JDK 1.4)：很像HashMap，但是用Iterator进行遍历的时候，它会按插入顺序或最先使用的顺序（least-recently-used(LRU)order）进行访问。除了用Iterator外，其他情况下，只是比HashMap稍慢一点。用Iterator的情况下，由于是使用链表来保存内部顺序，因此速度会更快。

　　TreeMap：基于红黑树数据结构的实现。当你查看键或pair时，会发现它们时按顺序（根据Comparable或Comparator，我们过一会讲）排列的。TreeMap的特点时，你锁得到的时一个有序的Map。TreeMap是Map中唯一有subMap()方法的实现。这个方法能让你获取这个树中的一部分。

　　WeakHashMap：一个weak key的Map，是为某些特殊问题而设计的。它能让Map释放其所持有的对象。如果某个对象除了在Map当中充当键之外，在其他地方都没有其reference的话，那它将被当作垃圾回收。

　　IdentityHashMap(JDK 1.4)：一个用==，而不是equals()来比较键的hash map。不是为我们平常使用而设计的，是用来解决特殊问题的。

　　散列是往Map里存数据的常用算法。

　　SortedMap

　　SortedMap（只有TreeMap这一个实现）的键肯定是有序的，因此这个接口里面就有一些附加功能的方法了。

　　Comparator comparator()：返回Map所使用的comparator，如果是用Object内置的方法的话，则返回null。

　　Object firstKey()：返回第一个键。

　　Object lastKey()：返回最后一个键。

　　SortedMap subMap(fromKey, toKey)：返回这个Map的一个子集，其键从fromKey开始到toKey为止，包括前者，不包括后者。

　　SortedMap headMap(toKey)：返回这个Map的一愕嘎子集，其键均小于toKey。

　　SortedMap tailMap(fromKey)：返回这个Map的一个子集，其键均大于等于fromKey。

　　pair是按key的顺序存储的，由于TreeMap有顺序的概念，因此“位置”是有意义的，所以你可以去获取它的第一个和最后一个元素，以及它的子集。

　　LinkedHashMap

　　为了提高速度，LinkedHashMap对所有东西都做了hash，而且遍历的时候（println()会遍历整个Map，所以你能看到这个过程）还会按插入顺序返回pair。此外，你还可以在LinkedHashMap的构造函数里面进行配置，让它使用基于访问的LRU（least-recently-used）算法，这样还没被访问过的元素（同时也是要删除的候选对象）就会出现在队列的最前头。这样，为节省资源而写一个定时清理的程序就变得很简单了。