Java类集框架——Map接口（Map.Entry接口 Map常用子类HashMap、Hashtable、TreeMap、WeakHashMap）的使用

╰+攻爆jí腚メ 2022-09-25 10:18 225阅读 0赞

## 学习目标 ##

掌握Map接口与Collection接口的不同。

掌握Map与Map.Entry接口的关系。

掌握Map接口常用的子类：HashMap、Hashtable、TreeMap、WeakHashMap。

掌握HashMap与Hashtable的区别。

Collection的操作中每次保存的对象都是一个对象，但是在Map集合中保存的是一对对象，对象的形式是以：key—>value的形式保存的。就好像通讯录一样的。

## Map接口中的方法 ##

1、public void clear() 普通 清空Map集合。

2、public boolean containsKey(Object key)普通，判断指定的key是否存在。

3、public boolean containsValue(Object value) 普通 判断指定的value是否存在。

4、public Set<Map.Entry<K, V>>  entrySet()普通 将Map集合变为Set集合。

5、public boolean equals(Object o) 对象比较。

6、public V get(Object key)  普通 根据key取value。

7、public int hashCode() 普通 返回哈希码。

8、public boolean isEmpty() 普通 判断集合是否为空。

9、public Set<K> keySet()  普通  取得所有的key。

10、public V put(K key, V value) 向集合中加入元素。

11、public void putAll(Map<? extends K, ? extends V>  t) 普通 将一个Map集合中的内容加入到另一个Map中。

12、public V remove(Object key)根据key删除value。

13、public int size() 普通  取出集合的长度。

14、public Collection<V> values() 普通 取出全部的value。

## Map与Map.Entry ##

![Center][]

## Map接口的常用子类： ##

HashMap：无序存放的，是新的操作类，key不允许重复。

Hashtable：无序存放的，是旧的操作类，key值不允许重复。

TreeMap：可以排序的Map集合，按集合中的key排序，key值不允许重复。

WeakHashMap：弱引用的Map集合，当集合中的某些内容不再使用时，可以清除掉无用的数据，可以使用gc进行回收。

IdentityHashMap：key可以重复的Map集合。

以HashMap为例，Map的基本方法的操作如下：

import java.util.HashMap ;
    import java.util.Map ;
    public class HashMapDemo01{
    	public static void main(String args[]){
    		Map<String,String> map = null; // 声明Map对象，其中key和value的类型为String
    		map = new HashMap<String,String>() ;
    		map.put("name","liuxun") ;	// 增加内容
    		map.put("QQ","2652790899") ;	// 增加内容
    		map.put("age","23") ;	// 增加内容
    		String val = map.get("name") ;	// 根据key取出值
    		System.out.println("取出的内容是：" + val) ;
    	}
    };

![Center 1][]  
在map中也可以使用containsXxx()方法判断指定的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对象，其中key和value的类型为String
    		map = new HashMap<String,String>() ;
    		map.put("name","liuxun") ;	// 增加内容
    		map.put("QQ","2652790899") ;	// 增加内容
    		map.put("age","23") ;	// 增加内容
    		if(map.containsKey("name")){	// 判断key是否存在
    			System.out.println("搜索的key存在！") ;
    		}else{
    			System.out.println("搜索的key不存在！") ;
    		}
    		if(map.containsValue("23")){	// 判断value是否存在
    			System.out.println("搜索的value存在！") ;
    		}else{
    			System.out.println("搜索的value不存在！") ;
    		}
    	}
    };

![Center 2][]  
如果现在想输出全部的key，则使用如下方法：

Set<K>  **keySet**()

import java.util.HashMap ;
    import java.util.Map ;
    import java.util.Iterator ;
    import java.util.Set ;
    public class HashMapDemo03{
    	public static void main(String args[]){
    		Map<String,String> map = null; // 声明Map对象，其中key和value的类型为String
    		map = new HashMap<String,String>() ;
    		map.put("name","liuxun") ;	// 增加内容
    		map.put("QQ","2652790899") ;	// 增加内容
    		map.put("age","23") ;	// 增加内容
    		Set<String> keys = map.keySet() ;	// 得到全部的key
    		Iterator<String> iter = keys.iterator() ;
    		while(iter.hasNext()){
    			String str = iter.next() ;
    			System.out.print(str + "、") ;
    		}
    	}
    };

![Center 3][]  
既然可以输出全部的key，那么肯定可以输出全部的value

Collection<V>**values**()

import java.util.HashMap ;
    import java.util.Map ;
    import java.util.Iterator ;
    import java.util.Collection ;
    public class HashMapDemo04{
    	public static void main(String args[]){
    		Map<String,String> map = null; // 声明Map对象，其中key和value的类型为String
    		map = new HashMap<String,String>() ;
    		map.put("name","liuxun") ;	// 增加内容
    		map.put("QQ","2652790899") ;	// 增加内容
    		map.put("age","23") ;	// 增加内容
    		Collection<String> values = map.values() ;	// 得到全部的value
    		Iterator<String> iter = values.iterator() ;
    		while(iter.hasNext()){
    			String str = iter.next() ;
    			System.out.print(str + "、") ;
    		}
    	}
    };

在Map中也存在一个Hashtable子类，实际上这个子类的推出时间与Vector是一样的，都属于旧的类。

