散列表（HashMap）的实现

HashMap 概述

HashMap 是基于哈希表的 Map 接口的非同步实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

此实现假定哈希函数将元素适当地分布在各桶之间，可为基本操作（get 和 put）提供稳定的性能。迭代 collection 视图所需的时间与 HashMap 实例的“容量”（桶的数量）及其大小（键-值映射关系数）成比例。所以，如果迭代性能很重要，则不要将初始容量设置得太高或将加载因子设置得太低。也许大家开始对这段话有一点不太懂，不过不用担心，当你读完这篇文章后，就能深切理解这其中的含义了。

需要注意的是：Hashmap 不是同步的，如果多个线程同时访问一个 HashMap，而其中至少一个线程从结构上（指添加或者删除一个或多个映射关系的任何操作）修改了，则必须保持外部同步，以防止对映射进行意外的非同步访问。

HashMap 的数据结构

在 Java 编程语言中，最基本的结构就是两种，一个是数组，另外一个是指针（引用），HashMap 就是通过这两个数据结构进行实现。HashMap实际上是一个“链表散列”的数据结构，即数组和链表的结合体。

从上图中可以看出，HashMap 底层就是一个数组结构，数组中的每一项又是一个链表。当新建一个 HashMap 的时候，就会初始化一个数组。

实现散列表需要的方法，初始化、设置key-value、删除key、通过key获取value、获取散列表元素个数。

内部方法：对key的hash算法、空间扩容等。

使用泛型实现。

实现了判断是否为空、是否包含指定key，以及清空散列表的方法。

在Java实现中，HashTable是线程安全的散列表，而普通的散列表是HashMap。

需要Entry这个类作为一个存储元素。

this.table = new Entry[initCapacity];

创建了一个 Entry 的数组，其大小为 initCapacity。

Entry 是一个 static class，其中包含了 key 和 value，也就是键值对，另外还包含了一个 next 的 Entry 指针。我们可以总结出：Entry 就是数组中的元素，每个 Entry 其实就是一个 key-value 对，它持有一个指向下一个元素的引用，这就构成了链表。

package d20180828.ch11;

import java.util.Arrays;

public class HashMap<K, V> {
    /**
     * 默认散列表的初始化长度（16）
     */
    private static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
    /**
     * 默认扩容因子
     */
    private static final float DEFAULT_LOAD_FACTOR = 0.75f;
    /**
     * 散列表数组
     */
    private Entry<K, V>[] table;
    /**
     * 扩容因子
     */
    final float loadFactor;
    private int size = 0; //散列表元素个数
    private int use = 0;  //散列表使用数组元素的数量
    public HashMap(){
        this(DEFAULT_INITIAL_CAPACITY);
    }
    public HashMap(int initCapacity){
        this(initCapacity, DEFAULT_LOAD_FACTOR);
    }
    public HashMap(int initCapacity, float loadFactor){
        this.table = new Entry[initCapacity];
        this.loadFactor = loadFactor;
    }

    /**
     * 添加/修改
     * @param key
     * @param value
     */
    public void put(K key, V value){
        int index = hash(key);
        Entry<K, V> e = table[index];
        if(e == null){
            //不存在值，向链表添加，有可能需要扩容
            table[index] = new Entry<K, V>(key, value, null);
            size++;
            use++;
            //不存在值，说明是个未用过的地址，需要判断是否需要扩容
            //其实这里可以使用size判断，可以保持某个数组元素下的链表不太长
            if(use >= table.length*loadFactor){
                resize();
            }
        }else{
            //本身存在值，修改已有的值
            for(; e!=null; e=e.next){
                Object k = e.key;
                if(k == key || k.equals(key)){
                    e.value = value;
                    return;
                }
            }
            //不存在相同的值，直接向链表添加元素
            Entry<K, V> temp = table[index];
            Entry<K, V> newEntry = new Entry<K, V>(key, value, temp);
            table[index] = newEntry;
            size++;
        }
    }

    /**
     * 删除
     * @param key
     */
    public void remove(K key){
        int index = hash(key);
        Entry<K, V> e = table[index];
        Entry<K, V> pre = null;
        for(; e!=null; pre=e, e=e.next){
            K k = e.key;
            if(k == key || k.equals(key)){
                if(pre == null){
                    //说明删除的是第一个元素
                    table[index] = null;
                }else{
                    pre.next = e.next;
                    size--;
                }
                return;
            }
        }
    }

    /**
     * 获取
     * @param key
     * @return
     */
    public V get(K key){
        int index = hash(key);
        Entry<K, V> e = table[index];
        for(; e!=null; e=e.next){
            Object k = e.key;
            if(k == key || k.equals(key)){
                return e.value;
            }
        }
        //没有找到返回null
        return null;
    }

    public boolean containsKey(K key){
        int index = hash(key);
        Entry<K, V> e = table[index];
        for(; e!=null; e=e.next){
                Object k = e.key;
                if(k == key || k.equals(key)){
                    return true;
                }
        }
        return false;
    }

    /**
     * 清空散列表
     */
    public void clear(){
        Arrays.fill(table, null);
        size = 0;
        use = 0;
    }

    /**
     * 获取散列表中元素个数
     * @return
     */
    public int size(){
        return size;
    }

    public boolean isEmpty(){
        return size == 0;
    }

    /**
     * 根据key，通过哈希函数获取在散列表数组中的位置
     * @param key
     * @return
     */
    private int hash(K key){
        int hashCode = Math.abs(key.hashCode());
        hashCode %= table.length;
        return hashCode;
    }

    /**
     * 扩容
     */
    private void resize(){
        int newLength = table.length * 2;
        Entry<K, V>[] oldTable = table;
        table = new Entry[newLength];
        use = 0;
        for(int i=0; i<oldTable.length; i++){
            Entry<K, V> e = oldTable[i];
            while (null != e){
                //重新计算哈希值，放入新的地址中
                int index = hash(e.key);
                if(table[index] == null){
                    use++;
                    table[index] = new Entry<K, V>(e.key, e.value, null);
                }else{
                    Entry<K, V> temp = table[index];
                    Entry<K, V> newEntry = new Entry<K, V>(e.key, e.value, temp);
                    table[index] = newEntry;
                }
                e = e.next;
            }
        }
    }

    static class Entry<K, V>{
        K key;
        V value;
        Entry<K, V> next;

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

测试代码

package d20180828.ch11;

public class HashMapTest {

    public static void main(String[] args){
        HashMap<Integer, String> map = new HashMap<Integer, String>(2);
        map.put(1, "a");
        map.put(2, "b");
        map.put(3, "c");
        System.out.println(map.get(1));
        System.out.println(map.get(2));
        System.out.println(map.get(3));
    }
}