Map集合（HashMap、TreeMap、Hashtable）

2024-03-16 23:16:16

一、Map集合概述

Map与Collection并列存在。用于保存具有映射关系的数据:key-value

Map 中的 key 和 value 都可以是任何引用类型的数据
Map 中的key 用Set来存放，不允许重复，即同一个 Map 对象所对应的类，须重写hashCode()和equals()方法
常用String类作为Map的“键”
key 和 value 之间存在单向一对一关系，即通过指定的 key 总能找到唯一的、确定的 value
Map接口的常用实现类：HashMap、TreeMap、LinkedHashMap和Properties。其中，HashMap是 Map 接口使用频率最高的实现类

1.1 Map接口常用方法

添加、删除、修改操作：
Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中

void putAll(Map m):将m中的所有key-value对存放到当前map中

Object remove(Object key)：移除指定key的key-value对，并返回value

void clear()：清空当前map中的所有数据

元素查询的操作：
Object get(Object key)：获取指定key对应的value
boolean containsKey(Object key)：是否包含指定的key
boolean containsValue(Object value)：是否包含指定的value
int size()：返回map中key-value对的个数
boolean isEmpty()：判断当前map是否为空
boolean equals(Object obj)：判断当前map和参数对象obj是否相等

元视图操作的方法：
Set keySet()：返回所有key构成的Set集合
Collection values()：返回所有value构成的Collection集合
Set entrySet()：返回所有key-value对构成的Set集合

1.2 Map的实现类的结构:

Map:双列数据，存储key-value对的数据—类似于高中的函数: y = f(x)
---->HashMap:作为map的主要实现类;线程不安全的，效率高;存储null的key和value
---------->linkedHasnMap:保证在遍历map元素时，可以按照添加的顺序实现遍历。
原因:在原有的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素。对于频繁的遍历操作，此类执行效率高于HashMap 。
---->TreeMap:保证按照添加的hey-value对进行排序，实现排序遍历。此时考虑key的自然排序或定制排序
底层使用红黑树
---->Hashtable:作为古老的实现类，线程安全的，效率低;不能存储nuLL的key和value’/ ----------------------->Properties:常用来处理配置文件。key和vaLue都是String类型

HashMap的底层:数组+链表(jdk7及之前)
数组+链表+红黑树(jdk 8)

二、Map实现类HashMap

Map实现类之一：HashMap

HashMap是 Map 接口使用频率最高的实现类。
允许使用null键和null值，与HashSet一样，不保证映射的顺序。
所有的key构成的集合是Set:无序的、不可重复的。所以，key所在的类要重写：
equals()和hashCode()
所有的value构成的集合是Collection:无序的、可以重复的。所以，value所在的类
要重写：equals()
一个key-value构成一个entry
所有的entry构成的集合是Set:无序的、不可重复的
HashMap 判断两个 key 相等的标准是：两个 key 通过 equals() 方法返回 true，
hashCode 值也相等。
HashMap 判断两个 value相等的标准是：两个 value 通过 equals() 方法返回 true。

2.1 HashMap源码分析

2.1.1 HashMap源码中的重要常量

DEFAULT_INITIAL_CAPACITY : HashMap的默认容量，16
MAXIMUM_CAPACITY ： HashMap的最大支持容量，2^30
DEFAULT_LOAD_FACTOR：HashMap的默认加载因子
TREEIFY_THRESHOLD：Bucket中链表长度大于该默认值，转化为红黑树
UNTREEIFY_THRESHOLD：Bucket中红黑树存储的Node小于该默认值，转化为链表
MIN_TREEIFY_CAPACITY：桶中的Node被树化时最小的hash表容量。（当桶中Node的
数量大到需要变红黑树时，若hash表容量小于MIN_TREEIFY_CAPACITY时，此时应执行
resize扩容操作这个MIN_TREEIFY_CAPACITY的值至少是TREEIFY_THRESHOLD的4
倍。）
table：存储元素的数组，总是2的n次幂
entrySet：存储具体元素的集
size：HashMap中存储的键值对的数量
modCount：HashMap扩容和结构改变的次数。
threshold：扩容的临界值，=容量*填充因子
loadFactor：填充因子

