java源码解读之HashMap------jdk 1.7

最新推荐文章于 2024-10-15 15:06:01 发布

冰凉的火焰

最新推荐文章于 2024-10-15 15:06:01 发布

阅读量350

点赞数

分类专栏： java java源码学习文章标签： java 源码

本文链接：https://blog.csdn.net/oHouZi123456/article/details/69952159

版权

java 同时被 2 个专栏收录

6 篇文章 0 订阅

订阅专栏

java源码学习

6 篇文章 0 订阅

订阅专栏

1. 定义
    Map与list不同是一种键值对的集合,包含了key和value.hashmap是用hash处理分配存储位置的对map接口的一种实现.

hash就是通过散列算法，将一个任意长度关键字转换为一个固定长度的散列值，但是有一点要指出的是，不同的关键字可能会散列出相同的散列值。

首先来看看map的接口定义：

public interface Map<K,V> {
    //获得容器内有多少元素
    int size();
    //获得容器内元素是否为零
    boolean isEmpty();
    //是否包含传入值
    boolean containsKey(Object key);
    //是否包含传入value
    boolean containsValue(Object value);
    //根据传入key获得value
    V get(Object key);
    //增加对象
    V put(K key, V value);
    //移除对象
    V remove(Object key);
    //根据传入集合增加多个对象
    void putAll(Map<? extends K, ? extends V> m);
    //清空容器
    void clear();
    //获得key的set类型集合
    Set<K> keySet();
    //获得value的集合
    Collection<V> values();
    //获得键值对的set集合
    Set<Map.Entry<K, V>> entrySet();
    //实现map的核心,put后都是用entry进行存储
    interface Entry<K,V> {
       V getValue();
       V setValue(V value);
        boolean equals(Object o);
        int hashCode();
    }
    boolean equals(Object o);
    int hashCode();
}

再看看HashMap的定义：

//AbstractMap是实现了map接口的一部分方法的抽象类,Cloneable表示支持克隆,Serializable接口表示启用序列化功能
public class HashMap<K,V>
    extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable

2. 属性

//默认容量
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//最大的容量,容量数最好是2的n次幂
static final int MAXIMUM_CAPACITY = 1 << 30;
//默认负载因子,size到达容量乘于负载因子就进行扩容
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//空的entry数组,创建hashmap的时候使用
static final Entry<?,?>[] EMPTY_TABLE = {};
//添加对象使用的entry数组
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
//总共有多少元素
transient int size;
//下次扩容的临界值=capacity*loadFactor
int threshold;
//负载因子
final float loadFactor;
//修改次数
transient int modCount;
//默认阈值
static final int ALTERNATIVE_HASHING_THRESHOLD_DEFAULT = Integer.MAX_VALUE;
//哈希种子，实例化HashMap后在将要使用前设置的随机值，可以使得key的hashCode冲突更难出现
transient int hashSeed = 0;

3.构造器

//自己设置临界值和负载因子的构造
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();
}
//单独设置临界值,负载因子使用默认值
public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
//用默认临界值和默认负载因子创建构造器
public HashMap() {
    this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
//根据传入的map的实现创建hashmap
public HashMap(Map<? extends K, ? extends V> m) {
    //判断传入map的capacity是否大于默认的容量16,如果大于则使用计算后的容量,否则使用默认容量
    this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1, DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
    //根据容量重新计算临界值
    inflateTable(threshold);
    //把传入map中的键和值遍历之后放入map
    putAllForCreate(m);
}
//现在来看看inflateTable方法里面是什么
private void inflateTable(int toSize) {
    //根据上方传入的临界值计算出容量
    int capacity = roundUpToPowerOf2(toSize);
    //根据负载因子重新计算,再通过比较获得小的那个临界值
    threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
    //创建对应容量的entry数组
    table = new Entry[capacity];
    //判断HashMap对象是否需要将存储数据的哈希表扩展到指定的容量,如果需要就进行扩容
    initHashSeedAsNeeded(capacity);
}
//简单解析下遍历map放入新map的方法
private void putAllForCreate(Map<? extends K, ? extends V> m) {
    //遍历key,value调用方法放入新map
    for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
        putForCreate(e.getKey(), e.getValue());
}
private void putForCreate(K key, V value) {
    //判断下key是否为null,为null进行特殊处理
    int hash = null == key ? 0 : hash(key);
    //获得hash计算后应该放置的位置
    int i = indexFor(hash, table.length);
    //遍历map如果map中已有传入map相同的key值,则覆盖value
    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;
        }
    }
    //如果没有对应key则新建一个entry放入
    createEntry(hash, key, value, i);
}
//createEntry简单看看就行
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++;
}
//hashmap有两层结构,一层是entry数组,entry是一个链表
Entry(int h, K k, V v, Entry<K,V> n) {
    value = v;
    next = n;
    key = k;
    hash = h;
}

