实战-深入剖析HashMap实现原理

最新推荐文章于 2024-08-02 15:49:51 发布

weixin_30708329

最新推荐文章于 2024-08-02 15:49:51 发布

阅读量143

点赞数

文章标签：数据库数据结构与算法 java

原文链接：http://www.cnblogs.com/zz-cl/p/6012510.html

版权

HashMap是继承至AbstractMap,基于Map接口的一种哈希表的实现。

public class HashMap<K,V>
    extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable

哈希表也叫散列表，是将存储元素（key-value键值对）通过hash算法（即散列函数）映射到表中对应的位置(一个有限的地址区间上)，以此来对元素进行直接访问，加快查找速度的数据结构。在HashMap中则是通过定义一个table[]数组

transient Entry[] table;

这里的transient表示定义了一个瞬时态变量。即不需要维持table的值，不想用serialization序列化机制来保存它

回顾Hibernate对象的3种状态，分别为：瞬时态(Transient)、持久态(Persistent)、脱管态(Detached)。

1、瞬时态(Transient)对应的是通过new命令开辟内存空间的java对象，瞬时对象在内存孤立存在，如果没有变量对该对象进行引用，它将被java虚拟机回收。它不和数据库的数据有任何关联关系，在Hibernate中，可通过session的save()或saveOrUpdate()方法将瞬时对象与数据库相关联，并将数据对应的插入数据库中，此时该瞬时对象转变成持久化对象。

2、持久态(Persistent)则是在数据库中有对应记录的对象，与session关联。

3、脱管态(Detached)，又称游离态，可以说在数据库中有对应记录的对象，但不与session关联。即是持久态对象关闭了session后的对象，但拥有数据库标识。相对于瞬时态而言，多了一个数据库记录标识值。
哈希算法则是将任意长度的输入(二进制)值映射为固定长度的输出(较小二进制)。运用hash算法加密比较著名的如：MD5，SHA-1加密，这些是不可逆的加密。(有一种简单的可逆加密算法：异或运算，原理：a^b=c;则有c^b=a)HashMap中则也是使用了hash算法来存储元素的

 static int hash(int h) {
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }
  static int indexFor(int h, int length) {
        return h & (length-1);
    }

HashMap里的hash(int h)方法根据key的hashCode重新计算一次散列。此算法加入了高位计算，防止低位不变，高位变化时，造成的hash冲突。

而indexFor方法设计的巧妙之处在于用按位与来代替取模运算(位运算效率明显高于其他运算)，但是这里的length必须是2的幂，这也是HashMap的容量设计capacity为什么一定要2的幂的原因。通过一个简单测试

 public static void main(String[] args) {  
    	int a=75%16;
    	int b=75&(16-1);
    	System.out.println(a);
    	System.out.println(b);

    }

测试结果

只要满足length是2的幂，h&(length-1)与h%length是等价的

hash和indexFor方法的作用，通过下图分析

hash的目的是让“1”变的均匀一些，散列的本意就是要尽量均匀分布元素，充分利用空间，也是方便在indexFor方法中拿到比较均匀的index。这也是因为HashMap的数据结构是数组和链表的结合，设计者就是想尽量地去一次性遍历数组拿到数据，降低去遍历链表的几率，从而大大地优化了查询效率。HashMap的数据结构图如下

对于Entry在HashMap中的设计是这样的

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

Entry就是HashMap里面定义的一个静态内部类，存放元素的键、值、hash值和指向下一个元素的next引用。

HashMap类相当于Hashtable,(除了Hashtable同步和不允许null)。HashMap不担保映射的顺序,特别是它不保证该顺序将随时间保持不变。

接下来介绍几个重要参数

 /**
     * 默认初始容量(16)——必须是2的幂
     */
    static final int DEFAULT_INITIAL_CAPACITY = 16; 
/**
     * 如果使用的最大容量,更高的价值是隐式地指定
     */
    static final int MAXIMUM_CAPACITY = 1 << 30;
/**
     * 当构造函数中没有指定时，默认的负载系数。
     */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
     * 扩容后的下一个大小值调整(容量*负载系数)，极限值。
    int threshold;
/**
     * 哈希表的负载系数。
    final float loadFactor;
 /**
    HashMap结构性修改的次数
   
*/
    transient volatile int modCount;

值得关注的是加了volatile修饰的modCount变量，这个变量是迭代器的快速失败原理fast-fail的运用，不会等到迭代结束再抛出异常。关于volatile的一些总结：