2.1.2 HashMap的存储结构

JDK 7及以前版本：HashMap是数组+链表结构(即为链地址法)
JDK 8版本发布以后：HashMap是数组+链表+红黑树实现。

2.1.3 源码解析

jdk7源码分析：

/**
 * The table, resized as necessary. Length MUST Always be a power of two.
 */
transient Entry[] table;
static class Entry<K,V> implements Map.Entry<K,V> {
final K key;
V value;
Entry<K,V> next;
final int hash;
}

可以看出，Entry 就是数组中的元素，每个 Map.Entry 其实就是一个 key-value 对，它
持有一个指向下一个元素的引用，这就构成了链表

存储：

 public V put(K key, V value) {
 // HashMap 允许存放 null 键和 null 值。
 // 当 key 为 null 时，调用 putForNullKey 方法，将 value 放置在数组第一个位置。
 if (key == null)
 return putForNullKey(value);
 // 根据 key 的 keyCode 重新计算 hash 值。
 int hash = hash(key.hashCode());
 // 搜索指定 hash 值在对应 table 中的索引。
 int i = indexFor(hash, table.length);
 // 如果 i 索引处的 Entry 不为 null，通过循环不断遍历 e 元素的下一个元素。
 for (Entry<K,V> e = table[i]; e != null; e = e.next) {
 Object k;
 if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
 V oldValue = e.value;
 e.value = value;
 e.recordAccess(this);
 return oldValue;
 }
 }
 // 如果 i 索引处的 Entry 为 null，表明此处还没有 Entry。
  modCount++;
 // 将 key、value 添加到 i 索引处。
 addEntry(hash, key, value, i);
 return null;
}

从上面的源代码中可以看出：当我们往 HashMap 中 put 元素的时候，先根据 key 的
hashCode 重新计算 hash 值，根据 hash 值得到这个元素在数组中的位置（即下标），如果数组该位置上已经存放有其他元素了，那么在这个位置上的元素将以链表的形式存放，新加入的放在链头，最先加入的放在链尾。如果数组该位置上没有元素，就直接将该元素放到此数组中的该位置上。addEntry(hash, key, value, i)方法根据计算出的 hash 值，将 key-value 对放在数组 table的 i 索引处。addEntry 是 HashMap 提供的一个包访问权限的方法，代码如下：

void addEntry(int hash, K key, V value, int bucketIndex) {
 // 获取指定 bucketIndex 索引处的 Entry
 Entry<K,V> e = table[bucketIndex];
 // 将新创建的 Entry 放入 bucketIndex 索引处，并让新的 Entry 指向原来的 Entry
 table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
 // 如果 Map 中的 key-value 对的数量超过了极限
 if (size++ >= threshold)
 // 把 table对象的长度扩充到原来的 2 倍。
 resize(2 * table.length);
 }

jdk8源码分析：

//默认的初始容量为 16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//最大的容量上限为 2^30
static final int MAXIMUM_CAPACITY = 1 << 30;
//默认的负载因子为 0.75
static final float DEFAULT_LOAD_FACTOR = 0.75f;
尚硅谷 Java 高级编程 宋红康
//变成树型结构的临界值为 8
static final int TREEIFY_THRESHOLD = 8;
//恢复链式结构的临界值为 6
static final int UNTREEIFY_THRESHOLD = 6;
//哈希表
transient Node<K,V>[] table;
//哈希表中键值对的个数
transient int size;
//哈希表被修改的次数
transient int modCount;
//它是通过 capacity*load factor 计算出来的，当 size 到达这个值时，就会进行扩容操作
int threshold;
//负载因子
final float loadFactor;
//当哈希表的大小超过这个阈值，才会把链式结构转化成树型结构，否则仅采取扩容来尝试减少冲突
static final int MIN_TREEIFY_CAPACITY = 64;

