Map接口

本章目标
掌握Map接口与Collection接口的不同
掌握Map与Map.Entry接口的关系
掌握Map接口的常用子类：HashMap、Hashtable、TreeMap、WeakHashMap
掌握HashMap与Hastable的区别

Map接口
之前所讲解的Collection、Set、List接口都属于单值的操作，即：每次只能操作一个对象，而Map与它们不同的是，每次操作的是一对对象，即二元偶对象，Map中的每个元素都使用key à value的形式存储在集合之中，此接口定义如下：
——public interface Map<K,V>

 

Map接口中的方法


 

Map.Entry接口
Map.Entry是Map中内部定义的一个接口，专门用来保存keyàvalue的内容。
Map.Entry接口定义：
——public static interface Map.Entry<K,V>

 

Map.Entry接口的常用方法

 

Map与Map.Entry

Map接口的常用子类
Map接口的常用子类：
——HashMap：无序存放的，是新的操作类，key不允许重复。
——Hashtable：无序存放的，是旧的操作类，key不允许重复。
——TreeMap：可以排序的Map集合，按集合中的key排序，key不允许重复。
——WeakHashMap：弱引用的Map集合，当集合中的某些内容不再使用时，可以清除掉无用的数据，可以使用gc进行回收。
——IdentityHashMap：key可以重复的Map集合。

 

新的子类：HashMap
HashMap本身是Map的子类，直接使用此类为Map接口实例化即可。
HashMap类的定义如下：
——public class HashMap<K,V>extends AbstractMap<K,V>implements Map<K,V>, Cloneable, Serializable

 

实例操作一：向集合中增加和取出内容

import java.util.HashMap;
import java.util.Map;
public class HashMapDemo01 {
	public static void main(String[] args) {
		Map<String,String> map = null;//声明 Map 对象
		map = new HashMap<String, String>();//key 和 value 是 String 类
		map.put("baidu", "www.baidu.com");//增加内容
		map.put("聊程", "阅谁问君诵，水落清香浮");//增加内容
		map.put("name", "chaoyi");//增加内容
		String val = map.get("聊程");//根据 key 求出 value
		System.out.println("取出的内容是："+val);//输出 Map，调用 toString()
	}
/* 结果：
 * 取出的内容是：阅谁问君诵，水落清香浮
 * */
}

 

实例操作二：判断指定的key或value是否存在

import java.util.HashMap;
import java.util.Map;
public class HashMapDemo02 {
	public static void main(String[] args) {
		Map<String,String> map = null;//声明 Map 对象
		map = new HashMap<String, String>();//key 和 value 是 String 类
		map.put("baidu", "www.baidu.com");//增加内容
		map.put("聊程", "阅谁问君诵，水落清香浮");//增加内容
		map.put("name", "chaoyi");//增加内容
		if(map.containsKey("聊程")){//查找指定的 key 是否存在
			System.out.println("搜索的 key 存在！");
		}else{
			System.out.println("搜索的 key 不存在！");
		}
		if(map.containsValue("www.baidu.com")){//查找指定的 value 是否存在
			System.out.println("搜索的 value 存在！");
		}else{
			System.out.println("搜索的 value 不存在！");
		}
	}
/* 结果：
 * 搜索的 key 存在！
 * 搜索的 value 存在！
 * */
}

 

实例操作三：输出全部的key

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class HashMapDemo03 {
	public static void main(String[] args) {
		Map<String,String> map = null;//声明 Map 对象
		map = new HashMap<String, String>();//key 和 value 是 String 类
		map.put("baidu", "www.baidu.com");//增加内容
		map.put("聊程", "阅谁问君诵，水落清香浮");//增加内容
		map.put("name", "chaoyi");//增加内容
		Set<String> keys = map.keySet();//得到全部的 key
		Iterator<String> iter = keys.iterator();//实例化 Iterator
		System.out.print("全部的 key：");//输出信息
		while(iter.hasNext()){//迭代输出全部的 key
			String str = iter.next();//取出集合的 key
			System.out.print(str+"、");//输出内容
		}
	}
/* 结果：
 * 全部的 key：baidu、聊程、name、
 * */
}

 

