JDK源码阅读，手写HashMap

HashMap是jdk提供的最常用的容器之一，jdk 1.7及之前版本，HashMap底层基于数组和单链表结构，数组每个元素是一对键值对对象，该对象包括hash值，key，value以及单链表下一个键值对的引用。jdk 1.8对HashMap底层结构做了一些改进，当数组同一位置的键值对超过8个，不再以单链表形式存储，而是改为红黑树。进一步提升了性能。

本文基于jdk 1.7，参考源码，手写一个简单的HashMap，实现自动扩容功能、put、get、entrySet方法。
HashMap结构如下图：

1、HashMap的一些性质

通过阅读源码，相较于HashTable，HashMap有以下性质：

• 线程安全：Hashtable线程安全，同步，同步方式是锁住整个Hashtable，效率相对低下
  HashMap线程不安全，非同步，效率相对高
• 父类：Hashtable是Dictionary
  HashMap是AbstractMap
• null值：Hashtable键与值不能为null
  HashMap键最多一个null，值可以多个null
• 初始容量：HashMap的初始容量为16，
  Hashtable初始容量为11
• 扩容方式：HashMap扩容时是当前容量翻倍即:capacity2，
  Hashtable扩容时是容量翻倍+1即:capacity2+1。
• 计算hash的方法：HashMap计算hash对key的hashcode进行了二次hash，以获得更好的散列值，然后对table数组长度取摸。
  Hashtable计算hash是直接使用key的hashcode对table数组的长度直接进行取模
• 存储结构:jdk1.8以后，HashMap在链表长度超过阈值时，改用数组+红黑树的方式存储
  Hashtable采用数组+链表方式存储

这些性质都体现在源码中，通过代码，可以有更深刻的认识。

2、手写HashMap

这里还是用常规命名MyHashMap作为我们的HashMap的类名

定义接口 MyMap

public interface MyMap<K, V> {
    V put(K k,V v);
    V get(K k);
    Set<? extends Entry<K, V>> entrySet();
    interface Entry<K, V>{
        K getKey();
        V getValue();
    }
}

这里定义了后面即将去实现的三个方法，和一个内部接口类型。

MyhashMap的一些属性

public class MyHashMap<K,V> implements MyMap<K,V> {
    //默认初始化的容量，16
    private static final int DEFAULT_INITIAL_CAPACITY = 1<<4;
    //默认初始化的扩容因子
    private static final float DEFAULT_LOAD_FACTOR = 0.75f;
    //容量
    private int initialCapacity;
    //扩容因子
    private float loadFactor;
    //Entry数量，也就是map的长度
    int size;
    //entry数组
    private Node<K,V>[] table;

有两个常量，一个初始化容量16，一个扩容因子0.75，都与jdk源码保持一致。两个变量initialCapacity，loadFactor就是对应的两个属性，size是MyHashMap键值对个数，table是存放键值对的数组。
前面说了HashMap是基于数组+链表形式存储键值对，那么链表数据结构就在下面的静态内部类Node的结构中体现

静态内部类 Node

static class Node<K,V> implements MyMap.Entry<K,V>{
        K key;
        V value;
        Node<K,V> next;

        public Node() {
        }

        Node(K key, V value, Node<K, V> next) {
            this.key = key;
            this.value = value;
            this.next = next;
        }

        @Override
        public K getKey() {
            return key;
        }

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

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Node<?, ?> node = (Node<?, ?>) o;
            return Objects.equals(key, node.key) &&
                    Objects.equals(value, node.value);
        }

        @Override
        public int hashCode() {
            return Objects.hash(key, value);
        }

        @Override
        public String toString() {
            return key+"="+value;
        }
    }

Node类实现前面定义的MyMap.Entry接口，有三个属性，key、value以及单链表下一个节点的引用，实际上jdk源码还有一个hash属性存储hash值，这里简化掉。Node的两个方法getKey，getValue非常简单，获取键和值，源码有个setValue方法，这里也简化掉，：）然后就是重写hashCode方法和equals方法，使得判断两个Node相等的依据是key值和value值都相等。

