HashMap实现原理及自定义

Posted 2022-11-30 劲火星空

一、概念

什么是哈希表

哈希表（hash table）也叫散列表，是一种非常重要的数据结构，应用场景及其丰富，许多缓存技术（比如memcached）的核心其实就是在内存中维护一张大的哈希表，而HashMap的实现原理也常常出现在各类的面试题中，重要性可见一斑。本文会对java集合框架中的对应实现HashMap的实现原理进行讲解，然后会对JDK7的HashMap源码进行分析。
（1）定义       HashMap实现了Map接口，继承AbstractMap。其中Map接口定义了键映射到值的规则，而AbstractMap类提供 Map 接口的骨干实现，以最大限度地减少实现此接口所需的工作，其实AbstractMap类已经实现了Map，这里标注Map LZ觉得应该是更加清晰吧

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

（2）构造函数

    HashMap提供了三个构造函数：

    HashMap()：构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。

    HashMap(int initialCapacity)：构造一个带指定初始容量和默认加载因子 (0.75) 的空 HashMap。

    HashMap(int initialCapacity, float loadFactor)：构造一个带指定初始容量和加载因子的空 HashMap。

      在这里提到了两个参数：初始容量，加载因子。这两个参数是影响HashMap性能的重要参数，其中容量表示哈希表中桶的数量，初始容量是创建哈希表时的容量，加载因子是哈希表在其容量自动增加之前可以达到多满的一种尺度，它衡量的是一个散列表的空间的使用程度，负载因子越大表示散列表的装填程度越高，反之愈小。

（3）结构       我们知道在Java中最常用的两种结构是数组和模拟指针(引用)，几乎所有的数据结构都可以利用这两种来组合实现，HashMap也是如此。实际上HashMap是一个“链表散列”，如下是它数据结构：

可以看到是数组上面加了不同的链表，首先我们求Hash值，根据Hash值来尽心数组位置的查询，如果有冲突就查询key值是否相等，如果key值不相等就插入到链表头中，如果key值是相等的就会覆盖

二、源码

（1）构造函数的源码

public HashMap(int initialCapacity, float loadFactor) 
        //初始容量不能<0
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: "
                    + initialCapacity);
        //初始容量不能 > 最大容量值，HashMap的最大容量值为2^30
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        //负载因子不能 < 0
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: "
                    + loadFactor);

        // 计算出大于 initialCapacity 的最小的 2 的 n 次方值。
        int capacity = 1;
        while (capacity < initialCapacity)
            capacity <<= 1;
        
        this.loadFactor = loadFactor;
        //设置HashMap的容量极限，当HashMap的容量达到该极限时就会进行扩容操作
        threshold = (int) (capacity * loadFactor);
        //初始化table数组
        table = new Entry[capacity];
        init();
    

有一个静态内部类Entry，这个类就是key和value的类

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

（2）put 方法的实现

public V put(K key, V value) 
        //当key为null，调用putForNullKey方法，保存null与table第一个位置中，这是HashMap允许为null的原因
        if (key == null)
            return putForNullKey(value);
        //计算key的hash值
        int hash = hash(key.hashCode());                  ------(1)
        //计算key hash 值在 table 数组中的位置
        int i = indexFor(hash, table.length);             ------(2)
        //从i出开始迭代 e,找到 key 保存的位置
        for (Entry<K, V> e = table[i]; e != null; e = e.next) 
            Object k;
            //判断该条链上是否有hash值相同的(key相同)
            //若存在相同，则直接覆盖value，返回旧value
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) 
                V oldValue = e.value;    //旧值 = 新值
                e.value = value;
                e.recordAccess(this);
                return oldValue;     //返回旧值
            
        
        //修改次数增加1
        modCount++;
        //将key、value添加至i位置处
        addEntry(hash, key, value, i);
        return null;
    

