码迷，mamicode.com
首页 > 编程语言 > 详细

Java 集合 - HashMap

时间：2016-05-19 11:55:28      阅读：236      评论：0      收藏：0      [点我收藏+]

标签：

一、源码解析

(1). 属性

 

// 默认初始化空间 = 16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

// 最大空间 = 2的30次方
static final int MAXIMUM_CAPACITY = 1 << 30;

// 默认加载因子 = 0.75
static final float DEFAULT_LOAD_FACTOR = 0.75f;

// 一个空的 Entry 数组
static final Entry<?,?>[] EMPTY_TABLE = {};

// HashMap 是数组 + 链表实现的，如下 table
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;

transient int size;

// 极限容量
int threshold;

// 加载因子
final float loadFactor;

 

(2). 构造方法

 

public HashMap(int initialCapacity, float loadFactor)：new hashmap，自定义初始化容量和加载因子

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(); // 空方法
}

 

// 构造方法。自定义初始化因子，加载因子为 0.75
public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

// 构造方法。创建一个初始化容量为 16 和加载因子为 0.75 的 HashMap
public HashMap() {
    this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}

 

public HashMap(Map<? extends K, ? extends V> m)：创建一个包含了一个 map 的 hashmap

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); // 为 map 添加元素之前先扩充空间

    putAllForCreate(m);
}

1). new hashmap，使用默认加载因子，根据所加入的 map 元素个数来计算应该需要多大的初始化容量。

2). inflateTable 数组初始化，new 出一个 table 数组，数组的长度为 2的 n次方数。（下面介绍）

3). putAllForCreate 往里面塞一个 map（下面介绍）

 

// 1. toSize 是初始化容量，roundUpToPowerOf2 方法得到一个最小的比 toSize 大的 2 的 n次方数，即实际初始化容量。比如：传进来的自定义容量是 15，经过 roundUpToPowerOf2 方法处理之后就会得到实际初始化容量 16
// 2. threshold 是极限容量，等于实际初始化容量 * 加载因子 0.75
// 3. new 数组
private void inflateTable(int toSize) {
    // Find a power of 2 >= toSize
    int capacity = roundUpToPowerOf2(toSize);

    threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
    table = new Entry[capacity];
    initHashSeedAsNeeded(capacity);
}


// 遍历 map，将 map 中的元素依次存入 hashmap
private void putAllForCreate(Map<? extends K, ? extends V> m) {
    for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
        putForCreate(e.getKey(), e.getValue());
}     

// 1. 根据 key 算出 hash 码
// 2. 根据 hash 码定位到应该存储在哪条链表中，得到数组的下标
// 3. 遍历链表如果找到了同样 key 的元素，跳过；如果找不到同样 key 的元素，调 createEntry 方法将该元素插入到这条链表的链首
private void putForCreate(K key, V value) {
    int hash = null == key ? 0 : 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 != null && key.equals(k)))) {
            e.value = value;
            return;
        }
    }

    createEntry(hash, key, value, i);
}

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

 

(3). Entry 类

 

// 单向链表结构
static class Entry<K,V> implements Map.Entry<K,V> {
    // 四个元素，key、value、next指针、hash 码
    final K key;
    V value;
    Entry<K,V> next;
    int hash;

    // 构造方法。创建一个 Entry 节点
    Entry(int h, K k, V v, Entry<K,V> n) {
        value = v;
        next = n;
        key = k;
        hash = h;
    }

    // 设置新 value，返回值为旧 value 值
    public final V setValue(V newValue) {
        V oldValue = value;
        value = newValue;
        return oldValue;
    }

    // 判断两个节点是否相等
    public final boolean equals(Object o) {
        if (!(o instanceof Map.Entry))
            return false;
        Map.Entry e = (Map.Entry)o;
        Object k1 = getKey();
        Object k2 = e.getKey();
        if (k1 == k2 || (k1 != null && k1.equals(k2))) {
            Object v1 = getValue();
            Object v2 = e.getValue();
            if (v1 == v2 || (v1 != null && v1.equals(v2)))
                return true;
        }
        return false;
    }

