HashMap的实现原理及源码

最近看<java编程思想> 容器深入研究 这一章讲到了HashMap  散列表实现高速查询的实现思想.书中关于桶位讲解的有点抽象,故翻出HahsMap的实现源码来加深理解 


先来看HashMap几个重要的全局变量


static final float DEFAULT_LOAD_FACTOR = 0.75f;//默认负载因子
 transient Entry[] table;//内部数组,也是java编程思想里讲到的桶
 
  transient int size;

负载因子稍后再说, entry类型的数组 ,说明散列表内部也是由数组来实现的.大家都知道   HashMap保存的是entry对象 如下代码 : 

 static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next;
        final int hash;

        /**
         * Creates new entry.
         */
        Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        }
这是hashmap的静态内部类  .四个成员变量,除了我们已经知道的K和V,还有Entry类型的next,以及hash值.  很明显,Entry类型的next,说明entry还维护了一个单链表 

hash值是怎么来的呢  ?  看看hashmap的hash()方法 :

static int hash(int h) {
        // This function ensures that hashCodes that differ only by
        // constant multiples at each bit position have a bounded
        // number of collisions (approximately 8 at default load factor).
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }
 

还有indexFor()方法(put和get方法里都会用到):

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


运算过程就不说了 ,总而言之,是对KEY的hashcode值进行了处理,来看看hashmap的put方法:

 public V put(K key, V value) {
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key.hashCode());
        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;
    }
可以发现,put方法先用hash方法对key的hashcode值进行处理,然后调用indexFor方法生成int值,并以这个值作为数组的索引,定位到数组的位置(也就是所谓的槽位).然后遍历此数组索引位置保存的entry对象(实际上数组中保存的是链表的头结点,entry对象中有next属性保存了下个对象的地址).   然后判断此链表中是否有重复的key.判断方法  
if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
前面说过,entry对象中有一个hash属性,此属性即key的hashcode经过hash方法处理后的hash值,然后用equals比较.也就是我们说的,hashmap判断key是否相同时先判断hashcode值(内部保存的是经过处理的hash值),然后equals值是否相等 . 

如果存在此key,则修改entry对象的value值为要保存的新value,并返回旧的value

如果不存在此key,则添加此entry对象 

addEntry(hash, key, value, i);
addEntry方法代码:
void addEntry(int hash, K key, V value, int bucketIndex) {
	Entry<K,V> e = table[bucketIndex];
        table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
        if (size++ >= threshold)
            resize(2 * table.length);
    }

过程是先拿到当前槽位(数组的下标)处的entry对象,  然后根据要保存的key和value,以及key的hash值,以及之前取得的entry对象(当前数组保存的头结点)
,实例化一个新的entry对象,并把此新的entry对象更新到此槽位.
 table[bucketIndex] = new Entry<K,V>(hash, key, value, e);  这个过程实际上就是把要put进来的键值对对象,放到数组里,并设置成链表新的头结点
 if (size++ >= threshold)
            resize(2 * table.length);

这段代码是判断map容量,如果达到某种程度,则数组长度翻倍 .这和负载因子有关,稍后再说 .

然后来看get()方法:

public V get(Object key) {
        if (key == null)
            return getForNullKey();
        int hash = hash(key.hashCode());
        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.equals(k)))
                return e.value;
        }
        return null;
    }


也是先对参数key的hashcode值处理后得到hash值,indexfor方法处理后作为数组的下标,  然后遍历此数组下标位置保存的entry类型的链表 
对链表中的每一个entry对象 ,用之前put时同样的方法判断是否为同一个key:

if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
                return e.value;

如果entry对象的hash值和参数key的hash值相同,并且equals比较entry的key和参数key的值也相等,则取出此entry对象的value ,并return

最后总结: 因为线性查询效率低下(比如list,从头查到尾,遍历所有元素)
所以散列表实现高速查询的思路是让存放在map里的元素以某种规则放置,取出时也以这种规则取出 .此规则就是key的hashcode值

因为数组随机访问的效率最高,hashmap用数组来存放,通过对key的hashcode处理后,产生数组的下标,并把此entry对象存放在此处(存放的是链表的头结点).因为hashcode有可能重复,比如有两个对象,A 和B  ,A和B的hashcode值相同,但是我们不希望用B来做key存放元素时覆盖已经用A做KEY保存的元素.故这里数组实际上保存的是具有相同hashcode值的entry链表(准确说是链表的头结点)  

这样查询时  ,先根据key的hashcode值快速定位到数组的某个位置,因为数组随机访问效率高,所以此过程快速.然后线性查询此数组位置的链表就可以了  .虽然链表线性查询比较慢,但因为hashcode值相同的key较少,所以每个数组位置保存的链表的长度也较短,故而效率也比较快.   所以散列表的查询速度非常快

