Map用于保存具有映射关系的数据，因此Map集合里保存着两组值，一组用于保存Map里的key，另一组用于保存Map里的value，key和value都可以是任何应用类型的数据。Map的key不允许重复，即同一个Map对象任何两个key通过equals()方法比较总是返回true。

Map里的所有key就放在一起，它们就组成一个Set集合（所以key没有顺序，key与key之间不能重复），实际上Map确实包含一个keySet()方法，用于返回Map里所有key组成的Set集合。
不仅如此，Map里key集和Set集合元素的存储形式也很像，Map子类和Set子类在名字上也很像，比如Set接口中有HashSet、LinkedSet、sorted接口、TreeSet、EnumSet等子接口和实现类，而Map接口下则有HashMap、LinkedHashMap、SortedMap接口、TreeMap、EnumMap等子接口和实现类。Map的这些实现类和子接口中key集的存储形式和对应的Set集合中元素的存储形式相同。
如果把Map里的所有value放在一起来看，它们又非常类似一个List：元素与元素之间可以重复，每个元素可以根据索引来查找，只是Map中的索引不在使用整数值，而是以另一个对象作为索引。，因此Map有时也成为字典或关联数组。

★void clear():删除该Map集合中的所有key-value对。
★boolean containsKey(Object key):查询Map中的是否包含指定的key，如果半酣则返回true。
★boolean containsValue(Object value):查询Map中是否包含一个或多个value，如果包含则返回true。
★Set entrySet():返回Map中包含的key-value对所组成的Set集合，每个集合都是Map.Entry(Entry是Map的内部类)对象。
★Object get(Object key):返回key所对应的value；如果Map中不包含该key，则返回null。
★boolean isEmpty():查询该Map是否为空，如果为空则返回true。
★Set keySet():返回该Map中所有key组成的Set集合。
★Object put(Object key,Object value):添加一个key-value对，如果当前Map中已经有一个与该key相等的key-value对，则新的key-value对会覆盖原来的key-value对，并返回被覆盖的value。
★void putAll(Map m):将指定Map中的key-value对复制到本Map中。
★Object remove(Object key):删除指定的key所对应的key-value对，返回被删除的key所关联的value，如果该key不存在，则返回null。
★boolean remove(Object key,Object value):Java 8新增的方法，删除指定的key、value所对应的key-value对。如果成功从该Map中成功删除该key-value对，则返回true，否则返回false。
★int size():返回该Map种key-value对的个数。
★Collection values():返回该Map种所有value值组成的Collection。
Map接口提供了大量的实现类，典型实现如HashMap和Hashtable等、HashMap的子类LinkedHashMap,还有SortedMap子接口和该接口的实现类TreeMap，以及WeakHashMap、IdentityHashMap等。
Map中包含一个内部类Entry，该类封装了一个key-value对。Entry包含三个方法：
1、Object getKey():返回该Entry里所包含的key值。
2、Object getValue():返回该Entry里所包含的value值。
3、Object setValue(V value):设置该Entry里包含的value值，并返回新的value值。