4.解析部分方法源码

4.1 增加方法

public V put(K key, V value) {
    //如果table还是默认数组,重新计算临界值
    if (table == EMPTY_TABLE) {
        inflateTable(threshold);
    }
    //如果key为null,调用封装的方法放在table[0]的位置
    if (key == null)
        return putForNullKey(value);
    //计算hash值的
    int hash = hash(key);
    //计算出对应hash应该放置的位置,内部代码为return h & (length-1),这个比取模运算更快,只有当容量是2的n次方倍的时候才成立
    int i = indexFor(hash, table.length);
    //遍历查找key,有则覆盖value
    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;
        }
    }
    //没有则新增entry
    modCount++;
    addEntry(hash, key, value, i);
    return null;
}
//现在来看看具体是怎么计算位置的
static int indexFor(int h, int length) {
    //因为length是2的n次方,二进制就是1+n个0,(length-1)的二进制即为0+n个1,例如8的二进制为1000,8-1的二进制为0111.
    //所以当length为2的次方的时候,h & (length-1)等价于h%(length-1),而且比后一种更快
    return h & (length-1);
}
//仔细看看addEntry方法
void addEntry(int hash, K key, V value, int bucketIndex) {
    //当size大于临界值,并且对应位置已经有存放entry时扩容table
    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);
}
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];
    //复制旧map数据到新的map
    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;
        }
    }
}

4.2 删除方法

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;
    }
    //因为put方法放置null位置为table[0],所以若为null的hash直接为0,负责经过hash方法计算
    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
            //后续循环才会进这里,把链表中间去掉要删除的entry,然后两端连接
                prev.next = next;
            //这是个空方法
            e.recordRemoval(this);
            return e;
        }
        prev = e;
        e = next;
    }

    return e;
}

4.3 修改方法
这个没什么好说的,修改方法就是put方法,同个key,value会覆盖

4.4 查找方法

public V get(Object key) {
    //如果为null特殊处理
    if (key == null)
        return getForNullKey();
    //根据key获得对应entry
    Entry<K,V> entry = getEntry(key);
    return null == entry ? null : entry.getValue();
}
private V getForNullKey() {
    if (size == 0) {
        return null;
    }
    //前面已说过,key为null的entry是放在table[0]的位置
    for (Entry<K,V> e = table[0]; e != null; e = e.next) {
        if (e.key == null)
            return e.value;
    }
    return null;
}
final Entry<K,V> getEntry(Object key) {
    if (size == 0) {
        return null;
    }
    //根据hash值获得对应entry链表,然后遍历key获得对应entry
    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;
}

4.5 遍历方法

//这是一个视图,修改或者删除都会对原有map造成影响
private transient Set<Map.Entry<K,V>> entrySet = null;
public Set<Map.Entry<K,V>> entrySet() {
    return entrySet0();
}
private Set<Map.Entry<K,V>> entrySet0() {
    Set<Map.Entry<K,V>> es = entrySet;
    return es != null ? es : (entrySet = new EntrySet());
}
//获得数据是通过下方一层层调用实现的,最后遍历每个nextEntry
private final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
    public Iterator<Map.Entry<K,V>> iterator() {
        return newEntryIterator();
    }
    public boolean contains(Object o) {
        if (!(o instanceof Map.Entry))
            return false;
        Map.Entry<K,V> e = (Map.Entry<K,V>) o;
        Entry<K,V> 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();
    }
}
Iterator<Map.Entry<K,V>> newEntryIterator()   {
    return new EntryIterator();
}
private final class EntryIterator extends HashIterator<Map.Entry<K,V>> {
    //是通过调用这个next方法来进行遍历的
    public Map.Entry<K,V> next() {
        return nextEntry();
    }
}
//nextEntry是HashMap中一个内部抽象类HashIterator的一个方法,补充一下HashIterator的构造器
HashIterator() {
    expectedModCount = modCount;
    if (size > 0) {
        Entry[] t = table;
        //找到第一个不等于null的entry赋值给next
        while (index < t.length && (next = t[index++]) == null)
            ;
    }
}
final Entry<K,V> nextEntry() {
    //保证遍历过程中没有修改
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
    Entry<K,V> e = next;
    if (e == null)
        throw new NoSuchElementException();
    //如果next的下一个entry是null,通过循环查找下一个不为null的entry
    if ((next = e.next) == null) {
        Entry[] t = table;
        while (index < t.length && (next = t[index++]) == null)
            ;
    }
    //相当于把下一个entry赋值给现在的entry,然后return给调用者
    current = e;
    return e;
}