import java.util.HashMap ;
    import java.util.Hashtable;
    import java.util.Map ;
    import java.util.Set ;
    import java.util.Iterator ;
    import java.util.Collection ;
    public class HashtableDemo01{
    	public static void main(String args[]){
    		Map<String,String> map = null; // 声明Map对象，其中key和value的类型为String
    		map = new Hashtable<String,String>() ;
    		map.put("name","liuxun") ;	// 增加内容
    		map.put("QQ","2652790899") ;	// 增加内容
    		map.put("age","23") ;	// 增加内容
    		System.out.print("全部的key：") ;
    		Set<String> keys = map.keySet() ;	// 得到全部的key
    		Iterator<String> iter = keys.iterator() ;
    		while(iter.hasNext()){
    			String str = iter.next() ;
    			System.out.print(str + "、") ;
    		}
    		System.out.print("\n全部的value：") ;
    		Collection<String> values = map.values() ;	// 得到全部的value
    		Iterator<String> iter2 = values.iterator() ;
    		while(iter2.hasNext()){
    			String str = iter2.next() ;
    			System.out.print(str + "、") ;
    		}
    	}
    };

![Center 4][]  
HashMap与Hashtable的区别：

1、从推出时间上看：HashMap是JDK1.2之后推出的，属于新的操作类，Hashtable是JDK1.0时推出 属于旧的操作类。

2、从性能上看：HashMap采用异步处理方式，性能更高，Hashtable采用同步的处理方式性能较低。

3、从线程安全看：HashMap属于非线程安全的操作类，Hashtable属于线程安全的操作类。

在Map中还存在一个TreeMap的子类，此类属于排序类，按key排序。

import java.util.TreeMap ;
    import java.util.Map ;
    import java.util.Set ;
    import java.util.Iterator ;
    import java.util.Collection ;
    public class TreeMapDemo01{
    	public static void main(String args[]){
    		Map<String,String> map = null; // 声明Map对象，其中key和value的类型为String
    		map = new TreeMap<String,String>() ;
    		map.put("Zname","liuxun") ;	// 增加内容
    		map.put("XQQ","2652790899") ;	// 增加内容
    		map.put("Yage","23") ;	// 增加内容
    		Set<String> keys = map.keySet() ;	// 得到全部的key
    		Iterator<String> iter = keys.iterator() ;
    		while(iter.hasNext()){
    			String str = iter.next() ;
    			System.out.println(str + " --> " + map.get(str)) ; // 取出内容
    		}
    	}
    };

![Center 5][]  
使用TreeMap可以方便的完成排序的操作。如果自定义的类要想作为key的话，则肯定要实现Comparable接口，指定比较的规则。

## 弱引用类：WeakHashMap ##

之前接触到的Map子类中的数据都是使用强引用保存的。即：里面的内容不管是否使用都始终在集合中保留，如果希望集合可以自动清理暂时不用的数据就可以使用WeakHashMap类。

WeakHashMap的定义如下：

public class WeakHashMap<K, V> extends  AbstractMap<K, V> implements Map<K, V>

如果假设一个Map中的某些内容长时间不使用的话，按照之前的做法是不会删除掉的，如果希望可以自动删除掉，可以使用弱引用。当里面的某些内容不使用时，可以自动删除掉。

import java.util.WeakHashMap ;
    import java.util.Map ;
    import java.util.Set ;
    import java.util.Iterator ;
    import java.util.Collection ;
    public class WeakHashMapDemo01{
    	public static void main(String args[]){
    		Map<String,String> map = null; // 声明Map对象，其中key和value的类型为String
    		map = new WeakHashMap<String,String>() ;
    		map.put(new String("name"),new String("liuxun")) ;
    		map.put(new String("QQ"),new String("2652790899")) ;
    		map.put(new String("age"),new String("23")) ;
    		System.gc() ;	// 强制性进行垃圾的收集操作
    		map.put(new String("sex"),new String("man")) ;
    		System.out.println(map) ;
    	}
    };

![Center 6][]

对象的引用强度说明：

从JDK1.2版本开始，Java把对象的引用分为四种级别，从而使程序能更加灵活的控制对象的生命周期。这四种级别由高到低依次为：强引用、软引用、弱引用、虚引用，四种引用的区别如下：

强引用：当内存不足时，JVM宁可出现OutOfMemoryError错误使程序停止，也不会回收此对象来释放空间。

软引用：当内存不足时，会回收这些对象的内存，用来实现内存敏感的高速缓存。

弱引用：无论内存是否紧张，被垃圾回收器发现立即回收。

虚引用：和没有任何引用一样。

总结：

1、掌握Map的特点及其基本操作。

2、Map与Map.Entry的关系。

3、Map的子类：HashMap、Hashtable、TreeMap、WeakHashMap。

4、主要功能就是查找，根据key找到value。

5、与Set的相似之处：对于非排序的HashMap，key不能重复，它判断key是否重复还是根据对象的hashCode()和equals()方法，如果是自定义的对象建议重写这两个方法。

对于排序的TreeMap 主要根据key实现的comparable接口中的compareTo(Object  o)方法对key进行排序。

[Center]: /images/20220718/6a075e44c3f049f2a5204ab8713a0181.png
[Center 1]: /images/20220718/4a85146ce1da4902a3d4303fe1c98824.png
[Center 2]: /images/20220718/cd4980e088314fd8a925430be783d547.png
[Center 3]: /images/20220718/24e8439bd76a4e51b1983ff9e51ae48c.png
[Center 4]: /images/20220718/54c8e19a4e3345128b78a3df884f4102.png
[Center 5]: /images/20220718/df84c87d246d46ac90e356e724c8eb5d.png
[Center 6]: /images/20220718/3b5d754213114233aedb3c1ca410fd37.png