HashMap原理剖析

什么叫hash？

就是把一个不固定的长度的二进制值映射成一个固定长度的二进制值。

hash算法：就是对应的这个映射规则。
hash值：固定长度的二进制值。

什么叫hash表？HashMap底层的存储结构就是hashtable。

什么是hash算法？

1、除留余数法（应用于根据key找到hash表的index值）
key % table.length = index 得到的这个index数字就是对应的hashtable的索引

2、冲突解决（冲突hashtable中的元素index相同）
table.length = 10
对应的hash值key.hashCode() = 2
2 % 10 = 2

另一个key对应的hash值key.hashCode() = 12
12 % 10 = 2

那么，该如何解决？

解决hash冲突

01.冲突过程：key4占掉key3的位置（后进来的元素占掉先进来的）
02.那么key3去哪混？
key4中的next指针会指向key3的位置（Obejct key4_next = new Object(key3)）

下面我们jdk源码的实现方式自定义一个简化版的HashMap，以便于加深理解。

1.定义MyMap接口

package cn.yzx.hashmap;
/**
 * 自定义的Map接口
 * @author Xuas
 *
 */
public interface MyMap<K,V> {
    
    public V put(K k,V v);//将k v属性包装成对象存储到hash表中
    
    public V get(K k);//根据key获取value
    
    public int size();//获取hash表的长度
    
    /**
     * 内部接口Entry<K,V>
     *         Entry对象就是存储到hash表中的数据对象
     *         hash表中每个元素存储的数据结构是一个Entry对象（包括key,value,next指针三个属性）
     */
    public interface Entry<K,V> {
        public K getKey();//获取key
        public V getValue();//获取value
    }
}

2.定义MyHashMap实现类

package cn.yzx.hashmap;

import java.util.ArrayList;
import java.util.List;

public class MyHashMap<K,V> implements MyMap<K, V> {

    /**
     * hash表的默认长度
     * jdk中的static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
     */
    private static int defaultLength = 16;
    
    /**
     * 负载因子（阈值）
     * 当表中元素数量超过 表容量 * 负载因子，那么表长度就需要扩容。（预警作用）
     * static final float DEFAULT_LOAD_FACTOR = 0.75f;
     */
    private static double defaultLoader = 0.75;
    
    /**
     * 表中存储元素的个数
     */
    private int size = 0;
    
    /**
     * 存储数据的Entry[]
     */
    private Entry<K,V>[] table = null;
    
    /**
     * 构造初始化属性值
     * public HashMap(int initialCapacity, float loadFactor) {}
     * @param length
     * @param loader
     */
    public MyHashMap(int length,double loader) {
        defaultLength = length;
        defaultLoader = loader;
        table = new Entry[defaultLength];
    }
    
    /**
     * 无参构造使用默认值
     */
    public MyHashMap() {
        this(defaultLength, defaultLoader);
    }
    
    /**
     * 需要把k,v存储到hash表中
     */
    @Override
    public V put(K k, V v) {
        
        if(size >= defaultLength * defaultLoader) {//进行扩容
            up2size();
        }
        
        //01.获取表中索引
        int index = getIndex(k);
        //02.判断此index上是否存在数据
        Entry<K,V> entry = table[index];
        if(null == entry) {//为空进行填充entry数据
            table[index] = new Entry(k,v,null);//因entry==null,故next为null
            size++;
        }else {//此index上存在数据
            table[index] = newEntry(k,v,entry);//新entry覆盖此位置上的原entry，并将新entry的next指针指向原entry
            size++;
        }
        
        return table[index].getValue();
    }
    
    /**
     * 实例化Entry对象
     * @param k
     * @param v
     * @return
     */
    private Entry<K,V> newEntry(K k,V v,Entry<K,V> next) {
        return new Entry(k,v,next);
    }
    
    /**
     * 扩容：默认扩容是扩大一倍
     * 疑问：扩容后原表中的元素在新表中的位置会变化吗？
     * 一定会。因为表中索引index是通过hash算法得到的。即：除留余数法 key.hashCode() % table.length = index
     * 这个table.length已经变化了！（再散列过程，重新散列分配位置 计算新的索引index）
     */
    private void up2size() {
        Entry<K,V>[] newTable = new Entry[defaultLength * 2];
    }
    