/*下面是 Node 类的定义，它是 HashMap 中的一个静态内部类，哈希表中的每一个
节点都是 Node 类型。我们可以看到，Node 类中有 4 个属性，其中除了 key 和
value 之外，还有 hash 和 next 两个属性。hash 是用来存储 key 的哈希值的，next 
是在构建链表时用来指向后继节点的。*/
static class Node<K,V> implements Map.Entry<K,V> {
 final int hash;
 final K key;
 V value;
 Node<K,V> next;
 Node(int hash, K key, V value, Node<K,V> next) {
 this.hash = hash;
 this.key = key;
 this.value = value;
 this.next = next;
 }
 public final K getKey() { return key; }
 public final V getValue() { return value; }
 
 public final String toString() { return key + "=" + valu
e; }
 public final int hashCode() {
 return Objects.hashCode(key) ^ Objects.hashCode(val
ue);
 }
 public final V setValue(V newValue) {
 V oldValue = value;
 value = newValue;
 return oldValue;
 }
 public final boolean equals(Object o) {
 if (o == this)
 return true;
 if (o instanceof Map.Entry) {
 Map.Entry<?,?> e = (Map.Entry<?,?>)o;
 if (Objects.equals(key, e.getKey()) &&
 Objects.equals(value, e.getValue()))
 return true;
 }
 return false;
 }

get()方法

//get 方法主要调用的是 getNode 方法，所以重点要看 getNode 方法的实现
 public V get(Object key) {
 Node<K,V> e;
 return (e = getNode(hash(key), key)) == null ? null
: e.value;
 }
 final Node<K,V> getNode(int hash, Object key) {
 Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
 //如果哈希表不为空 && key 对应的桶上不为空
 if ((tab = table) != null && (n = tab.length) > 0 &&
 (first = tab[(n - 1) & hash]) != null) {
 //是否直接命中
 if (first.hash == hash && // always check first n
ode
 ((k = first.key) == key || (key != null && ke
y.equals(k))))
 return first;

 //判断是否有后续节点
 if ((e = first.next) != null) {
 //如果当前的桶是采用红黑树处理冲突，则调用红黑树的 get 方法去获取节点
 if (first instanceof TreeNode)
 return ((TreeNode<K,V>)first).getTreeNode
(hash, key);
 //不是红黑树的话，那就是传统的链式结构了，通过循环的方法判断链中是否存在该 key
 do {
 if (e.hash == hash &&
 ((k = e.key) == key || (key != null && 
key.equals(k))))
 return e;
 } while ((e = e.next) != null);
 }
 }
 return null;
 }

实现步骤大致如下：
1、通过 hash 值获取该 key 映射到的桶。
2、桶上的 key 就是要查找的 key，则直接命中。
3、桶上的 key 不是要查找的 key，则查看后续节点：
（1）如果后续节点是树节点，通过调用树的方法查找该 key。
（2）如果后续节点是链式节点，则通过循环遍历链查找该 key。

put方法

