Map接口、HashMap源码详解
一、Map接口
从集合框架图来看：Map为collection的子接口，以key-value键值对的形式存储数据
- 数据结构: 哈希表
- 哈希表：通过关键码来映射到一个值的数据结构
- 哈希函数：键与值映射的一个映射关系 （哈希函数的具体方法（第9个））
二、HashMap
1、特点：
数据插入无序
值可以重复，键不能重复
键可以为null
2、常用方法介绍
- put（key，value）；//插入 键-值对
- int size();//map中存储键值对的个数
- get（Object key）；//通过键寻找值
- boolean isEmpty() //判空
- boolean containsValue(Object value)//判断值是否存在
- boolean containsKey(Object key) //判断键是否存在
- remove(Object key)//通过键删除键值对，
3、对hashMap集合的遍历（三种方式）
- 通过键值对遍历： 先将hashMap实例转化为set实例（类型为map.entry<>），
Iterator<Map.Entry<String,String>> iterator = hashMap.entrySet().iterator();
while(iterator.hasNext()){
Map.Entry<String,String> next = iterator.next();
String key = next.getKey();
String value = next.getValue();
System.out.print(key+":"+value+".");
}
- 通过键来遍历 （hashMap.keySet().iterator()）
Iterator<String> iterator1 = hashMap.keySet().iterator();
while(iterator1.hasNext()){
String next = iterator1.next();
System.out.print(next+".");
}
- 通过值来遍历 （ hashMap.values().iterator()）
Iterator<String> iterator2 = hashMap.values().iterator();
while(iterator2.hasNext()){
String next = iterator2.next();
System.out.print(next+" ");
}
4、JDK1.7源码分析
- 继承关系
继承了AbstractMap(jdk1.2开始)、实现了Map接口，可以克隆、可以序列化
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>,
Cloneable, Serializable
-
底层数据结构
数组+链表
【数组中存储的是一个个entry实体， hash到同一个索引位置的数据通过链表链接起来】 -
基本属性和默认值
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
哈希表中数组默认初始值大小为16
static final int MAXIMUM_CAPACITY = 1 << 30;
哈希表中数组最大容量值
static final float DEFAULT_LOAD_FACTOR = 0.75f;
默认的加载因子-》用来扩容使用
static final Entry<?,?>[] EMPTY_TABLE = {};
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
static class Entry<K,V>{
final K key; //键值对的key（键）
V value; //键值对的value（值）
Entry<K,V> next; //next节点
int hash; //和key相关的hash
- 构造函数：
1。指定初始容量、指定加载因子
public HashMap(int initialCapacity, float loadFactor) {
//基本参数校验
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
//加载因子、扩容阈值初始化
this.loadFactor = loadFactor;
threshold = initialCapacity;
init();
}
2。通过默认加载因子和默认初始容量
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
3。默认构造容量和默认加载因子
public HashMap() {
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
4。通过map集合来初始化当前集合
public HashMap(Map<? extends K, ? extends V> m) {
this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
inflateTable(threshold);
putAllForCreate(m);
}
- 增长方式：（扩容方式）
2倍扩容
①扩容时机：当前存储元素的个数size>=扩容阈值threshold时，考虑扩容（threshold=当前数组容量*加载因子。）
②扩容大小：二倍的数组大小table.length（数组要满足2的指数级关系）
//扩容完成后哈希函数会发生改变
扩容时创建一个新的table数组，并且将原来集合的元素全部哈希，找到新的对应位置进行插入
void resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
Entry[] newTable = new Entry[newCapacity];//创建一个新的table数组
transfer(newTable, initHashSeedAsNeeded(newCapacity));
table = newTable;
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
// transfer函数：(会引起CPU瞬间到100％)
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
for (Entry<K,V> e : table) {
while(null != e) {
Entry<K,V> next = e.next;
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i];
newTable[i] = e;
e = next;
// 新建节点，元素作为当前索引位置的头部元素进行插入
void createEntry(int hash, K key, V value, int bucketIndex) {
Entry<K,V> e = table[bucketIndex];
table[bucketIndex] = new Entry<>(hash, key, value, e);
size++;}
-
常用方法研究：
1. put（） 方法研究 *******HashMap的工作原理！！！！！
源码解析：
第一次插入元素，需要对数组进行初始化，数组长度为2的指数， 判断key为null或者非null当key不为null时,通过key哈希（hashing）来找到数据存在的索引位置，遍历该位置下的链表，（判断key是否存在，存在则替换value，不存在创建新的entry）
当key为null时,存在数组的索引为0的位置，遍历该位置下的链表，查看key为null的节点是否存在，存在的话，将value的值更新为传入的value，若该链表下不存key为null的节点，则创建新的entry节点插入该链表！
public V put(K key, V value) {
if (table == EMPTY_TABLE) {
inflateTable(threshold);
}
if (key == null) //key为null
return putForNullKey(value);
//key不为null
int hash = hash(key);
int i = indexFor(hash, table.length);
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;
}
}
modCount++;
addEntry(hash, key, value, i);
return null;
}
//key为null时：
private V putForNullKey(V value) {
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
if (e.key == null) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(0, null, value, 0);
return null;
}
- get（）方法研究:
源码解析:
通过键key来寻找value
①判断key是否为null，是则特殊处理，直接到0号索引位置查找元素
②当key！=null时,先通过哈希找到索引位置，通过索引位置找到当前链表，
进行遍历找key，通过判断key是否相等找到value进行返回
public V get(Object key) {
if (key == null)
return getForNullKey();
Entry<K,V> entry = getEntry(key);
return null == entry ? null : entry.getValue();
}