import java.util.HashMap;
import java.util.Map;
public class MapTest 
{
	public static void main(String[] args) 
	{
		var map=new HashMap();
		//成对放入多个key-value对
		map.put("疯狂Java讲义",109);
		map.put("疯狂iOS讲义",10);
		map.put("疯狂Ajax讲义",79);
		map.put("轻量级Java EE企业应用实战",99);
		//多次放入重复的key时，新的value会覆盖原来的value
		System.out.println(map.put("疯狂iOS讲义",99));//10

		System.out.println(map);//{疯狂Ajax讲义=79, 疯狂iOS讲义=99, 轻量级Java EE企业应用实战=99, 疯狂Java讲义=109}

		//判断是否包含指定key
		System.out.println("判断是否包含值为 "疯狂iOS讲义"的key:"+map.containsKey("疯狂iOS讲义"));//true
		//判断是否包含指定的value
		System.out.println("是否包含值为99的value:"+map.containsValue(99));//true
		
		//获取Map集合的所有的key组成的集合，通过遍历key来实现遍历所有的key-value对
		System.out.println(map.keySet());
		for(var key:map.keySet())
		{
			System.out.println(key+"-->"+map.get(key));
		}

		//根据key来删除key-value对
		map.remove("疯狂Ajax讲义");
		System.out.println(map);//{疯狂iOS讲义=99, 轻量级Java EE企业应用实战=99, 疯狂Java讲义=109}

	}
}
---------- 运行Java捕获输出窗 ----------
10
{疯狂Ajax讲义=79, 疯狂iOS讲义=99, 轻量级Java EE企业应用实战=99, 疯狂Java讲义=109}
判断是否包含值为 "疯狂iOS讲义"的key:true
是否包含值为99的value:true
[疯狂Ajax讲义, 疯狂iOS讲义, 轻量级Java EE企业应用实战, 疯狂Java讲义]
疯狂Ajax讲义-->79
疯狂iOS讲义-->99
轻量级Java EE企业应用实战-->99
疯狂Java讲义-->109
{疯狂iOS讲义=99, 轻量级Java EE企业应用实战=99, 疯狂Java讲义=109}

输出完成 (耗时 0 秒) - 正常终止

HashMap重写了toString()方法，实际上所有的Map都重写了toString()方法，调用Map对象的toString()方法总是会返回如下格式的字符串：{key1=value1,key2=value2...}

二、Java 8 为Map新增的方法

Java 8除了为Map增加了remove(Object key,Object value)默认的方法之外，还增加了以下方法。

方法	描述
Object compute(object key,BiFunction remappingFunction)	该方法使用remappingFunction根据原key-value对计算一个新的value。只要新的value不为null，就是用新的value覆盖原来的value；如果原value不为null，但新的value为null，则删除原key-value对；如果原value、新value同时为null，那么该方法不改变任何key-value对
Object computeIfAbsent(object key,BiFunction remappingFunction)	如果传给该方法的key参数在Map中对应的value为null，则使用mappingFunction根据key计算一个新的结果，如果计算结果不为null，则用计算结果覆盖原来的value。如果原Map不包含该key，那么该方法可能会添加一组key-value对
Object computeIfPresent(Object key,object key,BiFunction remappingFunction)	如果传给该方法的key参数在Map中对应的value不为null，则使mappingFunction根据key、value计算一个新的结果，如果计算结果不为null，则用计算结果覆盖原来的value。如果计算结果为null，则删除原key-value对
forEach(BiConsumer action)	Java 8为Map新增的一个遍历key-value对的方法，通过该方法可以更加简洁的遍历map的key-value对
Object getOrDefault(Object key,V defaultValue)	获取指定key对应的value，如果该key不存在，则返回defaultValue
Object merge(Object key,Object value,BiFunction remappingFunction)	现根据key参数获取该Map对应的value。如果value为null，则直接用传入的value覆盖原有value（在这种情况下，可能要添加一组key-value对）；如果获取的value不为null，则使用remappingFunction根据根据原value、新value计算一个新的结果，并用该结果去覆盖原来的value
Object putIfAbsent(Object key,Object value)	该方法会自动检测指定key对应的value是否为null，如果为null，则用新value值代替原来的value
Object replace(Object key, Object value)	将map中指定key对应的value替换成新的value。与传统put()方法不同，该方法不可能添加新的key-value对。如果尝试替换的key在原Map中不存在，直接返回null
boolean replace(K key,V oldValue,V newValue)	将Map中指定的key-value对的value替换成新的value。如果在Map中找到key-value对，则执行操作，并返回true，否则返回false
replaceAll(BiFunction function)	该方法使用BiFunction对原key-value对执行计算，并将计算结果作为该key-vlaue对的value

Java 8新增用法示例：