    public final int hashCode() {
        return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());
    }

    public final String toString() {
        return getKey() + "=" + getValue();
    }
    
    public final K getKey() {
        return key;
    }

    public final V getValue() {
        return value;
    }
}

hashmap 的元素其实就是一个个 Entry 类。

hashmap 维护了一个 table 数组，而数组中的元素就是 Entry。每个 Entry 拥有一个指向另一个 Entry 的引用 next。所以 hashmap 的存储结构简单来说就是多条链表的集合。

 

(4). hash

 

final int hash(Object k) {
    int h = hashSeed;
    if (0 != h && k instanceof String) {
        return sun.misc.Hashing.stringHash32((String) k);
    }

    h ^= k.hashCode();
    
    h ^= (h >>> 20) ^ (h >>> 12);
    return h ^ (h >>> 7) ^ (h >>> 4);
}

得到 hash 码（一个数学计算，不必关注）。
只要 hashcode() 返回值一样，得到的 hash 码也一定一样。

 

(5). indexFor

 

static int indexFor(int h, int length) {
    return h & (length-1);
}

这个方法可以 根据 hash 码和数组长度 定位这个元素应该存储在哪一条链表中，得到数组下标。

根据构造方法中可知，实际初始化容量是一个 2 的 n 次方数，所以 length 就是一个 2的 次方数，经过计算：

h=5, length=16, h & length - 1 得到 5；

h=6, length=16, h & length - 1 得到 6；

……

h=15, length=16, h & length - 1 得到 15

h=16, length=16, h & length - 1 得到 0

h=17, length=16, h & length - 1 得到 1

......

h &(table.length -1) 计算得到的索引值总是在 table 数组的索引值之内。

数组在进行构建的时候，使用这个方法得到元素的存储位置，从而能保证元素的均匀分布。

 

(6). resize

 

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];
    transfer(newTable, initHashSeedAsNeeded(newCapacity));
    table = newTable;
    threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}

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

扩充容量一定会重新构造 map 的存储结构。

1). 创建一个新的数组，长度为 newCapacity

2). 遍历旧的数组和链表，根据 hash 码和新数组的长度重新定位数组下标 index

3). 将该元素存储在数组 index 位置的链表中，且新存入的元素总是在链首。

 

使用链表存储为什么要对数组进行扩容呢 ?

扩容后 hashmap 的结构更优，效率更高。

 

那么何时会需要 resize 呢 ?

分两种情况：

1). 使用 put 方法逐个向 hashmap 中添加元素的时候，若 map 中的元素个数大于等于极限容量，就扩容为原来的两倍。（下面会有 put 方法）

2). 使用 putAll 方法向 hashmap 中添加一个集合的时候，经过一系列计算来判断是否需要扩容。（下面会有 putAll 方法）

 

需要注意的是，resize 要遍历旧数组和链表，并且为每个 key 生成索等，所以是很耗时的，所以要尽量减少 resize 操作。

比如，在向 hashmap 中增加一个 map 的时候，有人可能会想到遍历 map 然后逐个元素 put 到 hashmap 中，put 的时候逐个判断是否需要扩容。这样就太耗费时间了。

所幸源码中的方法无疑是很聪明的，在知道了 map 的大小之后，经过计算得出需要扩容的新容量，进行一次性扩容。

 

(7). put

 

public V put(K key, V value)：增加新的键值对或根据 key 替换掉旧的 value

public V put(K key, V value) {
    if (table == EMPTY_TABLE) {
        inflateTable(threshold);
    }
    if (key == null)
        return putForNullKey(value);
    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;
}

1). map 为空的话，进行数组初始化

2). 若 key == null，putForNullKey（下面介绍）

3). 若 key != null

　　先求出 hash 码