MyHashMap的构造方法

	public MyHashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity<0) {
            throw new IllegalArgumentException("Illegal initial capacity: "+initialCapacity);
        }
        if (loadFactor <= 0 || Float.isNaN(loadFactor)){
            throw new IllegalArgumentException("Illegal load factor: " +loadFactor);
        }
        this.loadFactor = loadFactor;
        this.initialCapacity = initialCapacity;
        this.table = new Node[this.initialCapacity];
    }

    public MyHashMap() {
        this(DEFAULT_INITIAL_CAPACITY,DEFAULT_LOAD_FACTOR);
    }

用户可以构造自定义初始容量和扩容因子的MyHashMap，如果自定义的数据不合法，抛出运行时异常。使用空构造是使用默认的16和0.75作为初始容量和扩容因子。非常简单。

put方法

接下来看put方法

	@Override
    public V put(K key, V value) {
        V oldValue = null;
        //是否需要扩容
        if (size>=initialCapacity*loadFactor){
            //数组容量扩大为两倍
            expand(2*initialCapacity);
        }
        //根据key的hash值确定应该放入的数组位置
        int index = hash(key)&(initialCapacity-1);
        if (table[index]==null){
            table[index] = new Node<K,V>(key,value,null);
        }else{//遍历单链表
            Node<K,V> node = table[index];
            Node<K,V> e = node;
            while(e!=null){
                if (e.key==key||e.key.equals(key)){
                    oldValue = e.value;
                    e.value=value;
                    return oldValue;
                }
                e = e.next;
            }
            table[index] = new Node<K,V>(key,value,node);
        }
        ++size;
        return oldValue;
    }

插入node之前先检查键值对数量是否大于容量*扩容因子，若超过则需先扩容。扩容方法和hash方法后面再看。
put方法返回值为map中对应key原来的value值，若存在该key，更新其value值，并返回旧值；
若不存在该key，则通过hash取模将键值对插入到数组对应index的位置，若该位置有其他node，将要插入的键值对插入到单链表头部。size加1.

get方法

获取对应key值的键值对的value值。

	@Override
    public V get(K key) {
        int index = hash(key)&(initialCapacity-1);
        Node<K,V> e = table[index];
        while(e!=null){
            if (e.key==key||e.key.equals(key)){
                return e.value;
            }
            e=e.next;
        }
        return null;
    }

根据key的hash得到数组index，遍历该位置的单链表获取键值对。

entrySet方法

	@Override
    public Set<Node<K, V>> entrySet() {
        Set<Node<K,V>> set = new HashSet<>();
        for (Node<K,V> node:table){
            while(node!=null){
                set.add(node);
                node = node.next;
            }
        }
        return set;
    }

遍历数组和链表，返回所有键值对的集合。

扩容方法 expand

	//扩容方法，将旧数组的数据取出来通过put方法放进新数组
    private void expand(int i) {
        Node<K,V> [] newTable = new Node[i];
        initialCapacity = i;
        size = 0;
        Set<Node<K, V>> set = entrySet();
        //替换数组引用
        if (newTable.length>0){
            table = newTable;
        }
        for (Node<K,V> node:set){
            put(node.key,node.value);
        }
    }

源码里该方法叫resize，通过entrySet方法获取所有键值对的集合，put进新的数组里面。

hash方法

	static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }
}

参考源码的hash方法。
以上就是完整的MyHashMap类。实现HashMap的基本功能。
测试类：

public class TestMain {
    public static void main(String[] args) {
        MyHashMap<String, String> myHashMap = new MyHashMap<>();
        //put()
        for (int i = 1; i <=500 ; i++) {
            myHashMap.put("KEY_"+i,"VALUE_"+i);
        }
        //size
        System.out.println("【SIZE】-->"+myHashMap.size);
        //get()
        System.out.println(myHashMap.get("KEY_444"));
        //entrySet()
        for (MyHashMap.Node<String, String> entry : myHashMap.entrySet()) {
            if(entry.getKey().equals("KEY_333"))
            System.out.println(entry);
        }
    }
}

运行结果：