 //put 方法的具体实现也是在 putVal 方法中，所以我们重点看下面的 putVal 方法
 public V put(K key, V value) {
 return putVal(hash(key), key, value, false, true);
 }
 final V putVal(int hash, K key, V value, boolean onlyIf
Absent,
 boolean evict) {
 Node<K,V>[] tab; Node<K,V> p; int n, i;
 //如果哈希表为空，则先创建一个哈希表
 if ((tab = table) == null || (n = tab.length) == 0)
 n = (tab = resize()).length;
 //如果当前桶没有碰撞冲突，则直接把键值对插入，完事
 if ((p = tab[i = (n - 1) & hash]) == null)
 tab[i] = newNode(hash, key, value, null);
 else {
 Node<K,V> e; K k;
 //如果桶上节点的 key 与当前 key 重复，那你就是我要找的节点了

 if (p.hash == hash &&
 ((k = p.key) == key || (key != null && key.equ
als(k))))
 e = p;
 //如果是采用红黑树的方式处理冲突，则通过红黑树的 putTreeVal 方法去插入这个键值对
 else if (p instanceof TreeNode)
 e = ((TreeNode<K,V>)p).putTreeVal(this, tab, 
hash, key, value);
 //否则就是传统的链式结构
 else {
 //采用循环遍历的方式，判断链中是否有重复的 key
 for (int binCount = 0; ; ++binCount) {
 //到了链尾还没找到重复的 key，则说明 HashMap 没有包含该键
 if ((e = p.next) == null) { 
 
 //创建一个新节点插入到尾部
 p.next = newNode(hash, key, value, nul
l);
 //如果链的长度大于 TREEIFY_THRESHOLD 这个临界值，则把链变为红黑树

 if (binCount >= TREEIFY_THRESHOLD - 1)
// -1 for 1st
 treeifyBin(tab, hash);
 break;
 }
 //找到了重复的 key
 if (e.hash == hash &&
 ((k = e.key) == key || (key != null && 
key.equals(k))))
 break;
 p = e;
 }
 }
 //这里表示在上面的操作中找到了重复的键，所以这里把该键的值替换为新值
 if (e != null) { // existing mapping for key
 V oldValue = e.value;
 if (!onlyIfAbsent || oldValue == null)
 e.value = value;
 afterNodeAccess(e);
 return oldValue;
 }
 }
 ++modCount;

 //判断是否需要进行扩容
 if (++size > threshold)
 resize();
 afterNodeInsertion(evict);
 return null;
 }

put 方法比较复杂，实现步骤大致如下：
1、先通过 hash 值计算出 key 映射到哪个桶。
2、如果桶上没有碰撞冲突，则直接插入。
3、如果出现碰撞冲突了，则需要处理冲突：
（1）如果该桶使用红黑树处理冲突，则调用红黑树的方法插入。
（2）否则采用传统的链式方法插入。如果链的长度到达临界值，则把链转变为红黑树。
4、如果桶中存在重复的键，则为该键替换新值。
5、如果 size 大于阈值，则进行扩容。

三、TreeMap

TreeMap存储 Key-Value 对时，需要根据 key-value 对进行排序。
TreeMap 可以保证所有的 Key-Value 对处于有序状态。

TreeSet底层使用红黑树结构存储数据
TreeMap 的 Key 的排序：
自然排序：TreeMap 的所有的 Key 必须实现 Comparable 接口，而且所有的 Key 应该是同一个类的对象，否则将会抛出 ClasssCastException
定制排序：创建 TreeMap 时，传入一个 Comparator 对象，该对象负责对TreeMap 中的所有 key 进行排序。此时不需要 Map 的 Key 实现Comparable 接口
TreeMap判断两个key相等的标准：两个key通过compareTo()方法或者compare()方法返回0。

四、Hashtable

Hashtable是个古老的 Map 实现类，JDK1.0就提供了。不同于HashMap，
Hashtable是线程安全的。

Hashtable实现原理和HashMap相同，功能相同。底层都使用哈希表结构，查询
速度快，很多情况下可以互用。  与HashMap不同，Hashtable 不允许使用 null 作为 key 和 value
与HashMap一样，Hashtable 也不能保证其中 Key-Value 对的顺序
Hashtable判断两个key相等、两个value相等的标准，与HashMap一致。

五、Properties

Properties 类是 Hashtable 的子类，该对象用于处理属性文件

由于属性文件里的 key、value 都是字符串类型，所以 Properties 里的 key 和 value 都是字符串类型
存取数据时，建议使用setProperty(String key,String value)方法和getProperty(String key)方法.

Properties pros = new Properties();
pros.load(new FileInputStream("jdbc.properties"));
String user = pros.getProperty("user");
System.out.println(user);

码农公寓