通过源码我们可以清晰看到HashMap保存数据的过程为：首先判断key是否为null，若为null，则直接调用putForNullKey方法。若不为空则先计算key的hash值，然后根据hash值搜索在table数组中的索引位置，如果table数组在该位置处有元素，则通过比较是否存在相同的key，若存在则覆盖原来key的value，否则将该元素保存在链头（最先保存的元素放在链尾）。

static int hash(int h) 
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    

      我们知道对于HashMap的table而言，数据分布需要均匀（最好每项都只有一个元素，这样就可以直接找到），不能太紧也不能太松，太紧会导致查询速度慢，太松则浪费空间。计算hash值后，怎么才能保证table元素分布均与呢？我们会想到取模，但是由于取模的消耗较大，HashMap是这样处理的：调用indexFor方法。

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

这里一个比较关键的地方就是如果两个hash值相等且key值相等(e.hash == hash && ((k = e.key) == key || key.equals(k))),则用新的Entry的value覆盖原来节点的value。

（3）get 读取方法

      相对于HashMap的存而言，取就显得比较简单了。通过key的hash值找到在table数组中的索引处的Entry，然后返回该key对应的value即可。

public V get(Object key) 
        // 若为null，调用getForNullKey方法返回相对应的value
        if (key == null)
            return getForNullKey();
        // 根据该 key 的 hashCode 值计算它的 hash 码  
        int hash = hash(key.hashCode());
        // 取出 table 数组中指定索引处的值
        for (Entry<K, V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) 
            Object k;
            //若搜索的key与查找的key相同，则返回相对应的value
            if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
                return e.value;
        
        return null;
    

     在这里能够根据key快速的取到value除了和HashMap的数据结构密不可分外，还和Entry有莫大的关系，在前面就提到过，HashMap在存储过程中并没有将key，value分开来存储，而是当做一个整体key-value来处理的，这个整体就是Entry对象。同时value也只相当于key的附属而已。在存储的过程中，系统根据key的hashcode来决定Entry在table数组中的存储位置，在取的过程中同样根据key的hashcode取出相对应的Entry对象。

三、自定义

也是一个普通函数，一个get函数，还有一个Entry实体类

public class MyHashMap 

    private static int length = 10;
    private MyEntry[] entries;
    private int index = 0;

    public MyHashMap() 
        super();
        initinalize();
    

    public void initinalize() 
        entries = new MyEntry[length];
    

    // 添加键值对
    public String put(String key, String value) 

        // 要添加到的链表的下表
        int index = key.hashCode() % length;
        // 链表当前存储的第一个元素
        MyEntry privious = entries[index];

        // 有相同的key就覆盖
        for (MyEntry entry = entries[index]; entry != null; entry = entry.next) 
            if (entry.getKey().equals(key)) 
                // 替换value
                String oldValue = entry.getValue();
                entry.setValue(value);
                return oldValue;
            
        

        // 没有相同的key就添加,并且把这个键值对放在头部
        MyEntry entry = new MyEntry(key, value);
        entry.next = privious;
        entries[index] = entry;

        return null;
    

    // 根据key取值
    public String get(String key) 
        //  要查找的链表的位置
        int index = key.hashCode() % length;

        // 在链表中查找key对应的值
        for (MyEntry entry = entries[index]; entry != null; entry = entry.next) 
            if (entry.key.equals(key)) 
                return entry.getValue();
            
        

        return null;
    

    private final class MyEntry 
        private String key;
        private String value;
        private MyEntry next;

        public MyEntry() 
            super();
        

        public MyEntry(String key, String value) 
            super();
            this.key = key;
            this.value = value;
        

        public MyEntry(String key, String value, MyEntry next) 
            super();
            this.key = key;
            this.value = value;
            this.next = next;
        

        public String getKey() 

            return key;
        

        public void setKey(String key) 
            this.key = key;
        

        public String getValue() 
            return value;
        

        public void setValue(String value) 
            this.value = value;
        

        public MyEntry getNext() 
            return next;
        

        public void setNext(MyEntry next) 
            this.next = next;