import java.util.HashMap;
public class HashMapTest2 
{
	public static void main(String[] args) 
	{
		var map=new HashMap();
		//成对放入多个key-value对
		map.put("疯狂Java讲义",109);
		map.put("疯狂iOS讲义",99);
		map.put("疯狂Ajax讲义",79);

		//尝试替换key为"疯狂XML讲义"的value，由于原Map中没有对应的key
		//因此Map没有改变，不会添加新的key-value对
		map.replace("疯狂XML讲义",66);
		System.out.println(map);//{疯狂Ajax讲义=79, 疯狂iOS讲义=99, 疯狂Java讲义=109}

		//使用原value与传入参数计算新的结果覆盖原有的value
		map.merge("疯狂iOS讲义",10,
			(oldVal,newVal)->(Integer)oldVal+(Integer)newVal);
			System.out.println(map);//{疯狂Ajax讲义=79, 疯狂iOS讲义=109, 疯狂Java讲义=109}
			
		//当key为"Java"对应的value为null（或不存在）时，使用计算结果作为新的value
		map.computeIfAbsent("Java",key->((String)key).length());
		System.out.println(map);//{Java=4, 疯狂Ajax讲义=79, 疯狂iOS讲义=109, 疯狂Java讲义=109}
		map.computeIfPresent("Java",(key,value)->(Integer)value+((String)key).length());
		System.out.println(map);//{Java=8, 疯狂Ajax讲义=79, 疯狂iOS讲义=109, 疯狂Java讲义=109}
	}
}

三、改进的HashMap和Hashtable实现类

HashMap和Hashtable都是Map接口的典型实现类，它们之间的关系类似于ArrayList和Vector的关系：Hashtable是一个古老的Map实现类，包含了了两个比较繁琐的方法，即elements()和keys()。但是尽量减少使用Hashtable。
Java 8改进了HashMap的实现，使用HashMap存在key冲突时依然具有较好的性能。
此外Hashtable和HashMap存在两个典型的区别：
1、Hashtable是一个线程安全的Map实现类，但HashMap是线程不安全的实现，所以HashMap比Hashtable的性能高一点；但如果出现多个线程同时访问一个Map对象时，使用Hashtable类会更好。
2、Hashtable不允许使用null作为key和value，如果试图把null放入Hashtable中，将会引发NullPointerException异常；但HashMap允许使用null作为key或value。

3.1 null值作为HashMap的key、value情形

由于HashMap里key不能重复，所以HashMap最多只有一个key-value对的key为null，但可以有多个key-value对的value为null。下面示范null值作为HashMap的key和value情形。

import java.util.HashMap;
public class NullInHashMap 
{
	public static void main(String[] args) 
	{
		var hm=new HashMap();
		//试图将两个key-value对放入HashMap中
		hm.put(null,null);
		hm.put(null,null);//此处无法将key-value对放入，因为Map中已经有一个key-value对为null
		//将一个value为null的值key-value放入到HashMap中
		hm.put("a",null);
		System.out.println(hm);//{null=null, a=null}
	}
}

3.2 HashMap和Hashtable存储对象必须实现hashCode()和equals()方法

HashMap和Hashtable不能保证key-value对的顺序。HashMap和Hashtable判断两个对象相等标准：两个key通过equals()方法返回true，两个key的HashCode值也要相同。
HashMap和Hashtable独有的方法：
containsValue()：用于判断是否包含指定的value。HashMap和Hashtable判断两个value相等的标准：只要两个对象通过equals()方法比较返回true。

