Java面向对象系列[v1.0.0][HashMap]

HashMap和HashTable都是Map接口的典型实现类,但HashTable是一个古老的Map实现类,自Java1.0就有了,但Java1.0还没有Map接口,HashTable只包含了两个方法,elements()(类似于Map接口定义的values()方法)和keys()(类似于Map接口定义的keySet()方法)。

HashMap和Hashtable

  • HashTable是一个线程安全的Map实现,但HashMap是线程不安全的,因此HashMap比HashTable的性能好一些,但多个线程访问同一个Map对象时,使用HashTable实现类会更好
  • HashTable不允许使用null作为key和value,如果试图把null放进HashTable中,将会引发NullPointerException异常,但HashMap可以使用null作为key或value
import java.util.*;
import static java.lang.System.*;
public class NullInHashMap
{
    public static void main(String[] args)
    {
        var hm = new HashMap();
        // 试图将两个key为null的key-value对放入HashMap中
        hm.put(null, null);
        hm.put(null, null);  
        // 将一个value为null的key-value对放入HashMap中
        hm.put("a", null);   
        // 输出Map对象
        out.println(hm);
    }
}

为了成功的在HashMap、Hashtable中存储、获取对象,用作key的对象必须实现hashCode()方和equals()方法,与HashSet集合一样,HashMap、Hashtable也不能保证其中key-value对的顺序;并且判断两个key相等的标准也是:两个key通过equals()方法比较返回true,两个key的hashCode值也相等。

import java.util.*;
import static java.lang.System.*;

class A
{
	int count;
	public A(int count)
	{
		this.count = count;
	}
	// 根据count的值来判断两个对象是否相等。
	public boolean equals(Object obj)
	{
		if (obj == this)
			return true;
		if (obj != null && obj.getClass() == A.class)
		{
			var 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;
	}
}
public class HashtableTest
{
	public static void main(String[] args)
	{
		var ht = new Hashtable();
		ht.put(new A(60000), "自动化平台测试开发");
		ht.put(new A(87563), "SpringBoot实战");
		ht.put(new A(1232), new B());
		out.println(ht);
		// 只要两个对象通过equals比较返回true,
		// Hashtable就认为它们是相等的value。
		// 由于Hashtable中有一个B对象,
		// 它与任何对象通过equals比较都相等,所以下面输出true。
		out.println(ht.containsValue("测试字符串")); 
		// 只要两个A对象的count相等,它们通过equals比较返回true,且hashCode相等
		// Hashtable即认为它们是相同的key,所以下面输出true。
		out.println(ht.containsKey(new A(87563)));   
		// 下面语句可以删除最后一个key-value对
		ht.remove(new A(1232));           
		out.println(ht);
	}
}

​​程序定义了A类和B类,其中A类判断两个A对象相等的标准是count实例变量,只要两个A对象的count变量相等,则通过equals()方法比较它们返回ture,它们的hashCode()值也相等;
Hashtable判断value相等的标准时:value与另一个对象通过equals()方法比较返回true即可
与HashSet类似的是,如果使用可变对象作为HashMap、HashTable的key,并且程序修改了作为key的可变对象,则也可能出现与HashSet类似的情形:程序再也无法准确访问到Map中被修改过的key

import java.util.*;
import static java.lang.System.*;

public class HashMapErrorTest
{
	public static void main(String[] args)
	{
		var ht = new HashMap();
		// 此处的A类与前一个程序的A类是同一个类
		ht.put(new A(60000), "Spring实战");
		ht.put(new A(87563), "SpringBoot实战");
		// 获得Hashtable的key Set集合对应的Iterator迭代器
		var it = ht.keySet().iterator();
		// 取出Map中第一个key,并修改它的count值
		var first = (A) it.next();
		first.count = 87563;   
		// 输出{A@1560b=Spring实战, A@1560b=SpringBoot实战}
		out.println(ht);
		// 只能删除没有被修改过的key所对应的key-value对
		ht.remove(new A(87563));
		out.println(ht);
		// 无法获取剩下的value,下面两行代码都将输出null。
		out.println(ht.get(new A(87563)));   
		out.println(ht.get(new A(60000)));   
	}
}

因此尽量不要使用可变对象作为HashMap、HashTable的key,如果使用可变对象则尽量不要修改作为key的对象

LinkedHashMap实现类

HashSet有一个LinkedHashSet子类,HashMap也有一个LinkedHashMap子类,LinkedHashMap使用双向链表来维护key-value对的次序,该链表负责维护Map的迭代顺序,该顺序与key-value的插入顺序保持一致, 它可以记住key-value对的添加顺序
LinkedHashMap需要维护元素的插入顺序,因此性能略低于HashMap,但因为它以链表来维护内部顺序,所以在迭代访问Map里的全部元素时将有较好的性能

import java.util.*;
import java.lang.System.*;

public class LinkedHashMapTest
{
	public static void main(String[] args)
	{
		var scores = new LinkedHashMap();
		scores.put("语文", 80);
		scores.put("英文", 82);
		scores.put("数学", 76);
		// 调用forEach方法遍历scores里的所有key-value对
		scores.forEach((key, value) -> System.out.println(key + "-->" + value));
	}
}

使用Properties读写属性文件

Properties类是Hashtable类的子类,用于处理属性文件,例如windows平台的ini文件。Properties类可以把Map对象和属性文件关联起来,从而可以把Map对象中的键值对写入属性文件中,也可以把属性文件中的“属性名=属性值”加载到Map中
因为属性文件中的属性名和属性值只能是字符串类型,因此Properties里的key和value也都是字符串类型
该类提供了如下方法来修改Properties:

  • String getProperty(String key):获取Properties中指定属性名对应的属性值,类似于Map的get(Object key)方法
  • String getProperty(String key, String defaultValue):该方法与前一个方法基本相似,只是如果Properties中不存在指定的key时,则该方法指定默认值
  • Object setProperty(String key, String value):设置属性值,类似于Hashtable的put()方法
    void load(InputStream inStream):从属性文件(以输入流表示)中加载键值对,把加载到的键值对追加到Properties里(PropertiesHashtable的子类,它不保证键值对的次序)
    void store(OutputStream out, String comments):将Properties中的键值对输出到指定的属性文件(以输出流表示)中
import java.util.*;
import java.io.*;
import static java.lang.System.*;

public class PropertiesTest
{
	public static void main(String[] args)
		throws Exception
	{
		var props = new Properties();
		// 向Properties中增加属性
		props.setProperty("username", "yeeku");
		props.setProperty("password", "123456");
		// 将Properties中的key-value对保存到a.ini文件中
		props.store(new FileOutputStream("a.ini"),
			"comment line");   
		// 新建一个Properties对象
		var props2 = new Properties();
		// 向Properties中增加属性
		props2.setProperty("gender", "male");
		// 将a.ini文件中的key-value对追加到props2中
		props2.load(new FileInputStream("a.ini"));   
		out.println(props2);
	}
}

此外,Properties可以把键值对以XML文件的形式保存起来,也可以从XML文件中加载键值对

SortedMap接口和TreeMap实现类

正如Set接口派生出SortedSet子接口,SortedSet接口有一个TreeSet实现类一样,Map接口也派生出一个SortedMap子接口,SortedMap接口也有一个TreeMap实现类,TreeMap就是一个红黑树数据结构,每个键值对作为红黑树的一个节点。

TreeMap存储键值对(节点)时,需要根据key对节点进行排序,TreeMap可以保证所有的键值对处于有序状态,它的排序方式:

  • 自然排序:TreeMap的所有key必须实现Comparable接口,而且所有的key应该是同一个类的对象,否则将会抛出ClassCastException异常
  • 定制排序:创建TreeMap时,传入一个Comparator对象,该对象负责对TreeMap中的所有key进行排序,采用定制排序时不要求Map的key实现Comparable接口

类似于TreeSet中判断两个元素相等的标准,TreeMap中判断两个key相等标准是:两个key通过compareTo()方法返回0,TreeMap即可认为两个key是相等的
如果使用自定义类坐位TreeMap的key,则重写该类的equals(0方法和compareTo()方法时应保持一致的返回结果:两个key通过equals()方法比较返回true时,他们通过compareTo()方法比较应该返回0,如果两个方法的结果不一致,TreeMap和Map接口的规则就会冲突

TreeMap提供了一系列根据key顺序访问键值对的方法:

  • Map.Entry firstEntry():返回该Map中最小key所对应的key-value对,如果该Map为空,则返回null
  • Object firstKey():返回该Map中最小key值,如果该Map为空,则返回null
  • Map.Entry lastEntry():返回该Map中最大key所对应的键值对,如果Map为空或不存在这样的键值对,则返回null
  • Object lastKey():返回该Map中的最大key值,如果该Map为空或不存在这样的key,则返回null
  • Map.Entry higherEntry(Object key):返回该Map中位于key后一位的键值对(即大于指定key的最小key所对应的键值对),如果该Map为空,则返回null
  • Object higherKey(Object key):返回该Map中位于key后一位的key值,如果该Map为空或者不存在这样的键值对,则返回null
  • Map.Entry lowerEntry(Object key):返回该Map中位于key前一位的键值对(即小于指定key的最大key所对应的键值对),如果该Map为空或不存在这样的键值对,则返回null
  • Object lowerKey(Object key):返回该Map中位于key前一位的key值,如果该Map为空或者不存在这样的key,则返回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
import java.util.*;
import static java.lang.System.*;

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), "SpringBoot实战");
		tm.put(new R(-5), "Spring实战");
		tm.put(new R(9), "Spring");
		out.println(tm);
		// 返回该TreeMap的第一个Entry对象
		out.println(tm.firstEntry());
		// 返回该TreeMap的最后一个key值
		out.println(tm.lastKey());
		// 返回该TreeMap的比new R(2)大的最小key值。
		out.println(tm.higherKey(new R(2)));
		// 返回该TreeMap的比new R(2)小的最大的key-value对。
		out.println(tm.lowerEntry(new R(2)));
		// 返回该TreeMap的子TreeMap
		out.println(tm.subMap(new R(-1), new R(4)));
	}
}

定义了一个R类,该类重写了equals()方法,并实现了Comparable接口,所以可以使用该R对象作为TreeMap的key,该TreeMap使用自然排序

WeakHashMap实现类

WeakHashMap与HashMap的用法基本相似,区别在于HashMap的key保留了对实际对象的强引用,只要该HashMap对象不被销毁,那么该HashMap的所有key所引用的对象就不会被垃圾回收,HashMap也不会自动删除这些key所对应的键值对。
WeakHashMap的key只保留了对实际对象的若引用,这意味着这些key所引用的对象可能被垃圾回收,当垃圾回收了该key所对应的实际对象后,WeakHashMap会自动删除该key对应的键值对,并且WeakHashMap也可能自动删除这些key所对应的键值对

import java.util.*;
import static java.lang.System.*;

public class WeakHashMapTest
{
	public static void main(String[] args)
	{
		var 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是一个系统缓存的字符串对象,该key是一个字符串直接量
		whm.put("java", new String("中等"));   
		// 输出whm对象,将看到4个key-value对。
		out.println(whm);
		// 通知系统立即进行垃圾回收
		gc();
		runFinalization();
		// 通常情况下,将只看到一个key-value对。
		out.println(whm);
	}
}

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

IdentityHashMap实现类

在IdentityHashMap中,当且仅当两个key严格相等(key1=key2)时,IdentityHashMap才认为两个key相等,而对于普通的HashMap来说只要key1和key2通过equals()比较返回true,且他们的hashCode值相等即可
IdentityHashMap提供了与HashMap基本相似的方法,也允许使用null作为key和value,同时它也不保证键值对之间的顺序,更不能保证顺序不变

import java.util.*;
import static java.lang.System.*;

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);
	}
}

  • 前两个键值对的key是新创建的字符串对象,通过==比较不相等,因此被当成两个键值对处理
  • 后两个键值对的key是字符串直接量,且字符顺序完全相同,Java用常量池来管理字符串直接量,所有通过==比较相等,被当成同一个key处理

EnumMap实现类

