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，因为它正式为快速查询设计的。