import java.util.Hashtable;
class A
{
	int count;
	public A(int count)
	{
		this.count=count;
	}
	//根据count判断两个对象是否相等
	@Override
	public boolean equals(Object obj)
	{
		if(this==obj)
			return true;
		else if(obj!=null&&obj.getClass()==A.class)
		{
			var r=(A)obj;
			return r.count==this.count;
		}
		else
			return true;
	}
	//根据count值计算hashCode值
	@Override
	public int hashCode()
	{
		return this.count;
	}
}
class B
{
	//重写equals()方法，B对象与任何对象通过该方法比较都返回true
	@Override
	public boolean equals(Object obj)
	{
		return true;
	}
}
public class HashtableTest
{
	public static void main(String[] args)
	{
		var ht=new Hashtable();
		ht.put(new A(60000),"疯狂Java讲义");
		ht.put(new A(87563),"轻量级Java EE企业应用实战");
		ht.put(new A(1232),new B());
		System.out.println(ht);//{A@ea60=疯狂Java讲义, A@1560b=轻量级Java EE企业应用实战, A@4d0=B@a09ee92}

		//只要两个对象通过equals()方法比较返回true
		//Hashtable就认为它们有相等的value
		//由于Hashtable中有一个B对象，它与任何对象通过equals()方法比较都返回true
		System.out.println(ht.containsValue("测试字符集"));//true

		//只要两个A对象的count相等，它们通过equals()方法比较返回true，且hashCode值相等
		//Hashtable即认为它们有相同的key
		System.out.println(ht.containsKey(new A(87563)));//true

		//B对象为重写hashCode()方法，因此两个B对象尽管通过equals()比较返回true，但HashCode值
		//不相等，Java为将它们认为是不同的key值。
		System.out.println(ht.containsKey(new B()));//false

		//删除元素
		System.out.println(ht.remove(new A(1232)));//B@a09ee92
		System.out.println(ht.remove(new A(1222)));//null
		System.out.println(ht);//{A@ea60=疯狂Java讲义, A@1560b=轻量级Java EE企业应用实战}
	}
}

当使用自定义类作为HashMap和Hashtable的key时，在重写该类的equals()和hashCode()方法时，要保证两个方法的判断结果一致——当两个key通过equals()方法返回true时，两个key通过hashCode()返回的HashCode值也应该相同。

3.3 尽量不要修改可变对象作为HashMap和Hashtable的key

如果使用可变对象作为HashMap和Hashtable的key，并且修改了作为的key的对象，则也可能出现HashSet类似的情形：程序无法准确访问到Map中修改过的key。

import java.util.HashMap;
public class HashMapErrorTest
{
	public static void main(String[] args)
	{
		var hm=new HashMap();
		//此处的A类与上一个程序中A类是同一个类
		hm.put(new A(60000),"疯狂Java讲义");
		hm.put(new A(87563),"轻量级Java EE企业应用开发实战");
		System.out.println(hm);//{A@ea60=疯狂Java讲义, A@1560b=轻量级Java EE企业应用开发实战}
		
		//获取HashMap的key，value的Iterator迭代器
		//hm.keySet()返回key值所组成的HashSet集合
		var it=hm.keySet().iterator();
		//修改第一个元素的key
		var first=(A)it.next();
		first.count=87563;
		System.out.println(hm);//{A@1560b=疯狂Java讲义, A@1560b=轻量级Java EE企业应用开发实战}

		//只能删除没有被修改过的key所对应的kkey-value对
		hm.remove(new A(87563));
		System.out.println(hm);//{A@1560b=疯狂Java讲义}

		//无法获取剩下的value
		System.out.println(hm.get(new A(60000)));//null
		System.out.println(hm.get(new A(87563)));//null
	}
}

尽量不要使用可变对象作为HashMap、Hashtable的key，如果使用了，不要去修改作为key的可变对象。

四、LinkedHashMap实现类

LinkedHashMap是HashMap的子类，使用双向链表来维护key-value对的顺序（其实只需要考虑key的顺序），该链表维护Map的迭代顺序，迭代顺序与key-value对的插入顺序保持一致。
LinkedHashMap可以避免对HashMap、Hashtable里key-value排序，同时也避免了使用TreeMap增加的成本。
LinkedHashMap需要维护元素的插入顺序，因此性能略低于HashMap的性能；但因为它以链表来维护内部顺序，所以在迭代Map里的元素时将具有较好的性能。

import java.util.LinkedHashMap;
public class LinkedHashMapTest 
{
	public static void main(String[] args) 
	{
		var scores=new LinkedHashMap();
		scores.put("语文",89);
		scores.put("数学",98);
		scores.put("英语",92);
		//调用Map方法中的forEach()遍历Map
		scores.forEach((key,value)->System.out.println(key+"-->"+value));
	}
}
---------- 运行Java捕获输出窗 ----------
语文-->89
数学-->98
英语-->92