　　根据 hash 码判断该键值对应该存储在哪条链表中

　　得到该链表的链首 Entry 进行遍历寻找，如果找到了 key 值相同的节点，就给该节点赋新值并且返回旧值

　　如果找不到 key 值相同的节点，就在该链表增加一个节点，同时新增节点为链首，返回 null。

　　（其实和 key == null 的原理是一样的，只不过此种情况下需要先确定存储位置，剩下了就基本一样了）

 

// 为 key == null 的节点赋值（得到 table[0] 的链表遍历寻找，若能找到这个节点，则赋新值，返回旧值；若找不到，则为链表新增元素<null,value>，且该节点为链首，返回 null）
// 由此可见，如果存在 key == null 的元素，一定存在于 table[0] 的链表中
// 再想一下原因，key == null 得到的 hash 码为 0，hash * (length -1) = 0，所以应该存储在 table[0] 的链表中
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;
}

// 当元素个数 >= 极限容量  并且 Entry 数组 bucketIndex 位置的元素 != null 的时候。1. 容量扩充为原来的两倍 2. rehash 得到存储位置并存储
// 否则直接存储
void addEntry(int hash, K key, V value, int bucketIndex) {
    if ((size >= threshold) && (null != table[bucketIndex])) {
        resize(2 * table.length);
        hash = (null != key) ? hash(key) : 0;
        bucketIndex = indexFor(hash, table.length);
    }
    createEntry(hash, key, value, bucketIndex);
}

 

public void putAll(Map<? extends K, ? extends V> m)：为 hashmap 增加一个 map

public void putAll(Map<? extends K, ? extends V> m) {
    int numKeysToBeAdded = m.size();
    if (numKeysToBeAdded == 0)
        return;

    if (table == EMPTY_TABLE) {
        inflateTable((int) Math.max(numKeysToBeAdded * loadFactor, threshold));
    }

    // 判断是否需要扩容
    if (numKeysToBeAdded > threshold) {
        int targetCapacity = (int)(numKeysToBeAdded / loadFactor + 1); // 得到 m 需要的目标容量
        if (targetCapacity > MAXIMUM_CAPACITY)
            targetCapacity = MAXIMUM_CAPACITY;
        int newCapacity = table.length;                                // 数组现有的容量
        while (newCapacity < targetCapacity)                           // 若数组现有容量 < 存储 m 需要的目标容量，数组现有容量扩大为两倍，循环比较下去
            newCapacity <<= 1;                                         
        if (newCapacity > table.length)                                // 若前面 newCapacity 有增大，就为数组扩容为 newCapacity。最后扩充容量之后足以存储 putAll 之后的数组了
            resize(newCapacity);
    }

    for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
        put(e.getKey(), e.getValue());
}

1). m 元素个数为0，不用操作了

2). 如果 table 为空，就得先初始化了

3). 判断是否需要扩容（不必深究）

4). 遍历 m，一个一个 put

 

(8). get

 

public V get(Object key)

public V get(Object key) {
    if (key == null)
        return getForNullKey();
    Entry<K,V> entry = getEntry(key);

    return null == entry ? null : entry.getValue();
}

1). 若 key == null，就会调 getForNullKey，若得到就会返回 value，找不到就会返回 null

2). 若 key != null，就会找该 Entry，若得到就会返回 value，找不到就会返回 null

 

相关方法如下：

// 1. 数组长度为0，找不到，返回 null
// 2. 遍历数组和链表进行寻找，找得到就返回 value，找不到就返回 null
private V getForNullKey() {
    if (size == 0) {
        return null;
    }
    for (Entry<K,V> e = table[0]; e != null; e = e.next) {
        if (e.key == null)
            return e.value;
    }
    return null;
}