volatile原意:易变的；反复无常的；volatile修饰的变量是说这变量可能会被意想不到地改变，优化器每次都小心地重新去内存读取这个变量的值，而不是使用保存在寄存器里的备份。 volatile不具备原子性，volatile 变量不能用作线程安全计数器。虽然增量操作（x++）看上去类似一个单独操作，实际上它是一个由读取－修改－写入操作序列组成的组合操作，必须以原子方式执行，而 volatile 不能提供必须的原子特性。实现正确的操作需要使 x 的值在操作期间保持不变，而 volatile 变量无法实现这点。

volatile具备可见性，Volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。从而保证后一个拿到锁的线程读取到前一个线程修改后的值

modCount作用的核心代码如下

 private abstract class HashIterator<E> implements Iterator<E> {
        Entry<K,V> next;	// next entry to return
        int expectedModCount;	// For fast-fail
        int index;		// current slot
        Entry<K,V> current;	// current entry

        HashIterator() {
            expectedModCount = modCount;
            if (size > 0) { // advance to first entry
                Entry[] t = table;
                while (index < t.length && (next = t[index++]) == null)
                    ;
            }
        }

        public final boolean hasNext() {
            return next != null;
        }

        final Entry<K,V> nextEntry() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            Entry<K,V> e = next;
            if (e == null)
                throw new NoSuchElementException();

            if ((next = e.next) == null) {
                Entry[] t = table;
                while (index < t.length && (next = t[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;
        }

    }

通过研究源码，可以发现HashMap在添加、删除或修改元素时，都会执行modCount++，所有在使用迭代器遍历HashMap时，如果有其他线程对该HashMap进行了结构性的操作时，迭代器会发现并抛出ConcurrentModificationException异常

throw new ConcurrentModificationException();

而之前说的HashMap的容量是2的幂，这个又是怎么实现，怎么控制的呢？原理如下

int capacity = 1;
while (capacity < initialCapacity)
  capacity <<= 1;//通过向右移位(每当capacity小于初始化构造方法是传入的<span style="font-family: verdana, sans-serif;">initialCapacity值是，capacity值都会翻倍</span>)
this.loadFactor = loadFactor;
threshold = (int)(capacity * loadFactor);//极限值=集合容量*负载系数
table = new Entry[capacity];//根据capacity指定容量大小，为Entry数组开辟一块内存空间

既然HashMap底层数据结构是基于数组+链表，但存储的元素越来越多时，就要涉及到扩容了，着也是HashMap里对效率影响最大的耗时操作。因为扩充过程会导致元素数据的所有元素进行重新hash计算，这个过程也叫rehash。因此尽可能的选择合适的初始化大小是有效提高HashMap效率的关键。太大了会导致过多的浪费空间，太小了就可能会导致繁重的rehash过程。在这个过程中loadFactor也可以考虑。负载因子越大，空间的利用率越高，但从统计学角度讲意味着链表的长度就也大，也就是在查找元素的时候就需要更多次的循环。所以凡事必然是一个平衡的过程。
接下来就分析下扩容的过程：

首先要有触发条件，也就是什么时候会导致扩容，根源如下：

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

但size数组大于threshold极限值是，调用resize，扩容两倍。接下来就进入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);
        table = newTable;
        threshold = (int)(newCapacity * loadFactor);
    }

    /**
     * Transfers all entries from current table to newTable.
     */
    void transfer(Entry[] newTable) {
        Entry[] src = table;
        int newCapacity = newTable.length;
        for (int j = 0; j < src.length; j++) {
            Entry<K,V> e = src[j];
            if (e != null) {
                src[j] = null;
                do {
                    Entry<K,V> next = e.next;
                    int i = indexFor(e.hash, newCapacity);
                    e.next = newTable[i];
                    newTable[i] = e;
                    e = next;
                } while (e != null);
            }
        }
    }

集合，最主要的作用其实就是对其所持有的某类型的数据进行存储和读取。

接下来就分析一下HashMap对元素的存取过程。

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

当我们往HashMap中put元素的时候，先根据key的hashCode重新计算hash值，根据hash值得到这个元素在数组中的位置（即下标），如果数组该位置上已经存放有其他元素了，那么在这个位置上的元素将以链表的形式存放，新加入的放在链头，最先加入的放在链尾。如果数组该位置上没有元素，就直接将该元素放到此数组中的该位置上。对于null元素，则一般是存放在index=0的首元素。

addEntry(hash, key, value, i)方法根据计算出的hash值，将key-value对放在数组table的i索引处。addEntry 是 HashMap 提供的一个包访问权限的方法。

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，找到数组中对应位置的某一元素，然后通过key的equals方法在对应位置的链表中找到需要的元素。

转载于:https://www.cnblogs.com/zz-cl/p/6012510.html

weixin_30708329

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
实战-深入剖析HashMap实现原理

HashMap是继承至AbstractMap,基于Map接口的一种哈希表的实现。public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable哈希表也叫散列表，是将存储元素（key-value键值...
复制链接

扫一扫