实例操作四：输出全部的value

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
public class HashMapDemo04 {
	public static void main(String[] args) {
		Map<String,String> map = null;//声明 Map 对象
		map = new HashMap<String, String>();//key 和 value 是 String 类
		map.put("baidu", "www.baidu.com");//增加内容
		map.put("聊程", "阅谁问君诵，水落清香浮");//增加内容
		map.put("name", "chaoyi");//增加内容
		Collection<String> values = map.values();//得到全部的 values
		Iterator<String> iter = values.iterator();//实例化 Iterator
		System.out.print("全部的 value：");//输出信息
		while(iter.hasNext()){//迭代输出
			String str = iter.next();//取出 value
			System.out.print(str+"、");//输出内容
		}
	}
/* 结果：
 * 全部的 value：www.baidu.com、阅谁问君诵，水落清香浮、chaoyi、
 * */
}

 

旧的子类：Hashtable

import java.util.Collection;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class HashtableDemo01 {
	public static void main(String[] args) {
		Map<String,String> map = null;//声明 Map 对象
		map = new Hashtable<String, String>();//key 和 value 是 String 类
		map.put("baidu", "www.baidu.com");//增加内容
		map.put("聊程", "阅谁问君诵，水落清香浮");//增加内容
		map.put("name", "chaoyi");//增加内容
		Set<String> keys = map.keySet();//得到全部的 key
		Iterator<String> iter1 = keys.iterator();//实例化 Iterator
		System.out.print("全部的 key ：");//输出信息
		while(iter1.hasNext()){//迭代输出全部的 key
			String str = iter1.next();//取出内容
			System.out.print(str+"、");//输出内容
		}
		Collection<String> values = map.values();//得到全部的 value
		Iterator<String> iter2 = values.iterator();//实例化 Iterator
		System.out.print("\n全部的 value：");//输出信息
		while(iter2.hasNext()){//迭代输出全部的 value
			String str = iter2.next();//取出内容
			System.out.print(str+"、");	//输出内容
		}
	}
/* 结果：
 * 全部的 key ：name、baidu、聊程、
 * 全部的 value：chaoyi、www.baidu.com、阅谁问君诵，水落清香浮、
 * */
}

 

HashMap与Hashtable的区别

 

排序的子类：TreeMap

import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
public class TreeMapDemo01 {
	public static void main(String[] args) {
		Map<String,String> map = null;//声明 Map 对象
		map = new TreeMap<String, String>();//key 和 value 是 String 类
		map.put("A、baidu", "www.baidu.com");//增加内容
		map.put("C、name", "chaoyi");//增加内容
		map.put("B、聊程", "阅谁问君诵，水落清香浮");//增加内容
		Set<String> keys = map.keySet();//得到全部的 key
		Iterator<String> iter = keys.iterator();//实例化 Iterator
		while(iter.hasNext()){//迭代输出
			String str = iter.next();//取出 key
			System.out.println(str+"-->"+map.get(str));//取出 key 对应的内容
		}
	}
/* 结果：
 * A、baidu-->www.baidu.com
 * B、聊程-->阅谁问君诵，水落清香浮
 * C、name-->chaoyi
 * */
}

 

弱引用类：WeakHashMap
之前所讲解的Map 子类中的数据都是使用强引用保存的，即：里面的内容不管是否使用都始终在集合中保留，如果希望集合可以自动清理暂时不用的数据就可以使用WeakHashMap类。
WeakHashMap的定义如下：
——public class WeakHashMap<K,V>extends AbstractMap<K,V>implements Map<K,V>

 

观察弱引用的Map集合

import java.util.Map;
import java.util.WeakHashMap;
public class WeakHashMapDemo01 {
	public static void main(String[] args) {
		Map<String,String> map = null;
		map = new WeakHashMap<String, String>();//实例化 Map 对象
		map.put(new String("baidu"),new String("www.baidu.com"));
		map.put(new String("聊程"), new String("阅谁问君诵，水落清香浮"));
		map.put(new String("name"), new String("chaoyi"));
		System.gc();//进行垃圾收集
		map.put(new String("newCom"), new String("夜无为还是夜"));
		System.out.println("内容："+map);//一般只会剩下一个内容
	}
/* 结果：
 * 取出的内容是：内容：{newCom=夜无为还是夜}
 * */
}

 

提示：对象的引用强度说明
从JDK1.2版本开始，Java把对象的引用分为四种级别，从而使程式能更加灵活的控制对象的生命周期。这四种级别由高到低依次为：强引用、软引用、弱引用和虚引用，下面来简单了解以下这四种引用的区别：
——强引用：当内存不足时，JVM宁可出现OutOfMemeryError错误而使程序停止，也不会回收此对象来释放空间；
——软引用：当内存不足时，会回收这些对象的内存，用来实现内存敏感的高速缓存；
——弱引用：无论内存是否紧张，被垃圾回收器发现立即回收；
——虚引用：和没有任何引用一样。