Java8新增的Map集合以及各Map的实现

<span style="font-family:Times New Roman;font-size:18px;">package com.map.test;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.EnumMap;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.IdentityHashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Properties;
import java.util.TreeMap;
import java.util.WeakHashMap;
enum Season{
	SPRING,SUMMER,FALL,WINTER
}
class A{
	int count;
	public A(int count){
		this.count=count;
	}
	//根据count值判断两个对象是否相等
	public boolean equals(Object obj)
	{
		if(this==obj)
			return true;
		if(obj!=null&&obj.getClass()==A.class)
		{
			A a=(A)obj;
			return this.count==a.count;
		}
		return false;
	}
	//根据count值来判断hashcode值
	public int hashcode()
	{
		return this.count;
	}
}
class B
{
	//重写equals()方法，B对象与任何对象通过equals()方法比较都返回true
	public boolean equals(Object obj)
	{
		return true;
	}
}
/*
 *  下面代码定义了一个R类，该类重写了equals()方法，并实现了Comparable()接口
 *  所以可以使用该R对象作为TreeMap的key,该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 this.count==r.count;
		}
		return false;
	}
	//根据count属性值来判断两个对象的大小
	public int compareTo(Object arg0) {
		R r=(R)arg0;
		return count>r.count?1:
			count<r.count?-1:0;
	}
}
public class MapTest {

	public static void main(String[] args) throws FileNotFoundException, IOException {
		Map map=new HashMap();
		//成对放入多个key-value对
		map.put("计算机导论", 101);
		map.put("高级算法分析", 111);
		map.put("敏捷开发", 121);
		map.put("网页设计", 131);
		//多次放入的key-value中的value可以重复
		map.put("疯狂java讲义", 99);
		//放入重复的key时，新的value会覆盖原有的value
		//如果新的value覆盖了原有的value，该方法返回被覆盖的value
		System.out.println(map.put("网页设计", 99));
		System.out.println(map);
		//判断是否包含指定的key
		System.out.println("是否包含值为 数据库技术key："
		+map.containsKey("数据库技术"));
		//判断是否包含指定value
		System.out.println("判断是否包含值为99 value:"+
		map.containsValue(111));
		//获取map集合的所有key组成的集合，通过遍历key来实现遍历所有的key-value对
		for(Object key:map.keySet())
		{
			//map.get(key)方法获取指定key对应的value
			System.out.println(key+"-->"+map.get(key));
		}
		map.remove("敏捷开发");
		System.out.println(map);
		System.out.println("--------Java8新增的Map方法-------");
		//尝试替换key为"云计算"的value,由于原map中木有对应的key
		//因此map没有改变，不会添加新的key-value对
		map.replace("云计算", 98);
		System.out.println(map);
		//使用原value与传入参数计算出来的结果覆盖原有的value
		map.merge("高级算法分析", 10, (oldVal,parm)->(Integer)oldVal+(Integer)parm);
		System.out.println(map);//可以看到"高级算法分析"的value值增加了10
		//当key为"java web"对应的value为null或者不存在时，使用计算的结果作为新的value
		map.computeIfAbsent("java web", (key)->((String)key).length());
		System.out.println(map);//可以看到map中添加了java web=8这组key-value对
		//当key为java web对应的value存在时，使用计算的结果作为新的value
		map.computeIfPresent("java web", (key,value)->(Integer)value*(Integer)value);
		System.out.println(map);//map中的java web=8变成了java web=64
		
		System.out.println("\n-------Java改进的HashMap和HashTable实现类-------");
		//试图将两个key为null值的key-value对放入HashMap中,不会引发异常
		map.put(null,null);
		map.put(null, null);
		//将一个value为null值的key-value对放入HashMap中
		map.put("a",null);
		//输出map
		System.out.println(map);
		
		System.out.println("\n----Hashtable判断key,value相等的标准----");
		Hashtable ht=new Hashtable();
		ht.put(new A(6000), "编程之美");
		ht.put(new A(87666), "高级算法设计");
		ht.put(new A(3211), new B());
		System.out.println(ht);
		//只要两个对象通过equals()方法返回true
		//Hashtable就认为他们是相等value
		//由于Hashtable中有一个B对象
		//它与任何对象通过equals()方法比较都相等，所以下面输出true
		System.out.println(ht.containsValue("测试字符串"));
		//只要两个A对象的count相等，它们通过equals()方法返回true，且hashcode值相等
		//Hashtable即认为它们是相同的key，所以下面输出true
		System.out.println(ht.containsKey(new A(3211)));
		//下面语句可以删除最后一个key-value对
		ht.remove(new A(3211));
		System.out.println(ht);
		System.out.println("\n-------使用可变对象作为HashMap的key-------");
/*
 * 与HashSet类似的，如果使用可变对象作为HashMap、Hashtable的key,并且修改了作为key
 * 的可变对象，则也可能出现与HashSet类似的情形：程序再也无法准确访问到Map中被修改过的key
 * 尽量不要使用可变对象作为HashMap,Hashtable的key,如果必须使用，尽量不要修改作为key的可变对象
 */
		map.clear();
		map.put(new A(6999),"海量存储");
		map.put(new A(87653),"云计算");
		System.out.println(map);
		//获得与Hashtable的key set集合对应的Iterator迭代器
		Iterator it=map.keySet().iterator();
		//取出map中的第一个key，并修改它的count值
		A first=(A)it.next();
		first.count=8888;
		//输出
		System.out.println(map);
		//只能删除没有被修改过的key对应的key-value对
		map.remove(new A(87653));
		System.out.println(map);
		//无法获取剩下的value
		System.out.println(map.get(new A(6999)));
		System.out.println(map.get(new A(87653)));
