前面，我们已对List进行了学习，接下来，我们先学习Map，然后再学习Set；因为Set的实现类都是基于Map实现的（如HashSet是通过HashMap实现的，TreeSet是通过TreeMap实现的）
HashMap是一个散列表（链表+数组），它存储的内容是键值对（Key-Value）映射
HashMap继承于AbstractMap，实现了Map、Cloneable、java.io.Serializable接口。
HashMap的实现是非同步的，意味着它不是线程安全的。它的Key、Value值都可以为空，并且HashMap中的映射不是有序的。
面试易考点：
| 关注点 | 结论 |
|---|---|
| 结合底层实现的数据结构 | 散列表（数组+列表） |
| 集合中元素是否允许为空 | Key和value都可以为空 |
| 是否允许数据重复 | key值会被覆盖，value允许重复 |
| 是否有序 | 无序，是指不是按put添加的顺序 |
| 是否线程安全 | 非线程安全（不是同步的） |
1> HashMap的实例有两个参数影响其性能：“初始容量”和“加载因子”。“容量”是哈希表中桶的数量，“初始容量”只是哈希表在创建时的容量。“加载因子”是哈希表在其容量自增所达到的一种尺度。当哈希表中的内容超过了加载因子与当前容量的乘积时，则要对该哈希表进行rehash操作（即重建内部数据结构），从而哈希表将具有大约两倍的容量。
通常默认的加载因子为0.75，这是在时间和空间复杂度上的一种折中。加载因子过高尽管减少了空间开销，但同时也增加了查询成本（在大多数HashMap类的操作中，包括get和put操作）。在设置初始容量时应该考虑到映射中所需的条目数量以及加载因子，以便最大限度减少rehash操作次数。如果初始容量>(最大条目数/加载因子)，则不会发生rehash操作。
2> HashMap构造函数
// 默认构造函数。
public HashMap() {
// 设置“加载因子”
this.loadFactor = DEFAULT_LOAD_FACTOR;
// 设置“HashMap阈值”，当HashMap中存储数据的数量达到threshold时，就需要将HashMap的容量加倍。
threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
// 创建Entry数组，用来保存数据
table = new Entry[DEFAULT_INITIAL_CAPACITY];
init();
}
// 指定“容量大小”和“加载因子”的构造函数
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity <0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
// HashMap的最大容量只能是MAXIMUM_CAPACITY
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
// Find a power of 2 >= initialCapacity
int capacity = 1;
while (capacity 1;
// 设置“加载因子”
this.loadFactor = loadFactor;
// 设置“HashMap阈值”，当HashMap中存储数据的数量达到threshold时，就需要将HashMap的容量加倍。
threshold = (int)(capacity * loadFactor);
// 创建Entry数组，用来保存数据
table = new Entry[capacity];
init();
}
// 指定“容量大小”的构造函数
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
// 包含“子Map”的构造函数
public HashMap(Map m) {
this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
// 将m中的全部元素逐个添加到HashMap中
putAllForCreate(m);
}
3>HashMap的的重要特性
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
// 系统默认初始容量，必须是2的n次幂，这是出于优化考虑的
static final int DEFAULT_INITIAL_CAPACITY = 16;
// 系统默认最大容量
static final int MAXIMUM_CAPACITY = 1 <<30;
// 系统默认负载因子0.75，可在构造函数中指定
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 用于存储的表，长度可以调整，且必须是2的n次幂
transient Entry[] table;
// 当前map的key-value映射数，也就是当前size
transient int size;
// 阈值
int threshold;
// 哈希表的负载因子
final float loadFactor;
// 用于确保使用迭代器的时候，HashMap并未进行更改
transient volatile int modCount;
// 构造一个带指定初始容量和加载因子的空 HashMap。
public HashMap(int initialCapacity, float loadFactor) {
// 如果指定初始容量小于0，抛错
if (initialCapacity <0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
// 如果初始容量大于系统默认最大容量，则初始容量为最大容量
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
// 如果loadFactor小于0，或loadFactor是NaN，则抛错
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
// 寻找一个2的k次幂capacity恰好大于initialCapacity
int capacity = 1;
while (capacity 1;
// 设置负载因子
this.loadFactor = loadFactor;
// 设置阈值为capacity * loadFactor，实际上当HashMap当前size到达这个阈值时，HashMap就需要扩大一倍了。
threshold = (int)(capacity * loadFactor);
// 创建一个capacity长度的数组用于保存数据
table = new Entry[capacity];
// 开始初始化
init();
} 结合上述代码，对其变量进行分析：
1>HashMap继承于AbstractMap类，实现了Map接口,Map是key-value键值对接口，AbstractMap实现了键值对的通用函数接口。
2>HashMapa是通过“拉链法”实现的哈希表。它包括几个重要的成员变量：table，size，threshold，loadFactor，modCount。
table：是一个Entry[]数组类型。而Entry、实际是一个单向链表。哈希标的键值对都是保存在Entry数组中的。
size：HashMap的大小，它是HashMap保存的键值对的数；
threshold是HashMap的阈值，用于判断是否需要调整HashMap的容量；
threshold=容量*加载因子，当HashMap中存储数据的数量达到threshold时，就需要将HashMap的容量加倍；
loadFactor就是加载因子；
modCount是用来实现fail-fast机制。
1>
clear():
用于清空HashMap。它是通过将所有的元素设为null来实现的。源码如下：
public void clear() {
modCount++;
Entry[] tab = table;
for (int i = 0; i null;
size = 0;
} 2>containsKey()
用于判断HashMap是否包含key。源码如下：
public boolean containsKey(Object key) { return getEntry(key) != null; } 由上面代码可以得到，首先通过getEntry（key）获取对应的Entry，然后判断该Entry是否为null，则getEntry（）源码如下：
final Entry getEntry(Object key) {
// 获取哈希值
// HashMap将“key为null”的元素存储在table[0]位置，“key不为null”的则调用hash()计算哈希值
int hash = (key == null) ? 0 : hash(key.hashCode());
// 在“该hash值对应的链表”上查找“键值等于key”的元素
for (Entry e = table[indexFor(hash, table.length)];
e != null;
e = e.next) {
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
}
return null;
} getEntry（）的作用就是返回键值为key的键值对。
注意点：HashMap将“key为null”的元素都放在table的位置0处，即table[0];key不是null的则放在其它处。
3>containsValue()
用于判断HashMap是否包含“值为value”的元素，源码如下：
public boolean containsValue(Object value) {
// 若“value为null”，则调用containsNullValue()查找
if (value == null)
return containsNullValue();
// 若“value不为null”，则查找HashMap中是否有值为value的节点。
Entry[] tab = table;
for (int i = 0; i for (Entry e = tab[i] ; e != null ; e = e.next)
if (value.equals(e.value))
return true;
return false;
} 由代码可以得出，containsValue()处理：一：若value为空，则调用containsNullValue()；二：若value不为null，则查找HashMap中是否有值为value的节点。
containsNullValue() 的作用判断HashMap中是否包含“值为null”的元素。
private boolean containsNullValue() {
Entry[] tab = table;
for (int i = 0; i for (Entry e = tab[i] ; e != null ; e = e.next)
if (e.value == null)
return true;
return false;
} 4>entrySet()、values()、keySet()
三者实现原理相似，以entrySet（）为例。
entrySet（）是返回“HashMap中所有Entry的集合”，它是一个集合。实现代码如下：
// 返回“HashMap的Entry集合”
public Set> entrySet() {
return entrySet0();
}
// 返回“HashMap的Entry集合”，它实际是返回一个EntrySet对象
private Set> entrySet0() {
Set> es = entrySet;
return es != null ? es : (entrySet = new EntrySet());
}
// EntrySet对应的集合
// EntrySet继承于AbstractSet，说明该集合中没有重复的EntrySet。
private final class EntrySet extends AbstractSet> {
public Iterator> iterator() {
return newEntryIterator();
}
public boolean contains(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry e = (Map.Entry) o;
Entry candidate = getEntry(e.getKey());
return candidate != null && candidate.equals(e);
}
public boolean remove(Object o) {
return removeMapping(o) != null;
}
public int size() {
return size;
}
public void clear() {
HashMap.this.clear();
}
} HashMap是通过链表法实现的散列表。表现在HashMap包括许多的Entry，而每一个ENtry都是一个单向链表。当HashMap遍历key-value键值对时，是通过newEntryIterator()逐个去遍历实现的，代码如下：
// 返回一个“entry迭代器”
Iterator> newEntryIterator() {
return new EntryIterator();
}
// Entry的迭代器
private final class EntryIterator extends HashIterator<Map.Entry<K,V>> {
public Map.Entry next() {
return nextEntry();
}
}
// HashIterator是HashMap迭代器的抽象出来的父类，实现了公共了函数。
// 它包含“key迭代器(KeyIterator)”、“Value迭代器(ValueIterator)”和“Entry迭代器(EntryIterator)”3个子类。
private abstract class HashIterator<E> implements Iterator<E> {
// 下一个元素
Entry next;
// expectedModCount用于实现fast-fail机制。
int expectedModCount;
// 当前索引
int index;
// 当前元素
Entry current;
HashIterator() {
expectedModCount = modCount;
if (size > 0) { // advance to first entry
Entry[] t = table;
// 将next指向table中第一个不为null的元素。
// 这里利用了index的初始值为0，从0开始依次向后遍历，直到找到不为null的元素就退出循环。
while (index index++]) == null)
;
}
}
public final boolean hasNext() {
return next != null;
}
// 获取下一个元素
final Entry nextEntry() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
Entry e = next;
if (e == null)
throw new NoSuchElementException();
// 注意！！！
// 一个Entry就是一个单向链表
// 若该Entry的下一个节点不为空，就将next指向下一个节点;
// 否则，将next指向下一个链表(也是下一个Entry)的不为null的节点。
if ((next = e.next) == null) {
Entry[] t = table;
while (index index++]) == null)
;
}
current = e;
return e;
}
// 删除当前元素
public void remove() {
if (current == null)
throw new IllegalStateException();
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
Object k = current.key;
current = null;
HashMap.this.removeEntryForKey(k);
expectedModCount = modCount;
}
} 当我们通过entrySet()获取到的Iterator的next()方法去遍历HashMap时，实际上调用的是 nextEntry() 。而nextEntry()的实现方式，先遍历Entry(根据Entry在table中的序号，从小到大的遍历)；然后对每个Entry(即每个单向链表)，逐个遍历。
5>get()
用于获取key对应的value，代码如下：
public V get(Object key) {
if (key == null)
return getForNullKey();
// 获取key的hash值
int hash = hash(key.hashCode());
// 在“该hash值对应的链表”上查找“键值等于key”的元素
for (Entry e = table[indexFor(hash, table.length)];
e != null;
e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
return e.value;
}
return null;
} 6>put()
用于对外提供接口，让HashMap对象通过put（）将键值对添加到HashMap中，代码如下：
public V put(K key, V value) {
// 若“key为null”，则将该键值对添加到table[0]中。
if (key == null)
return putForNullKey(value);
// 若“key不为null”，则计算该key的哈希值，然后将其添加到该哈希值对应的链表中。
int hash = hash(key.hashCode());
int i = indexFor(hash, table.length);
for (Entry e = table[i]; e != null; e = e.next) {
Object k;
// 若“该key”对应的键值对已经存在，则用新的value取代旧的value。然后退出！
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
// 若“该key”对应的键值对不存在，则将“key-value”添加到table中
modCount++;
addEntry(hash, key, value, i);
return null;
} 若要添加到HashMap中的键值对对应的key已经存在HashMap中，则找到该键值对；然后新的value取代旧的value，并退出！
若要添加到HashMap中的键值对对应的key不在HashMap中，则将其添加到该哈希值对应的链表中，并调用addEntry()。
下面看看addEntry()的代码：
void addEntry(int hash, K key, V value, int bucketIndex) {
// 保存“bucketIndex”位置的值到“e”中
Entry e = table[bucketIndex];
// 设置“bucketIndex”位置的元素为“新Entry”，
// 设置“e”为“新Entry的下一个节点”
table[bucketIndex] = new Entry(hash, key, value, e);
// 若HashMap的实际大小 不小于 “阈值”，则调整HashMap的大小
if (size++ >= threshold)
resize(2 * table.length);
} 此时就涉及到addEntry()和createEntry（）的区别。
a、addEntry（）一般用在新增Entry可鞥呢导致HahsMap实际容量超过阈值的情况。例：新建一个HashMap，然后不断通过put()向HashMap中添加元素；put()是通过addEntry()新增Entry的。
在这种情况下，我们不知道何时“HashMap的实际容量”会超过“阈值”；因此，需要调用addEntry()；
b、createEntry() 一般用在 新增Entry不会导致“HashMap的实际容量”超过“阈值”的情况下。例:调用HashMap“带有Map”的构造函数，它绘将Map的全部元素添加到HashMap中；
但在添加之前，我们已经计算好“HashMap的容量和阈值”。也就是，可以确定“即使将Map中的全部元素添加到HashMap中，都不会超过HashMap的阈值”。此时，调用createEntry()即可。
7>remove()
用于删除键为key的元素
public V remove(Object key) {
Entry e = removeEntryForKey(key);
return (e == null ? null : e.value);
}
// 删除“键为key”的元素
final Entry removeEntryForKey(Object key) {
// 获取哈希值。若key为null，则哈希值为0；否则调用hash()进行计算
int hash = (key == null) ? 0 : hash(key.hashCode());
int i = indexFor(hash, table.length);
Entry prev = table[i];
Entry e = prev;
// 删除链表中“键为key”的元素
// 本质是“删除单向链表中的节点”
while (e != null) {
Entry next = e.next;
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k)))) {
modCount++;
size--;
if (prev == e)
table[i] = next;
else
prev.next = next;
e.recordRemoval(this);
return e;
}
prev = e;
e = next;
}
return e;
} 1、遍历HashMap的键值对
// 假设map是HashMap对象
// map中的key是String类型，value是Integer类型
Integer integ = null;
Iterator iter = map.entrySet().iterator();
while(iter.hasNext()) {
Map.Entry entry = (Map.Entry)iter.next();
// 获取key
key = (String)entry.getKey();
// 获取value
integ = (Integer)entry.getValue();
}2、遍历HashMap的键
// 假设map是HashMap对象
// map中的key是String类型，value是Integer类型
String key = null;
Integer integ = null;
Iterator iter = map.keySet().iterator();
while (iter.hasNext()) {
// 获取key
key = (String)iter.next();
// 根据key，获取value
integ = (Integer)map.get(key);
}3、遍历HashMap的值
// 假设map是HashMap对象
// map中的key是String类型，value是Integer类型
Integer value = null;
Collection c = map.values();
Iterator iter= c.iterator();
while (iter.hasNext()) {
value = (Integer)iter.next();
}package Test;
/** * Created by LKL on 2017/2/17. */
import java.util.Map;
import java.util.Random;
import java.util.Iterator;
import java.util.HashMap;
/* * HashMap测试程序 */
public class TestHashMap {
public static void main(String[] args) {
testHashMapAPIs();
}
private static void testHashMapAPIs() {
// 初始化随机种子
Random r = new Random();
// 新建HashMap
HashMap map = new HashMap();
// 添加操作
map.put("one", r.nextInt(10));
map.put("two", r.nextInt(10));
map.put("three", r.nextInt(10));
// 打印出map
System.out.println("map:"+map );
// 通过Iterator遍历key-value
Iterator iter = map.entrySet().iterator();
while(iter.hasNext()) {
Map.Entry entry = (Map.Entry)iter.next();
System.out.println("next : "+ entry.getKey() +" - "+entry.getValue());
}
// HashMap的键值对个数
System.out.println("size:"+map.size());
// containsKey(Object key) :是否包含键key
System.out.println("contains key two : "+map.containsKey("two"));
System.out.println("contains key five : "+map.containsKey("five"));
// containsValue(Object value) :是否包含值value
System.out.println("contains value 0 : "+map.containsValue(new Integer(0)));
// remove(Object key) ： 删除键key对应的键值对
map.remove("three");
System.out.println("map:"+map );
// clear() ： 清空HashMap
map.clear();
// isEmpty() : HashMap是否为空
System.out.println((map.isEmpty()?"map is empty":"map is not empty") );
}
}运行结果如下：
map:{one=9, two=4, three=1}
next : one - 9
next : two - 4
next : three - 1
size:3
contains key two : true
contains key five : false
contains value 0 : false
map:{one=9, two=4}
map is empty文章只是作为自己的学习笔记，借鉴了网上的许多案例，如果觉得阔以的话，希望多交流，在此
谢过…
京公网安备 11010802041100号 | 京ICP备19059560号-4 | PHP1.CN 第一PHP社区 版权所有