Java学习笔记-----集合Map

Map
    Map用于保存具有映射关系的数据，Key-Value形式。
Map把所有的Key放一起，它们组成了Set集合（无序，不可重复），Value放一起，类似于List元素可以重复，
每个元素可以哦根据索引查找，只是Map中的索引是另一个对象作为索引。
Map常用的方法：
 1).void clear() 
          从此映射中移除所有映射关系（可选操作）。 
 2).boolean containsKey(Object key) 
          如果此映射包含指定键的映射关系，则返回 true。 
 3).boolean containsValue(Object value) 
          如果此映射将一个或多个键映射到指定值，则返回 true。 
 4).Set<Map.Entry<K,V>> entrySet() 
          返回此映射中包含的映射关系的 Set 视图。 
 5).boolean equals(Object o) 
          比较指定的对象与此映射是否相等。 
 6).V get(Object key) 
          返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。 
 7).int hashCode() 
          返回此映射的哈希码值。 
 8).boolean isEmpty() 
          如果此映射未包含键-值映射关系，则返回 true。 
 9).Set<K> keySet() 
          返回此映射中包含的键的 Set 视图。 
 10).V put(K key, V value) 
          将指定的值与此映射中的指定键关联（可选操作）。 
 11).void putAll(Map<? extends K,? extends V> m) 
          从指定映射中将所有映射关系复制到此映射中（可选操作）。 
 12).V remove(Object key) 
          如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。 
 13).int size() 
          返回此映射中的键-值映射关系数。 
 14).Collection<V> values() 
          返回此映射中包含的值的 Collection 视图。 

2.HashMap 和 Hashtable 实现类
  HashMap 和 Hashtable 存在两点典型区别：
	1).Hashtable是一个线程安全的Map实现，但是HashMap是线程不安全的实现，所以HashMap性能更高点；
但如果有多个线程访问同一个Map对象时，使用Hashtable实现类会更好。
	2).Hashtable不允许使用null座位key和value，但是HashMap可以使用null作为key或value.
判断两个value相等的标准是：只要两个对象通过equals()方法比较返回为true即可。

3.LinkedHashMap 实现类
  LinkedHashMap迭代顺序与key-value对的插入顺序保持一致。
eg:
import java.util.LinkedHashMap;

public class LinkedHashMapTest {
	public static void main(String[] args) {
		LinkedHashMap score = new LinkedHashMap();
		score.put("语文", 90);
		score.put("数学", 80);
		score.put("英语", 95);
		// 遍历
		for (Object key : score.keySet()) {
			System.out.println(key + "------->" + score.get(key));
		}
	}
}
运行结果：
		语文------->90
		数学------->80
		英语------->95

4.SortedMap 接口和 TreeMap 实现类
  TreeMap可以保证所有的key-value对处于有序状态。TreeMap也有两种排序方式：
	1).自然排序：TreeMap的 所有key必须实现Comparable接口，而且所有的key应该是同一个类的对象，
	   否则会抛出ClassCaseException异常。
	2).定制排序：创建TreeMap时，传入一个Comparator对象，改对象负责对TreeMap中所有的key进行排序。
	   采用定制排序时，不要求key实现Comparable接口。