输出完成 (耗时 0 秒) - 正常终止

从上面运行的结果可以看出LinkedMap可以记住key-value对的添加顺序。

五、使用Properties读写属性文件

Properties类是Hashtable类的子类，该对象在处理属性文件时，十分方便（Windows操作平台上的ini文件就是一种属性文件）。Propertites类可以把Map对象和属性文件关联起来，从而可以把Map对象中的key-value对写入属性文件中，也可以把属性文件中的“属性名=属性值”加载到Map对象中。由于属性文件里的属性名、属性值都是字符串类型，所以Properties里的key、value都是字符串类型。
Properties相当于一个key、value都是String类型的Map
该类提供三个方法来修改Properties里的key、value值
★String getProperty(String key):获取Properties中指定属性名对应的属性值，类似于Map中的get(Object key)。
★String getProperty(String key,String defaultValue):与上一个方法类似，只是Properties中不存在指定的key时，则该方法指定默认值。
★Object setProperty(String key,String value):设置属性值，类似于HashMap中的put()方法。
两个读写属性文件的方法
★void load(InputStream inStream):从属性文件（以输入流表示）中加载key-value对，把加载到的key-value对追加到Properties里（Properties是Hashtable的子类，它不能保证key-value对的顺序）。
★void store(OutputStream out,String comments):将Properties中的key-value对输出到指定的属性文件（以输出流表示）中。

六、SortedMap接口和TreeMap实现类

TreeMap就是一个红黑树数据结构，每个key-value对即作为红黑树的一个节点。TreeMap存储key-value对（节点）时，需要根据key对节点排序。TreeMap可以保证所有的key-value对处于有序状态
TreeMap有两种排序方式：
1、自然排序：
TreeMap的所有key必须实现Comparable接口，而且接口中的所有key应该是同一个类的对象，否则将会抛出ClassCastException依次。
2、定制排序：
创建TreeMap时，传入一个Comparator对象，该对象负责对TreeMap中的所有key进行排序。采用定制排序时，可以不要求Map实现key的Comparable接口。
TreeMap中判断两个key相等的标准：两个key通过compareTo()方法返回0，TreeMap即认为这两个key是相等的。
使用自定义类作为TreeMap的key，且想让TreeMap良好的工作，则重写该类的equals()方法和compareTo()方法应当保持一致：两个key通过equals()方法返回true时，它们通过compareTo()返回0.
TreeMap中提供了一系列的根据key顺序访问key-value对方法：

方法	描述
Map.Entry firstEntry()	返回该Map中最小的key所对应的key-value对，如果该Map为空，则返回null
Object firstKey()	返回该Map中最小的key值，如果该Map为空，则返回null
Map.Entry lastEntry()	返回该Map中最大的key所对应的key-value对，如果该Map为空，则返回null
Object lastKey()	返回该Map中最大的key值，如果该Map为空，则返回null
Map.Entry higherEntry(Object key)	返回该Map中位于key后一位的key-value对（即大于指定key的最小key所对应的key-value对）。如果该Map为空，则返回null
Map.Entry higherKey(Object key)	返回该Map中位于key后一位的key值（即大于指定key的最小key）。如果该Map为空或不存在这样的key-value对，则返回null
Map.Entry lowerEntry(Object key)	返回该Map中位于key前一位的key-value对（即小于指定key的最大key所对应的key-value对）。如果该Map为空，则返回null
Map.Entry higherKey(Object key)	返回该Map中位于key前一位的key值（即小于指定key的最大key）。如果该Map为空或不存在这样的key-value对，则返回null
NavigableMap subMap(Object fromKey,boolean fromInclusive,object toKey,boolean toInclusive)	返回该Map的子Map，其key范围从fromKey(是否包含取决于第二个参数)到toKey(是否包含取决于第二个参数)
SortedMap subMap(Object fromKey,Object toKey)	返回该Map的子Map，其key的返回从fromKey到toKey（不包括）
SortedMap tailMap(Object fromKey)	返回该Map的子Map，其key的范围是大于fromKey（包括）的所有key
NavigableMap tailMap(Object fromKey,boolean inclusive)	返回该Map的子Map，其key的范围是大于fromKey（是否包括取决于第二个参数）的所有key
SortedMap headMap(Object toKey)	返回该Map的子Map，其key的范围是小于toKey（不包括）的所有key
NavigableMap headMap(Object toKey,boolean inclusive)	返回该Map的子Map，其key的范围是小于toKey（是否包括取决于第二个参数）的所有key