    /**
     * 再散列（重新分配位置）
     * @param newTable
     */
    private void againHash(Entry<K,V>[] newTable) {
        //01.获取原表中的数据
        List<Entry<K,V>> list = new ArrayList<Entry<K,V>>();
        
        for(int i=0 ; i<table.length; i++) {
            if(null == table[i]) {//此判断目的：不一定hash表中所有的元素都有数据（index：i是hash算法计算出来的）
                continue;
            }
            findEntryByNext(table[i], list);
        }
        
        if(list.size() > 0) {
            //重新初始化hash表属性
            size = 0;
            defaultLength = defaultLength * 2;
            table = newTable;
            
            for(Entry<K,V> entry : list) {
                if(null != entry.next) {
                    entry.next = null; //初始化next指针
                }
                put(entry.getKey(), entry.getValue());//将数据添加到扩容后的hash表中
            }
        }
    }
    
    /**
     * 因为hash表是链表结构，所以通过next递归将原表中元素添加到List集合中，以便后续存入新表中
     * @param entry
     * @param list
     */
    private void findEntryByNext(Entry<K,V> entry,List<Entry<K,V>> list) {
        if(null != entry && null != entry.next) {
            list.add(entry);
            findEntryByNext(entry.next, list);
        }else {
            list.add(entry);
        }
    }
    
    /**
     * 根据key使用hash算法返回hash表的索引index
     * 根据key的hash值对hash表长度取模。得到index索引就是表中的存储位置
     * @param k
     * @return
     */
    private int getIndex(K k) {
        int l = defaultLength;
        
        int index = k.hashCode() % l;
        return index >= 0 ? index : -index;
    }
    
    /**
     * 根据key递归的去找key相等的value值
     */
    @Override
    public V get(K k) {
        
        int index = getIndex(k);//获取索引
        if(null == table[index]) {
            return null;
        }
        return findValueByEqualKey(k, table[index]);
    }
    
    /**
     * 表中两个元素是同一个索引（同一个索引index下存在不同的key）
     * 所以我们需要拿到参数传进来的key和index下与之对应的key相同的那个元素的value
     * 使用递归实现
     * @param k
     * @param entry
     * @return
     */
    private V findValueByEqualKey(K k,Entry<K,V> entry) {
        if(k == entry.getKey() || k.equals(entry.getKey())) {
            return entry.getValue();
        }else {
            if(null != entry.next) {
                return findValueByEqualKey(k, entry.next);
            }
        }
        return null;
    }

    @Override
    public int size() {
        // TODO Auto-generated method stub
        return 0;
    }
    
    /**
     * 内部类实现Entry接口（因为Entry是接口无法实例化，此内部类目的是实例化Entry对象）
     *  static class Node<K,V> implements Map.Entry<K,V> {}
     * @author Xuas
     *
     * @param <K>
     * @param <V>
     */
    class Entry<K,V> implements MyMap.Entry<K, V> {
        
        K k;
        
        V v;
        
        Entry<K,V> next;//next指针，next是指向Entry对象的
        
        public Entry(K k,V v,Entry<K,V> next) {
            this.k = k;
            this.v = v;
            this.next = next;
        }
        
        @Override
        public K getKey() {
            return k;
        }

        @Override
        public V getValue() {
            return v;
        }
        
    }

}

3.测试

package cn.yzx.hashmap;

import java.util.HashMap;
import java.util.Map;

public class Test {
    public static void main(String[] args) {
        // 测试jdk的HashMap
        Map<String, String> jdkmap = new HashMap<String, String>();

        Long begin = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++) {
            jdkmap.put("key" + i, "value" + i);
        }

        for (int i = 0; i < 1000; i++) {
            System.out.println(jdkmap.get("key" + i));
        }
        Long end = System.currentTimeMillis();
        System.out.println("jdk'time:" + (end - begin));
        
        System.out.println("*************************************************************");
        // 自定义的MyHashMap
        MyMap<String, String> mymap = new MyHashMap<String, String>();

        Long begin2 = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++) {
            mymap.put("key" + i, "value" + i);
        }

        for (int i = 0; i < 1000; i++) {
            System.out.println(mymap.get("key" + i));
        }
        Long end2 = System.currentTimeMillis();
        System.out.println("jdk'time:" + (end2 - begin2));

    }
}

这里本人对于性能的对比没做太深研究。

就酱~