TreeMap常用方法：
	1).Map.Entry<K,V> ceilingEntry(K key) 
			  返回一个键-值映射关系，它与大于等于给定键的最小键关联；如果不存在这样的键，则返回 null。 
	2).K ceilingKey(K key) 
			  返回大于等于给定键的最小键；如果不存在这样的键，则返回 null。 
	3).void clear() 
			  从此映射中移除所有映射关系。 
	4).Object clone() 
			  返回此 TreeMap 实例的浅表副本。 
	5).Comparator<? super K> comparator() 
			  返回对此映射中的键进行排序的比较器；如果此映射使用键的自然顺序，则返回 null。 
	6).boolean containsKey(Object key) 
			  如果此映射包含指定键的映射关系，则返回 true。 
	7).boolean containsValue(Object value) 
			  如果此映射为指定值映射一个或多个键，则返回 true。 
	8).NavigableSet<K> descendingKeySet() 
			  返回此映射中所包含键的逆序 NavigableSet 视图。 
	9).NavigableMap<K,V> descendingMap() 
			  返回此映射中所包含映射关系的逆序视图。 
	10).Set<Map.Entry<K,V>> entrySet() 
			  返回此映射中包含的映射关系的 Set 视图。 
	11).Map.Entry<K,V> firstEntry() 
			  返回一个与此映射中的最小键关联的键-值映射关系；如果映射为空，则返回 null。 
	12).K firstKey() 
			  返回此映射中当前第一个（最低）键。 
	13).Map.Entry<K,V> floorEntry(K key) 
			  返回一个键-值映射关系，它与小于等于给定键的最大键关联；如果不存在这样的键，则返回 null。 
	14).K floorKey(K key) 
			  返回小于等于给定键的最大键；如果不存在这样的键，则返回 null。 
	15).V get(Object key) 
			  返回指定键所映射的值，如果对于该键而言，此映射不包含任何映射关系，则返回 null。 
	16).SortedMap<K,V> headMap(K toKey) 
			  返回此映射的部分视图，其键值严格小于 toKey。 
	17).NavigableMap<K,V> headMap(K toKey, boolean inclusive) 
			  返回此映射的部分视图，其键小于（或等于，如果 inclusive 为 true）toKey。 
	18).Map.Entry<K,V> higherEntry(K key) 
			  返回一个键-值映射关系，它与严格大于给定键的最小键关联；如果不存在这样的键，则返回 null。 
	19).K higherKey(K key) 
			  返回严格大于给定键的最小键；如果不存在这样的键，则返回 null。 
	20).Set<K> keySet() 
			  返回此映射包含的键的 Set 视图。 
	21).Map.Entry<K,V> lastEntry() 
			  返回与此映射中的最大键关联的键-值映射关系；如果映射为空，则返回 null。 
	22).K lastKey() 
			  返回映射中当前最后一个（最高）键。 
	23).Map.Entry<K,V> lowerEntry(K key) 
			  返回一个键-值映射关系，它与严格小于给定键的最大键关联；如果不存在这样的键，则返回 null。 
	24).K lowerKey(K key) 
			  返回严格小于给定键的最大键；如果不存在这样的键，则返回 null。 
	25).NavigableSet<K> navigableKeySet() 
			  返回此映射中所包含键的 NavigableSet 视图。 
	26).Map.Entry<K,V> pollFirstEntry() 
			  移除并返回与此映射中的最小键关联的键-值映射关系；如果映射为空，则返回 null。 
	27).Map.Entry<K,V> pollLastEntry() 
			  移除并返回与此映射中的最大键关联的键-值映射关系；如果映射为空，则返回 null。 
	28).V put(K key, V value) 
			  将指定值与此映射中的指定键进行关联。 
	29).void putAll(Map<? extends K,? extends V> map) 
			  将指定映射中的所有映射关系复制到此映射中。 
	30).V remove(Object key) 
			  如果此 TreeMap 中存在该键的映射关系，则将其删除。 
	31).int size() 
			  返回此映射中的键-值映射关系数。 
	32).NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) 
			  返回此映射的部分视图，其键的范围从 fromKey 到 toKey。 
	33).SortedMap<K,V> subMap(K fromKey, K toKey) 
			  返回此映射的部分视图，其键值的范围从 fromKey（包括）到 toKey（不包括）。 
	34).SortedMap<K,V> tailMap(K fromKey) 
			  返回此映射的部分视图，其键大于等于 fromKey。 
	35).NavigableMap<K,V> tailMap(K fromKey, boolean inclusive) 
			  返回此映射的部分视图，其键大于（或等于，如果 inclusive 为 true）fromKey。 
	36).Collection<V> values() 
			  返回此映射包含的值的 Collection 视图。 