6.1定制排序

import java.util.*;
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)
		{
			var r = (R) obj;
			return r.count == this.count;
		}
		return false;
	}
	// 根据count属性值来判断两个对象的大小。
	public int compareTo(Object obj)
	{
		var r = (R) obj;
		return count > r.count ? 1 :
			count < r.count ? -1 : 0;
	}
}
public class TreeMapTest
{
	public static void main(String[] args)
	{
		var tm = new TreeMap();
		tm.put(new R(3), "轻量级Java EE企业应用实战");
		tm.put(new R(-5), "疯狂Java讲义");
		tm.put(new R(9), "疯狂Android讲义");
		System.out.println(tm);
		// 返回该TreeMap的第一个Entry对象
		System.out.println(tm.firstEntry());
		// 返回该TreeMap的最后一个key值
		System.out.println(tm.lastKey());
		// 返回该TreeMap的比new R(2)大的最小key值。
		System.out.println(tm.higherKey(new R(2)));
		// 返回该TreeMap的比new R(2)小的最大的key-value对。
		System.out.println(tm.lowerEntry(new R(2)));
		// 返回该TreeMap的子TreeMap
		System.out.println(tm.subMap(new R(-1), new R(4)));
	}
}
---------- 运行Java捕获输出窗 ----------
{R[count:-5]=疯狂Java讲义, R[count:3]=轻量级Java EE企业应用实战, R[count:9]=疯狂Android讲义}
R[count:-5]=疯狂Java讲义
R[count:9]
R[count:3]
R[count:-5]=疯狂Java讲义
{R[count:3]=轻量级Java EE企业应用实战}

输出完成 (耗时 0 秒) - 正常终止

6.2 定制排序

import java.util.TreeMap;
class R
{
	int count;
	public R(int count)
	{
		this.count=count;
	}
	@Override 
	public String toString()
	{
		return "R[count="+count+"]";
	}
}
public class TreeMapSorted
{
	public static void main(String[] args)
	{
		//按照count越大排序越前排序
		var tm=new TreeMap((o1,o2)->
		{
			var m1=(R)o1;
			var m2=(R)o2;
			return m1.count>m2.count?-1:m1.count<m2.count?1:0;
		});
		tm.put(new R(1),"one");
		tm.put(new R(2),"two");
		tm.put(new R(3),"three");
		System.out.println(tm);

	}
}
输出：{R[count=3]=three, R[count=2]=two, R[count=1]=one}

七、WeeakHashMap类

WeeakHashMap与HashMap用法相似，与HashMap的区别在于，HashMap的key保留了对实际对象的强引用，意味者只要该HashMap对象不被销毁，该HashMap的所有应用对象就不会被垃圾回收，HashMap也不会自动删除这些key所对应的key-value对；但WeeakHashMap的key只保留了对实际对象的弱引用，意味者如果WeekHashMap对象的key所引用的对象没有被其他强引用变量所引用，则这些key所引用的对象可能被垃圾回收，WeakHashMap也会自动删除这些key所对应的key-value对。
WeeakHashMap的key只保留了对实际对象的弱引用，因此当垃圾回收了该key对应的实际对象之后，WeakHashMap会自动删除该key对应的key-value对。如下程序：