// 根据 key 值寻找 Entry
// 1. 数组长度为0，找不到，返回 null
// 2. 根据 key 值得到 hash 码，再根据 hash 码得到应该存储在数组的那个位置
// 3. 在数组的该位置从链首开始遍历寻找，找得到就返回 value，找不到就返回 null
final Entry<K,V> getEntry(Object key) {
    if (size == 0) {
        return null;
    }

    int hash = (key == null) ? 0 : hash(key);
    for (Entry<K,V> 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;
}

 

(9). remove

 

public V remove(Object key)：根据 key 删除元素

public V remove(Object key) {
    Entry<K,V> e = removeEntryForKey(key);
    return (e == null ? null : e.value);
}

final Entry<K,V> removeEntryForKey(Object key) {
    if (size == 0) {
        return null;
    }
    int hash = (key == null) ? 0 : hash(key);
    int i = indexFor(hash, table.length);
    Entry<K,V> prev = table[i];
    Entry<K,V> e = prev;

    while (e != null) {
        Entry<K,V> 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). 如果元素个数为0，就直接返回 null

2). 元素个数不为 0，根据 key 得到 hash 码，根据 hash 码定位数组下标

3). 得到数组在该位置的 Entry，遍历如果找得到这个 key 就删除该元素并且返回该元素，找不到返回 null

 

final Entry<K,V> removeMapping(Object o) {
    if (size == 0 || !(o instanceof Map.Entry))
        return null;

    Map.Entry<K,V> entry = (Map.Entry<K,V>) o;
    Object key = entry.getKey();
    int hash = (key == null) ? 0 : hash(key);
    int i = indexFor(hash, table.length);
    Entry<K,V> prev = table[i];
    Entry<K,V> e = prev;

    while (e != null) {
        Entry<K,V> next = e.next;
        if (e.hash == hash && e.equals(entry)) {
            modCount++;
            size--;
            if (prev == e)
                table[i] = next;
            else
                prev.next = next;
            e.recordRemoval(this);
            return e;
        }
        prev = e;
        e = next;
    }

    return e;
}

 

public void clear()：清空 hashmap

public void clear() {
    modCount++;
    Arrays.fill(table, null);
    size = 0;
}

 

(10). 其他方法

 

// 判断是否包含 value
// 遍历数组和链表进行寻找。
public boolean containsValue(Object value) {
    if (value == null)
        return containsNullValue();

    Entry[] tab = table;
    for (int i = 0; i < tab.length ; i++)
        for (Entry e = tab[i] ; e != null ; e = e.next)
            if (value.equals(e.value))
                return true;
    return false;
}
private boolean containsNullValue() {
    Entry[] tab = table;
    for (int i = 0; i < tab.length ; i++)
        for (Entry e = tab[i] ; e != null ; e = e.next)
            if (e.value == null)
                return true;
    return false;
}   
    
    
    
// 得到元素个数
public int size() {
    return size;
}

// 判断是否为空
public boolean isEmpty() {
    return size == 0;
}

// 判断是否包含 key
public boolean containsKey(Object key) {
    return getEntry(key) != null;
}

// 影子克隆，没有克隆元素
public Object clone() {
    HashMap<K,V> result = null;
    try {
        result = (HashMap<K,V>)super.clone();
    } catch (CloneNotSupportedException e) {
        // assert false;
    }
    if (result.table != EMPTY_TABLE) {
        result.inflateTable(Math.min((int) Math.min(size * Math.min(1 / loadFactor, 4.0f),HashMap.MAXIMUM_CAPACITY),table.length));
    }
    result.entrySet = null;
    result.modCount = 0;
    result.size = 0;
    result.init();
    result.putAllForCreate(this);

    return result;
}

 

二、总结

说说源码解析中没有提到的

(1). 一些特性：

1). 不保证顺序，并且不保证顺序永远不变，因为 resize 后会重构数据结构

2). 支持空的 key 和 空的 value

(2). fast-fail 机制：原理同 ArrayList

 

Java 集合 - HashMap

标签：

原文地址：http://www.cnblogs.com/xmsx/p/5502180.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！