eg：
import java.util.TreeMap;

class R implements Comparable {
	int count;

	public R(int count) {
		this.count = count;
	}

	public String toString() {
		return "R[count:" + count + "]";
	}

	// 根据count来判断两个对象是否相等
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj != null && obj.getClass() == R.class) {
			R r = (R) obj;
			return r.count == this.count;
		}
		return false;
	}

	// 根据count属性来判断两个对象的大小
	public int compareTo(Object obj) {
		R r = (R) obj;
		return count > r.count ? 1 : count < r.count - 1 ? -1 : 0;
	}
}

public class TreeMapTest {
	public static void main(String[] args) {
		TreeMap tm = new TreeMap();
		tm.put(new R(3), "Abook");
		tm.put(new R(-5), "Bbook");
		tm.put(new R(9), "Cbook");
		System.out.println(tm);
		// 返回第一个Entry对象
		System.out.println(tm.firstEntry());
		// 返回最后一个key值
		System.out.println(tm.lastKey());
		// 返回比new R(2)大的最小Key值
		System.out.println(tm.higherKey(new R(2)));
		// 返回比new R(2)小的最大Key-valus值
		System.out.println(tm.lowerKey(new R(2)));
		// 返回该TreeMap的子TreeMap
		System.out.println(tm.subMap(new R(-1), new R(4)));
	}
}

5. WeakHashMap 实现类：
  WeakHashMap与HashMap类似。区别在于HashMap的key保留对实际对象的强引用，这意味着只要改HashMap
对象不被销毁，该HashMap的所有key所引用的对象不会被垃圾回收，HashMap也不会自动删除这些key所对应
的key-value对；但WeakHashMap的key值保留对实际对象的弱引用，这就意味WeakHashMap对象的key所引用的
对象没有被其它强引用变量所引用，则这些key所用的对象可能被垃圾回收，WeakHashMap也可能自动删除这些
key所对应的key-value对。
eg:
import java.util.WeakHashMap;

public class WeakHashMapTest {
	public static void main(String[] args) {
		WeakHashMap whm=new WeakHashMap();
		whm.put(new String("语文"), new String("良好"));
		whm.put(new String("数学"), new String("优秀"));
		whm.put(new String("英语"), new String("及格"));
		// 添加一个系统缓存的字符串对象
		whm.put("Java", new String("中等"));
		System.out.println(whm);
		// 通知系统回收
		System.gc();
		System.runFinalization();
		System.out.println(whm);
	}
}
运行结果：
{Java=中等, 数学=优秀, 英语=及格, 语文=良好}
{Java=中等}

6. EnumMap 实现类
  EnumMap 是一个与枚举类一起使用的Map实现，EnumMap中的所有Key必须是当个枚举类的枚举值。创建EnumMap时
必须显式或者隐式指定他对应的枚举类。
  EnumMap 在内部数据形式保存，实现形式紧凑、高效。
  EnumMap 根据key自然排序来维护key-value对的顺序，当程序通过keySet()、entrySet()、values()等方法遍历可以看到。
  EnumMap 不允许使用null作为key，但允许使用null作为value值。
eg:
import java.util.EnumMap;

enum Season1 {
	SPRING, SUNMER, FALL, WINTER
}

public class EnumMapTest {
	public static void main(String[] args) {
		EnumMap enumMap = new EnumMap(Season1.class);
		enumMap.put(Season1.SUNMER, "夏日炎炎");
		enumMap.put(Season1.SPRING, "春暖花开");
		System.out.println(enumMap);
	}
}
运行结果：
{SPRING=春暖花开, SUNMER=夏日炎炎}

7.各Map实现类性能分析：
TreeMap无需专门进行排序操作，但是HashMap和Hashtable慢。通常程序应该多考虑用HashMap，因为它正式为快速查询设计的。