EnumMap是一个与枚举类一起使用的Map实现,EnumMap中的所有key都必须是单个枚举类的枚举值。创建EnumMap时必须显式或隐式指定它对应的枚举类

  • EnumMap在内部以数组形式保存,所以这种实现形式非常紧凑高效
  • EnumMap根据key的自然顺序(即枚举值在枚举类中的定义顺序)来维护键值对的顺序,当通过keySet()、entrySet()、value()等方法遍历EnumMap时可以看到这种顺序
  • EnumMap不允许使用null作为key,可以使用null作为value,如果试图使用null作为key将抛出NullPointerException异常,如果只是查询是否包含值为null的key,或只是删除值为null的key则不会抛异常
import java.util.*;
import static java.lang.System.*;

enum Season
{
	SPRING, SUMMER, FALL, WINTER
}
public class EnumMapTest
{
	public static void main(String[] args)
	{
		// 创建EnumMap对象,该EnumMap的所有key都是Season枚举类的枚举值
		var enumMap = new EnumMap(Season.class);
		enumMap.put(Season.SUMMER, "夏日炎炎");
		enumMap.put(Season.SPRING, "春暖花开");
		out.println(enumMap);
	}
}

各Map实现类性能

  • 通常情况下HashMap要比HashTable要快
  • TreeMap通常比HashMap、HashTable要慢,尤其在插入和删除键值对时,因为TreeMap底层采用红黑树来管理键值对,HashMap底层采用数组来存储键值对,但TreeMap总是处于有序状态,不同专门排序,可以调用keySet()取得有key组成的Set,然后使用toArray()方法生成key的数组,然后使用Arrays的binarySerach()方法在已排序的数组中快速查询对象
  • LinkedHashMap比HashMap慢一点,因为它要维护链表来保持Map中键值对添加时的顺序
  • IdentityHashMap性能没有特别出色之处,它跟HashMap的实现基本相似,只是它用==而不是equals()方法来判断元素相等
  • EnumMap的性能最好,但他只能使用同一个枚举类的枚举值作为key

HashSet和HashMap的性能选项

对于HashSet及其子类而言,他们采用hash算法来决定集合中元素的存储位置,并通过hash算法来控制集合的大小;对于HashMap、Hashtable及其子类而言,他们采用hash算法来决定Map中key的存储,并通过hash算法来增加key集合的大小
hash表里可以存储元素位置的被称为“桶(bucket)”,在通常情况下,单个bucket里存储一个元素,此时具有最好的性能【hash算法可以根据hashCode值计算出bucket的存储位置,接着从bucket中取出元素】
hash表的状态是open的在发生“hash冲突”的情况下,单个bucket会存储多个元素,这些元素以链表形式存储,必须按顺序搜索,如图所示
Java面向对象系列[v1.0.0][HashMap]_第1张图片
HashSet、HashMap、HashTable都使用hash算法来决定其元素的存储,因此HashSet、HashMap的hash表包含如下属性:

  • 容量(capacity):hash表中bucket的数量
  • 初始化容量(initial capacity):创建hash表时bucket的数量,HashMap和HashSet都允许在构造器中指定初始化容量
  • 尺寸(Size):当前hash表中记录的数量
  • 负载因子(load factor):负载因子等于Size/Capacity,当其为0的时候,表示空的hash表,0.5的时候表示半满的hash表,以此类推【轻负载的hash表具有冲突少,适宜插入与查询的特点,但用Iterator迭代元素时比较慢】
  • 负载极限:它是一个0到1的数值,这个数值决定了hash表最大填满程度,当hash表中的负载因子达到指定的负载极限时,hash表会自动成倍的增加容量(bucket的数量),并将原有的对象重新分配,放入新的bucket,这就是rehashing。

HashSet、HashMap和HashTable的构造器允许指定一个负载极限,默认值为0.75,表明当hash表的3/4已经被填满的时候,hash表就会发生rehashing,这个数值是在时间和空间成本上的一种折中。

  • 较高的负载极限:可以降低hash表所占用的内存空间,但会增加查询数据的时间开销,而查询是最频繁的操作,例如HashMap的get()和put()方法都要用到查询
  • 较低的负载极限:可以提高查询数据的性能,但会增加hash表所占用的内存空间

如果一开始就知道HashSet、HashMap及HashTable会保存很多记录,则可以在创建时就使用较大的初始化容量,如果初始化容量始终大于HashSet、HashMap及HashTable所包含的最大记录除以负载极限就不会发生rehashing

你可能感兴趣的:(Java基础即高端)