hash算法与hashmap

一、hash算法

1.1 hash简介

hash,一般翻译为散列，就是把任意长度的输入，通过散列算法，变换成固定长度的输出，该输出值就是散列值，这种转换是一种压缩映射，也就是散列的空间小于输入的空间，不同的输入可能会形成相同的输出，因此不可以通过散列值来唯一的确定输入值，简单的说就是把任意长度的消息压缩到某一固定长度的消息摘要的函数

1.2 构造hash函数的方法

方法	介绍	适用场景	举例
直接寻址法	取keyword或keyword的某个线性函数值为 散列地址。即H(key)=key或H(key)=a•key +b，当中a和b为常数（这样的散列函数叫做 自身函数）	地址集合的大小 = 关键字集合的大小	地址 A1 A2 ……A99 A100 年龄(key) 1 2 ……99 100 人数(value)980 800 ……495 107
数字分析法	数字分析法是取数据元素关键字中某些取值较 均匀的数字位作为哈希地址的方法。即当关键 字的位数很多时，可以通过对关键字的各位进 行分析，丢掉分布不均匀的位，作为哈希值。 它只适合于所有关键字值已知的情况。通过分 析分布情况把关键字取值区间转化为一个较小 的关键字取值区间	能预先估计出全体关键字的每一位上各种数 字出现的频度	存在关键字如下： K1=61317602 K2=61326875 K3=62739628 K4=61343634 K5=62706815 K6=62774638 通过分析,key的前4位不宜作为hash值。 从后面取四位中取两位即可
折叠法	折叠法是将关键字从左到右分割成位数相等的 几部分（最后一部分位数不够可以短一些）， 然后将这几部分叠加求和，并按散列表表长， 取后几位作为散列地址	关键字的数字位数特别多	当哈希表长为1000,关键字key=31119891, 允许的地址空间为三位十进制数 ，则这两种叠加情况如下： 移位叠加   边界叠加 891     891 119     911   31       31 041     833
平方取中法	这个方法是先取关键字的平方，然后根据可使 用空间的大小，选取平方数是中间几位为哈希 地址	关键字中的每一位都有某些数字重复出现频 度很高的现象	若设哈希表长为1000 关键字 关键字的平方 哈希函数值 1234  1522756    227 2143  4592449    924 4132  17073424    734 3214  10329796    297
除留余数法	函数公式为：f(key)=key mod p(p<=m) ，m为地址空间大小，事实上，这方法不仅可 以对关键字直接取模，也可以在折叠、平方取 中后再取模	此方法重要的是p的选取	散列元素为（18，75，60，43，54， 90，46）,表长m=10，假设p=7，则： h(18)=18%7=4 h(75)=75%7=5 h(60)=60%7=4 h(43)=43%7=1 h(54)=54%7=5 h(90)=90%7=6 h(46)=46%7=4

1.3 散列表

散列表也叫哈希表，是依据关键码值（key,value）而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中的一个位置来访问记录，以加快查找的速度，这个映射函数就是1.1中的hash函数，存放记录的数组叫做散列表。

1.4 hash冲突

不同的key的hash值相同的时候，就产生了冲突，这个时候就需要有解决冲突的方法，常见的有：

1. 开放地址法

通过H=H（key）产生冲突的时候，就使用这个公式：H = （H（key）+di）mod m（m为hash表的长度） 来重新确定key的hash值。

1.当di取1，2，3，4 ...时，称为线性探测再散列

2.当di取1^2，-12，2^2,-22,...，称为平方探测再散列

3.当di取随机数时，称为随机探测再散列

2. 再哈希法

顾名思义，不止存在一个hash函数，当使用第一个hash函数产生冲突后，就使用其他的hash函数，直至不冲突为止

3. 链地址法

就是下面即将提到的hashMap采用的解决冲突的方法，此处不累述

1.5 java中的hash

Java中的Object类中有一个方法

public native int hashCode();

因此对于没有重写hashCode方法的类来说，他的hash值就是通过本地算法计算而来的。

1. hashCode的作用