import java.util.WeakHashMap;
public class WeakHashMapTest 
{
	public static void main(String[] args) 
	{
		var whm=new WeakHashMap();
		//添加三个元素的key都是匿名字符串对象（没有其他引用）
		whm.put(new String("语文"),new String("良好"));
		whm.put(new String("数学"),new String("优秀"));
		whm.put(new String("英语"),new String("中等"));

		//向WeakHashMap中添加一个key-value对，该key是一个系统缓存的字符串对象
		whm.put("java",new String("中等"));
		System.out.println(whm);

		//通知系统进行垃圾回收
		System.gc();////告诉垃圾收集器打算进行垃圾收集，而垃圾收集器进不进行收集是不确定的
		System.runFinalization();////强制调用已经失去引用的对象的finalize方法
		//通常情况下只能看见一个key-value对
		System.out.println(whm);
	}
}
---------- 运行Java捕获输出窗 ----------
{java=中等, 数学=优秀, 英语=中等, 语文=良好}
{java=中等}

输出完成 (耗时 0 秒) - 正常终止

如果需要使用WeakHashMap的key来保存对象的弱引用，则不要让该key所引用的对象具有任何强引用，否则将失去使用WeakHashMap的意义。

八、IdentityHashMap类

这个Map实现机制与HashMap实现机制基本类似，但它在处理两个key相等时比较独特：在IdentityHashMap中，当且仅当两个key严格相等（key1==key2）时，IdentityHashMap才会认为两个key相等；对于普通的HashMap而言，只要key1和key2通过equals()方法比较返回true，且他们的hashCode()方法返回值相等即可。

import java.util.*;
public class IdentityHashMapTest
{
	public static void main(String[] args)
	{
		var ihm = new IdentityHashMap();
		// 下面两行代码将会向IdentityHashMap对象中添加两个key-value对
		ihm.put(new String("语文"), 89);
		ihm.put(new String("语文"), 78);
		// 下面两行代码只会向IdentityHashMap对象中添加一个key-value对
		ihm.put("java", 93);
		ihm.put("java", 98);
		System.out.println(ihm);
	}
}
---------- 运行Java捕获输出窗 ----------
{语文=78, java=98, 语文=89}

输出完成 (耗时 0 秒) - 正常终止

九、EnumMap实现类

EnumMap实现类是一个与枚举类一起使用的Map实现，EnumMap中的所有key都必须是单个枚举类的枚举值。创建EnumMap时必须显式或隐式指定它所对应的枚举类。EnumMap具有以下特征：
★EnumMap在内部以数组形式保存，所以这种实现是非常搞笑的。
★EnumMap根据key的自然顺序（即枚举值在枚举类中的定义顺序）来维护key-value对的顺序。当程序通过keySet()、entrySet()、values()等方法遍历EnumMap时可以看到这种顺序结构。
★EnumMap不允许使用null作为key，但允许使用null作为value。

import java.util.EnumMap;
enum Season
{
	SPRING,SUMMER,FALL,WINTER
}
public class EnumMapTest
{
	public static void main(String[] args)
	{
		var em=new EnumMap(Season.class);
		em.put(Season.SUMMER,"夏日炎炎");
		em.put(Season.SPRING,"春暖花开");
		em.put(Season.WINTER,"白雪皑皑");
		System.out.println(em);//{SPRING=春暖花开, SUMMER=夏日炎炎, WINTER=白雪皑皑}
	}
}

十、各Map实现类的性能分析

就常用实现类而言，HashMap和Hashtable实现机制几乎一样，但由于Hashtable是一个古老的、线程安全的集合，因此HashMap通常比Hashtable要快。
TreeMap比HashMap和Hashtable要慢（尤其是插入、删除时），因为TreeMap使用红黑树管理key-value对（红黑树的每一个节点都是一个key-value对）
对于一般场景，程序应多考虑适用HashMap，因为HashMap正是为快速查询设计的（HashMap底层使用数组来存储key-value对）。但如果程序需要一个总是排序好的Map时，则可以考虑使用TreeMap.
LinkedHashMap比HashMap慢一点，因为它使用链表来保护Map中的key-value顺序。IdentityHashMap与HashMap基本相似的实现，只是它判断元素相等的条件需要两个key的identityHashCode()返回值相等。EnumMap性能最好，但它只能使用同一个枚举类的枚举值作为key。