/*
 * LinkedHashMap可以记住key-value对的添加顺序	
 */
		System.out.println("\n------LinekedHashMap实现类------");
		LinkedHashMap scores=new LinkedHashMap();
		scores.put("语文", 77);
		scores.put("英语", 68);
		scores.put("数学", 79);
		//调用forEach()方法遍历scores里的所有key-value对
		scores.forEach((key,value)->System.out.println(key+"-->"+value));
		
		System.out.println("\n------使用Properties读写属性文件------");
		Properties props=new Properties();
		props.setProperty("username", "Yafeng");
		props.setProperty("password", "123456");
		//将properties中的key-value对保存到a.ini文件中
		props.store(new FileOutputStream("a.ini"),"comment line");
		//新建一个Properties对象
		Properties props2=new Properties();
		//向props2中添加属性
		props2.setProperty("gender", "man");
		//将a.ini文件中的key-value对追加到props2中
		props2.load(new FileInputStream("a.ini"));
		System.out.println(props2);
/*
 * TreeMap中的key-value对是有序的，所以增加了访问
 * 第一个，前一个，后一个，最后一个key-value对的方法
 * 并提供了几个从TreeMap中截取子TreeMap的方法
 */
		System.out.println("\n-------TreeMap------");
		TreeMap tm=new TreeMap();
		tm.put(new R(3), "操作系统");
		tm.put(new R(-5), "计算机系统结构");
		tm.put(new R(9), "数据结构");
		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值
		System.out.println(tm.lowerEntry(new R(2)));
		//返回该TreeMap的子TreeMap
		System.out.println(tm.subMap(new R(-1), new R(19)));
		
/*
 * WeakHashMap中的每个key对象只持对实际对象的弱引用，因此
 * 当垃圾回收了该key所对应的实际对象之后，WeakHashMap会自动
 * 删除该key对应的key-value对。
 * PS:如果需要使用WeakHashMap的key来保留对象的弱引用，
 * 则不要让该key所引用的对象具有任何引用，否则将失去WeakHashMap的意义
 */
		System.out.println("---------WeakHashMap实现类----------");
		WeakHashMap whm=new WeakHashMap();
		//向WeakHashMap中添加三个key-value对
		//三个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("优秀"));
		//输出whm对象，将看到4个key-value对
		System.out.println(whm);
		//通知系统立即进行垃圾回收
		System.gc();
		System.runFinalization();
		//在通常情况下，将只会看到一个key-value对
		System.out.println(whm);
/*
 * IdentityHashMap实现类当且仅当两个key严格相等(key1==key2)时，
 * IdentityHashMap才认为两个key相等
 * 而普通的HashMap只要key1和key2通过equals()方法比较返回true，且
 * 它们的hashcode()相等即可
 */
		System.out.println("\n---------IdentityHashMap-----------");
		IdentityHashMap ihm=new IdentityHashMap();
		//下面将会向IdentityHashMap对象中添加两个key-value对
		ihm.put(new String("语文"), 89);
		ihm.put(new String("数学"), 78);
		/*下面两行代码只会向IdentityHashMa对象中添加一个key-value
		 * 下面key-value对的key都是字符串直接量，而且它们的字符串序列完全相同
		 * Java使用常量池来管理字符串直接量，因此它们通过==比较返回true
		 * IdentityHashMap会认为它们是同一个key,故只有一次添加成功
		 */
		ihm.put("Java",88);
		ihm.put("Java",88);
		System.out.println(ihm);
		
/*
 * EnumMap类中的所有key都必须是单个枚举类的枚举值
 * 创建EnumMap时必须显式或隐式指定它对应的枚举类
 */
		System.out.println("\n---------EnumMap-----------");
		//创建EnumMap对象，该EnumMap的所有key都是Season枚举类的枚举值
		EnumMap enumMap=new EnumMap(Season.class);
		//向该EnumMap中添加两个key-value对后，
		//这两个key-value对将会以Season枚举值的自然顺序排序
		enumMap.put(Season.WINTER, "漫天飞雪");
		enumMap.put(Season.FALL, "秋高气爽");
		System.out.println(enumMap);
	}

}</span>