java常见的集合框架HashMap，HashTable，HashSet等，在保存对象的同时都会保存下来对象的hashCode，这样做的目的可以减少集合进行某些操作，例如：HashMap的判断是否包含key，查找等操作的时间复杂度

2. hashCode与对象的关系

1.不同对象的hashCode可能相同（hash冲突），因此通过hashCode不能判断对象相同

2.hashCode不同那么对象肯定不同，因此可以通过hashCode判断对象不同

我们知道判断对象相同可以用equals方法，因此上述两句表示可以变为：

1.对象equals为true,那么hashCode一定相同

2.hashCode不同，那么equals一定为false

二、HashMap数据结构

　说明：上图很形象的展示了HashMap的数据结构（数组+链表+红黑树），桶中的结构可能是链表，也可能是红黑树，红黑树的引入是为了提高效率

三 、HashMap源码分析

3.1 类的属性

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
    // 序列号
    private static final long serialVersionUID = 362498820763181265L;
    // 默认的初始容量是16
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
    // 最大容量
    static final int MAXIMUM_CAPACITY = 1 << 30;
    // 默认的填充因子
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
    // 当桶(bucket)上的结点数大于这个值时会转成红黑树
    static final int TREEIFY_THRESHOLD = 8;
    // 当桶(bucket)上的结点数小于这个值时树转链表
    static final int UNTREEIFY_THRESHOLD = 6;
    // 桶中结构转化为红黑树对应的table的最小大小
    static final int MIN_TREEIFY_CAPACITY = 64;
    // 存储元素的数组，总是2的幂次倍
    transient Node<k,v>[] table;
    // 存放具体元素的集
    transient Set<map.entry<k,v>> entrySet;
    // 存放元素的个数，注意这个不等于数组的长度。
    transient int size;
    // 每次扩容和更改map结构的计数器
    transient int modCount;
    // 临界值 当实际大小(容量*填充因子)超过临界值时，会进行扩容
    int threshold;
    // 填充因子
    final float loadFactor;
}

用下图表示loadFactor，capacity，threshold的关系：



其中capacity为64（满足2的幂次倍），假设loadFactor为默认的0.75，那么threshold为54，当前size为10<54,因此不需要扩容，当size大于54时，会进行扩容

3.2 类的构造函数

1.HashMap（int，float）型

public HashMap(int initialCapacity, float loadFactor) {
    // 初始容量不能小于0，否则报错
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal initial capacity: " +
                                            initialCapacity);
    // 初始容量不能大于最大值，否则为最大值
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    // 填充因子不能小于或等于0，不能为非数字
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        throw new IllegalArgumentException("Illegal load factor: " +
                                            loadFactor);
    // 初始化填充因子
    this.loadFactor = loadFactor;
    // 初始化threshold大小
    this.threshold = tableSizeFor(initialCapacity);
}

说明：tableSizeFor(initialCapacity)返回大于initialCapacity的最小的二次幂数值

static final int tableSizeFor(int cap) {
        int n = cap - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }

说明：>>> 操作符表示无符号右移，高位取0

2.HashMap(int)型构造函数

public HashMap(int initialCapacity) {
    // 调用HashMap(int, float)型构造函数
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

3.HashMap()型构造函数

public HashMap() {
    // 初始化填充因子
    this.loadFactor = DEFAULT_LOAD_FACTOR;
}

4.HashMap(Map<? extends K>)型构造函数

public HashMap(Map<? extends K, ? extends V> m) {
    // 初始化填充因子
    this.loadFactor = DEFAULT_LOAD_FACTOR;
    // 将m中的所有元素添加至HashMap中
    putMapEntries(m, false);
}

说明：putMapEntries(Map<? extends K, ? extends V> m, boolean evict)函数将m的所有元素存入本HashMap实例中

final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
    int s = m.size();
    if (s > 0) {
        // 判断table是否已经初始化
        if (table == null) { // pre-size
            // 未初始化，s为m的实际元素个数
            float ft = ((float)s / loadFactor) + 1.0F;
            int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                    (int)ft : MAXIMUM_CAPACITY);
            // 计算得到的t大于阈值，则初始化阈值
            if (t > threshold)
                threshold = tableSizeFor(t);
        }
        // 已初始化，并且m元素个数大于阈值，进行扩容处理
        else if (s > threshold)
            resize();
        // 将m中的所有元素添加至HashMap中
        for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
            K key = e.getKey();
            V value = e.getValue();
            putVal(hash(key), key, value, false, evict);
        }
    }
}