当然,当map比较满时,每个槽位存放的元素比较多,链表的长度比较长,查询时的速度也会降低,这时就会有负载因子来做调解 .如之前的代码:

 if (size++ >= threshold)
            resize(2 * table.length);

负载因子=HashMap中的数据量/HashMap的总容量(initialCapacity)

当map的充满大小超过负载因子指定的程度,hashmap会自动扩容(2倍),并且把已经存放的entry对象重新散列到扩容后的数组中去.hashmap默认的初始容量为16,默认负载因子为0.75  .可以通过hashmap的构造函数来指定初始值  手动调节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);

        // Find a power of 2 >= initialCapacity
        int capacity = 1;
        while (capacity < initialCapacity)
            capacity <<= 1;

        this.loadFactor = loadFactor;
        threshold = (int)(capacity * loadFactor);
        table = new Entry[capacity];
        init();
    }


  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
HashMap是Java中最常用的哈希表实现之一,它基于哈希表实现了Map接口。以下是HashMap源码的详细解释: HashMap内部是由一个数组和链表组成的,数组的每个元素称为桶,每个桶存储一个链表(可能为空),链表中的每个节点都是一个键值对(key-value pair)。 以下是HashMap的主要属性: ```java transient Node<K,V>[] table; // 存储元素的数组 transient int size; // 元素大小 int threshold; // 扩容阈值 final float loadFactor; // 负载因子 ``` 其中,table是一个transient修饰的Node数组,存储HashMap中的元素;size表示HashMap中元素的个数;threshold表示HashMap的扩容阈值,即当元素个数达到这个值时就需要扩容;loadFactor是负载因子,用于决定HashMap何时需要扩容。 以下是HashMap的主要方法: 1. put(K key, V value) :将指定的键值对添加到HashMap中,如果键已经存在,则更新对应的值。 2. get(Object key):获取指定键对应的值,如果键不存在则返回null。 3. remove(Object key):从HashMap中删除指定的键值对,如果键不存在则返回null。 4. clear():从HashMap中删除所有的键值对。 5. resize():扩容HashMap,将table的大小增加一倍。 6. hash(Object key):计算键的哈希值。 7. getNode(int hash, Object key):获取指定键的节点。 8. putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict):实际执行put操作的方法,会根据指定的参数决定是否更新已有键的值、是否删除过期键等。 HashMap的put方法实现如下: ```java public V put(K key, V value) { // 计算键的哈希值 int hash = hash(key); // 计算键在table数组中的索引 int i = indexFor(hash, table.length); // 遍历桶中的链表,查找指定键 for (Node<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; } ``` 在这个方法中,我们首先计算键的哈希值,然后计算键在table数组中的索引。接着,我们遍历桶中的链表,查找指定键,如果键已经存在,则更新对应的值。否则,我们创建新的节点,并将其添加到桶的链表中。 HashMap的get方法实现如下: ```java public V get(Object key) { // 计算键的哈希值 int hash = hash(key); // 计算键在table数组中的索引 int i = indexFor(hash, table.length); // 遍历桶中的链表,查找指定键 for (Node<K,V> e = table[i]; e != null; e = e.next) { Object k; if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { // 如果找到指定键,则返回其对应的值 return e.value; } } // 如果指定键不存在,则返回null return null; } ``` 在这个方法中,我们首先计算键的哈希值,然后计算键在table数组中的索引。接着,我们遍历桶中的链表,查找指定键,如果找到指定键,则返回其对应的值。 HashMap的remove方法实现如下: ```java public V remove(Object key) { // 计算键的哈希值 int hash = hash(key); // 计算键在table数组中的索引 int i = indexFor(hash, table.length); // 遍历桶中的链表,查找指定键 Node<K,V> prev = table[i]; Node<K,V> e = prev; while (e != null) { Node<K,V> next = e.next; Object k; if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { modCount++; size--; if (prev == e) { table[i] = next; } else { prev.next = next; } e.recordRemoval(this); return e.value; } prev = e; e = next; } // 如果指定键不存在,则返回null return null; } ``` 在这个方法中,我们首先计算键的哈希值,然后计算键在table数组中的索引。接着,我们遍历桶中的链表,查找指定键,如果找到指定键,则从链表中删除节点,并返回其对应的值。否则,我们返回null。 以上就是HashMap源码的详细解释。HashMap是一个非常常用且实用的数据结构,它的实现原理也非常值得深入学习和理解。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值