3.3 重要函数分析

1.putVal

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    // table未初始化或者长度为0，进行扩容
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    // (n - 1) & hash 确定元素存放在哪个桶中，桶为空，新生成结点放入桶中(此时，这个结点是放在数组中)
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    // 桶中已经存在元素
    else {
        Node<K,V> e; K k;
        // 比较桶中第一个元素(数组中的结点)的hash值相等，key相等
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
                // 将第一个元素赋值给e，用e来记录
                e = p;
        // hash值不相等，即key不相等；为红黑树结点
        else if (p instanceof TreeNode)
            // 放入树中
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        // 为链表结点
        else {
            // 在链表最末插入结点
            for (int binCount = 0; ; ++binCount) {
                // 到达链表的尾部
                if ((e = p.next) == null) {
                    // 在尾部插入新结点
                    p.next = newNode(hash, key, value, null);
                    // 结点数量达到阈值，转化为红黑树
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    // 跳出循环
                    break;
                }
                // 判断链表中结点的key值与插入的元素的key值是否相等
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    // 相等，跳出循环
                    break;
                // 用于遍历桶中的链表，与前面的e = p.next组合，可以遍历链表
                p = e;
            }
        }
        // 表示在桶中找到key值、hash值与插入元素相等的结点
        if (e != null) {
            // 记录e的value
            V oldValue = e.value;
            // onlyIfAbsent为false或者旧值为null
            if (!onlyIfAbsent || oldValue == null)
                //用新值替换旧值
                e.value = value;
            // 访问后回调
            afterNodeAccess(e);
            // 返回旧值
            return oldValue;
        }
    }
    // 结构性修改
    ++modCount;
    // 实际大小大于阈值则扩容
    if (++size > threshold)
        resize();
    // 插入后回调
    afterNodeInsertion(evict);
    return null;
}

说明：HashMap并没有直接提供putVal接口给用户调用，而是提供的put函数，而put函数就是通过putVal来插入元素的。

2.getNode

final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    // table已经初始化，长度大于0，根据hash寻找table中的项也不为空
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
        // 桶中第一项(数组元素)相等
        if (first.hash == hash && // always check first node
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        // 桶中不止一个结点
        if ((e = first.next) != null) {
            // 为红黑树结点
            if (first instanceof TreeNode)
                // 在红黑树中查找
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            // 否则，在链表中查找
            do {
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}

说明：HashMap并没有直接提供getNode接口给用户调用，而是提供的get函数，而get函数就是通过getNode来取得元素的

3.resize

final Node<K,V>[] resize() {
    // 当前table保存
    Node<K,V>[] oldTab = table;
    // 保存table大小
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    // 保存当前阈值
    int oldThr = threshold;
    int newCap, newThr = 0;
    // 之前table大小大于0
    if (oldCap > 0) {
        // 之前table大于最大容量
        if (oldCap >= MAXIMUM_CAPACITY) {
            // 阈值为最大整形
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        // 容量翻倍，使用左移，效率更高
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
            oldCap >= DEFAULT_INITIAL_CAPACITY)
            // 阈值翻倍
            newThr = oldThr << 1; // double threshold
    }
    // 之前阈值大于0
    else if (oldThr > 0)
        newCap = oldThr;
    // oldCap = 0并且oldThr = 0，使用缺省值（如使用HashMap()构造函数，之后再插入一个元素会调用resize函数，会进入这一步）
    else {
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    // 新阈值为0
    if (newThr == 0) {
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                  (int)ft : Integer.MAX_VALUE);
    }
    threshold = newThr;
    @SuppressWarnings({"rawtypes","unchecked"})
    // 初始化table
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    // 之前的table已经初始化过
    if (oldTab != null) {
        // 遍历old每个桶
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            //桶中如果有元素
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                //如果桶中只有一个元素
                if (e.next == null)
                    //那么新桶中也只有一个元素，直接通过数组下标赋值
                    newTab[e.hash & (newCap - 1)] = e;
                //如果桶中存在红黑树
                else if (e instanceof TreeNode)
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                //如果桶中不只一个元素
                else { // preserve order
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    // 将同一桶中的元素根据(e.hash & oldCap)是否为0进行分割，分成两个不同的链表（如果e.hash & oldCap为1该entry可以分配到新的桶），完成rehash
                    do {
                        next = e.next;
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    if (loTail != null) {
                        //将lo和high链表分割开来
                        loTail.next = null;
                        //将lo放在原来的桶中
                        newTab[j] = loHead;
                    }
                    if (hiTail != null) {
                        //将lo和high链表分割开来
                        hiTail.next = null;
                        //将hi放在下标为j+oldCap的桶中
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

说明：进行扩容，会伴随着一次重新hash分配，并且会遍历hash表中所有的元素，是非常耗时的。在编写程序中，要尽量避免resize。扩容再hash的过程可以用下图表示：



在resize的时候，oldtable数组结点可以分为三类：1.没有子链的非空结点（例如A1,A3）,2.空结点（例如A2）,3.带有子链的结点（例如A4）。

对于第一种：resize后的位置根据 E.hash()&newCap-1 有两种可能，例如图中的：A1到B1或B5，A3到B3或 B7，直接通过下标为数组赋值即可

对于第二种：不必处理，例如A2

对于第三种：数组结点以及子链上的结点，根据E.hash()&oldCap是否为0，分为两组，构成两个链表(lo和hi)，lo放在原来的桶中例如：图中的从A4到B4，hi放在新的桶中例如：从A4到A8

4.hash

   static final int hash(Object key) {
        int h;
//返回Object的hashCode值的高十六位和低十六位的异或值
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

之所以不直接使用hashCode值，是为了降低不同对象哈希值相同的可能，对象在table中序列值计算的算法是hash&（tab.length-1）。这就可以解释table的length为什么为2的幂次倍，图解如下：



5.containsValue

    public boolean containsValue(Object value) {
        Node<K,V>[] tab; V v;
        if ((tab = table) != null && size > 0) {
         //遍历每个桶
            for (int i = 0; i < tab.length; ++i) {
         //遍历某个桶中的所有结点
                for (Node<K,V> e = tab[i]; e != null; e = e.next) {
                    if ((v = e.value) == value ||
                        (value != null && value.equals(v)))
                        return true;
                }
            }
        }
        return false;
    }

四、俯瞰hashmap

hashmap本质上来讲就是一个哈希表，设计的初衷是为了中和数组读取快，链表增删快的优点，因此设计的数据结构就是数组+链表，为了让key-value键值对中的key均匀的与数组下标对应起来，行为有两个，第一：数组的容量为2的次幂，第二：jdk1.8中的hash算法是key的hashCode移位，异或，取模，解决key和下标的对应问题，还存在桶中链表过长读取效率降低的问题，行为也有两个，1.hashmap内部有负载因子和阈值属性，当size>threhold的时候，会进行扩容。2.hashmap中有链表转换为红黑树的结点阈值属性，当桶中结点超过这个阈值之后，会转化为红黑树，查询效率为lg(n)。

五、延伸

在了解了HashMap之后，我们重新考虑下hashCode和equals的设计问题，例如有以下代码：

class People{
    private String name;
    private int age;

    public People(String name,int age) {
        this.name = name;
        this.age = age;
    }  

    public void setAge(int age){
        this.age = age;
    }

public class Main {

    public static void main(String[] args) {

        People p1 = new People("Jack", 12);
        HashMap<People, Integer> hashMap = new HashMap<People, Integer>();
        hashMap.put(p1, 1);

        System.out.println(hashMap.get(new People("Jack", 12)));
    }
}

上述结果的输出值为Null,原因很简单，因为Object本地的hashCode方法与对象的地址有关，那么p1在hashMap中储存的数组序列号与new People("Jack",12)在hashMap中查找的位置不同，因此需要重写hashCode方法：

    public int hashCode() {
        // TODO Auto-generated method stub
        return name.hashCode()*37+age;
    }

运行输出结果还是null，重写了hashCode方法我们保证了放和取的位置相同，但是getVal的细节是：

if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;

需要注意的是==判断地址相同，显然(k = first.key) == key为false，那么(key != null && key.equals(k))呢？由于我们没有重写equals方法，用的是Object的equals方法：

    public boolean equals(Object obj) {
        return (this == obj);
    }

很显然也返回false，结果返回不了，我们想到了重写equals方法，

    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        return this.name.equals(((People)obj).name) && this.age== ((People)obj).age;
    }
}

这个时候运行就成功输出1了，当然我们这里仅仅考虑了最简单的实现同时也是不规范的（同一对象的equals可能不同），没有考虑动态变化，例如：我们在将p1放进hashMap后，通过p1.setAge（11）改变age值，在调用hashMap.get（p1）也返回null，总的来说equals和hashCode的设计必须满足在前面所述的：

1.对象equals为true,那么hashCode一定相同

2.hashCode不同，那么equals一定为false

从上面的实例中我们可以得出这样的结论：hashCode与equals一定要一起重写，上述就演示了我如果们只是重写hashCode，将会导致我们放进去的key-value键值对，再取的时候取不出来了。

六、HashMap的优化

6.1扩容的效率问题

从前面分析已知，当插入一个元素的时候size就加1，若size大于threshold的时候，就会进行扩容。假设我们的capacity大小为32，loadFator为0.75,则threshold为24 = 32 * 0.75，此时，插入了25个元素，并且插入的这25个元素都在同一个桶中，桶中的数据结构为红黑树，则还有31个桶是空的，为了元素能够更加均匀的分布在各个桶中，也会进行扩容处理，但是这次扩容可能对于之后元素的查询优化了一点点，可是扩容的代价可是巨大的，这也就是hashMap在使用的时候需要优化。

6.2 hashMap优化

hashMap优化的目的主要有两个：1.减少hash冲突，减少查询的时间复杂度， 2.减少扩容的次数，因为扩容需要遍历所有的元素，这个代价是巨大的

方法有以下几种：

1.设计良好的hash函数是减少hash冲突的根本

2.对于初始loadFactor和capacity的设定，有如下两种情况：

   1.如果知道大致需要的容量，把初始容量设置好以解决扩容损失；例如：现在有1000个数据，需要 1000/0.75 = 1333 ,又 1024 < 1333 < 2048，所以最好使用2048作为初始容量

   2.容量是动态变化的，我们尽量将capacity设置的大一点，loadFactor设置小一点，这既保证了hash冲突的可能性，也降低了扩容的可能性。

六、思考题

HashMap的初始容量为什么是16？

1. 为什么hashmap的容量约定是2的n次幂？
   
   hashmap的设计要点就是要让key能够较为均匀的分布在所有的桶中，如果容量的大小是2的n次幂，那么key的hashcode的高十六位和第十六位异或再与上容量-1就可以确定桶的位置，并且每个桶中都有机会分配到key
2. 基于问题1的前提下，为什么不是32，或者8呢
   
   hashmap的效率高低有两点：1.减少冲突，2.减少扩容次数，8的话，初始容量太少很有可能会导致扩容，32的话，初始容量太大，基本上不会扩容，浪费空间，所以取了一个折中值16.

参考博客：

http://zha-zi.iteye.com/blog/1124484

http://www.cnblogs.com/dolphin0520/p/3681042.html(参考了hashCode与equals)

http://www.cnblogs.com/leesf456/p/5242233.html(转载了hashMap源码分析)

http://www.cnblogs.com/mengfanrong/p/4034950.html

http://blog.csdn.net/tanggao1314/article/details/51457585

http://blog.csdn.net/fan2012huan/article/details/51087722