文章目录

• • • • 什么是hashCode以及hashCode()与equals()的联系
      • • 1、什么是hashCode?
        • 2、equals()与hashCode()的联系
        • 3、为什么重写equals()的同时要重写hashCode()方法
        • 4、由hashCode()造成的内存泄露问题
        • 5、基本数据类型和String类型的hashCode()方法和equals()方法
        • 6、hashcode 在 JVM 发生 GC 前后的值是否发生改变？
      • Hash算法
      • • 1、hash是什么，它的作用
        • 2、hash算法有什么特点
        • 3、hash算法是如何实现的
        • 4、hash有哪些流行的算法
        • 5、什么是hash算法的碰撞
        • 6、hash在Java中的应用

Java基础篇：什么是hashCode 以及 hashCode()与equals()的联系_张维鹏的博客-CSDN博客

Hash算法总结_asdzheng的专栏-CSDN博客_hash算法

什么是hashCode以及hashCode()与equals()的联系

1、什么是hashCode?

hashCode就是对象的散列码，是根据对象的某些信息推导出的一个整数值，默认情况下表示是对象的存储地址。通过散列码，可以提高检索的效率，主要用于在散列存储结构中快速确定对象的存储地址，如Hashtable、hashMap中。

为什么说hashcode可以提高检索效率呢？

我们先看一个例子，如果想判断一个集合是否包含某个对象，最简单的做法是怎样的呢？逐一取出集合中的每个元素与要查找的对象进行比较，当发现该元素与要查找的对象进行equals()比较的结果为true时，则停止继续查找并返回true，否则，返回false。如果一个集合中有很多个元素，比如有一万个元素，并且没有包含要查找的对象时，则意味着你的程序需要从集合中取出一万个元素进行逐一比较才能得到结论，这样做的效率是非常低的。这时，可以采用哈希算法（散列算法）来提高从集合中查找元素的效率，将数据按特定算法直接分配到不同区域上。将集合分成若干个存储区域，每个对象可以计算出一个哈希码，可以将哈希码分组（使用不同的hash函数来计算的），每组分别对应某个存储区域，根据一个对象的哈希码就可以确定该对象应该存储在哪个区域，大大减少查询匹配元素的数量。

比如HashSet就是采用哈希算法存取对象的集合，它内部采用对某个数字n进行取余的方式对哈希码进行分组和划分对象的存储区域，当从HashSet集合中查找某个对象时，Java系统首先调用对象的hashCode()方法获得该对象的哈希码，然后根据哈希吗找到相应的存储区域，最后取得该存储区域内的每个元素与该对象进行equals()比较，这样就不用遍历集合中的所有元素就可以得到结论。

eg:

public class HashCodeTest {
	public static void main(String[] args) {
		int hash= 0;
		String s= "ok";
		StringBuilder sb = new StringBuilder(s);
		
		System.out.println(s.hashCode() + "  " + sb.hashCode());
		
		String t = new String("ok");
		StringBuilder tb =new StringBuilder(s);
		System.out.println(t.hashCode() + "  " + tb.hashCode());
	}
}

运行结果：
3548  1829164700
3548  2018699554

字符串s与t拥有相同的散列码，这是因为字符串的散列码是由内容导出的。而字符串缓冲sb与tb却有着不同的散列码，这是因为StringBuilder没有重写hashCode()方法，它的散列码是由Object类默认的hashCode()计算出来的对象存储地址，所以散列码自然也就不同了。

如何重写出一个较好的hashCode方法?

其实并不难，我们只要合理地组织对象的散列码，就能够让不同的对象产生比较均匀的散列码。例如下面的例子：

public class Model {
	private String name;
	private double salary;
	private int sex;
	
    @Override
    public int hashCode() {
        return name.hashCode() + new Double(salary).hashCode() + new Integer(sex).hashCode();
    }
}

上面的代码我们通过合理的利用各个属性对象的散列码进行组合，最终便能产生一个相对比较好的或者说更加均匀的散列码，当然上面仅仅是个参考例子而已，我们也可以通过其他方式去实现，只要能使散列码更加均匀（所谓的均匀就是每个对象产生的散列码最好都不冲突）就行了。

不过这里有点要注意的就是java 7中对hashCode方法做了两个改进，首先java发布者希望我们使用更加安全的调用方式来返回散列码，也就是使用null安全的方法Objects.hashCode（注意不是Object而是java.util.Objects）方法，这个方法的优点是如果参数为null，就只返回0，否则返回对象参数调用的hashCode的结果。Objects.hashCode 源码如下：

public static int hashCode(Object o) {
        return o != null ? o.hashCode() : 0;
    }

import java.util.Objects;
public  class Model {
	private   String name;
	private double salary;
	private int sex;
	@Override
	public int hashCode() {
		return Objects.hashCode(name) + new Double(salary).hashCode() + new Integer(sex).hashCode();
	}
}

java 7还提供了另外一个方法java.util.Objects.hash(Object… objects)，当我们需要组合多个散列值时可以调用该方法。进一步简化上述的代码：(最优代码)

@Override
public int hashCode() {
    return Objects.hash(name,salary,sex);
}

还有一点要说的，如果我们提供的是一个数组类型的变量的话，那么我们可以调用Arrays.hashCode()来计算它的散列码，这个散列码是由数组元素的散列码组成的。

2、equals()与hashCode()的联系

在Obeject类中，equals()比较的是两个对象的内存地址是否相等，而hashCode()返回的是对象的内存地址。所以hashCode主要是用于查找使用的，而equals()是用于比较两个对象是否相等的。

在重写这两个方法的时候，主要注意保持一下几个特性：

1. 相等的对象必须具有相等的散列码（hash code）。即：如果两个对象的equals()结果为true，那么这两个对象的hashCode一定相同；
2. 两个对象的hashCode()结果相同，并不能代表两个对象的equals()一定为true，只能够说明这两个对象在一个散列存储结构中。
3. 如果对象的equals()被重写，那么对象的hashCode()也要重写。

3、为什么重写equals()的同时要重写hashCode()方法

在将这个问题的答案之前，我们先了解一下将元素放入集合的流程，如下图：

同样，在使用get()查询元素的时候，集合类也先调key.hashCode()算出数组下标，然后看equals()的结果，如果是true就是找到了，否则就是没找到。

假设我们我们重写了对象的equals()，但是不重写hashCode()方法，由于超类Object中的hashcode()方法始终返回的是一个对象的内存地址，而不同对象的这个内存地址永远是不相等的。这时候，即使我们重写了equals()方法，也不会有特定的效果的，因为不能确保两个equals()结果为true的两个对象会被散列在同一个存储区域，即 obj1.equals(obj2) 的结果为true，但是不能保证 obj1.hashCode() == obj2.hashCode() 表达式的结果也为true；这种情况，就会导致数据出现不唯一，因为如果连hashCode()都不相等的话，就不会调用equals方法进行比较了，所以重写equals()就没有意义了。

以HashSet为例，如果一个类的hashCode()方法没有遵循上述要求，那么当这个类的两个实例对象用equals()方法比较的结果相等时，他们本来应该无法被同时存储进set集合中，但是，如果将他们存储进HashSet集合中时，由于他们的hashCode()方法的返回值不同(HashSet使用的是Object中的hashCode()，它返回值是对象的内存地址)，第二个对象首先按照哈希码计算可能被放进与第一个对象不同的区域中，这样，它就不可能与第一个对象进行equals方法比较了，也就可能被存储进HashSet集合中了；所以，Object类中的hashCode()方法不能满足对象被存入到HashSet中的要求，因为它的返回值是通过对象的内存地址推算出来的，同一个对象在程序运行期间的任何时候返回的哈希值都是始终不变的，所以，只要是两个不同的实例对象，即使他们的equals方法比较结果相等，他们默认的hashCode方法的返回值是不同的。

测试：

eg1：覆盖equals()但不覆盖hashCode()，导致数据不唯一性。

public class HashCodeTest {  
    public static void main(String[] args) {  
        Collection set = new HashSet();  
        Point p1 = new Point(1, 1);  
        Point p2 = new Point(1, 1);  
  
        System.out.println(p1.equals(p2));  
        set.add(p1);   //(1)  
        set.add(p2);   //(2)  
        set.add(p1);   //(3)  
  
        Iterator iterator = set.iterator();  
        while (iterator.hasNext()) {  
            Object object = iterator.next();  
            System.out.println(object);  
        }  
    }  
}  
  
class Point {  
    private int x;  
    private int y;  
  
    public Point(int x, int y) {  
        super();  
        this.x = x;  
        this.y = y;  
    }  
  
    @Override  
    public boolean equals(Object obj) {  
        if (this == obj)  
            return true;  
        if (obj == null)  
            return false;  
        if (getClass() != obj.getClass())  
            return false;  
        Point other = (Point) obj;  
        if (x != other.x)  
            return false;  
        if (y != other.y)  
            return false;  
        return true;  
    }  
  
    @Override  
    public String toString() {  
        return "x:" + x + ",y:" + y;  
    }  
}  

输出结果：
true
x:1,y:1  
x:1,y:1 

原因分析：

• 当执行set.add(p1)时（1），集合为空，直接存入集合；
• 当执行set.add(p2)时（2），首先判断该对象p2的hashCode值所在的存储区域是否有相同的hashCode，因为没有覆盖hashCode方法，所以默认使用Object的hashCode方法，返回内存地址转换后的整数，因为不同对象的地址值不同，所以这里不存在与p2相同hashCode值的对象，所以直接存入集合。
• 当执行set.add(p1)时（3），时，因为p1已经存入集合，同一对象返回的hashCode值是一样的，继续判断equals是否返回true，因为是同一对象所以返回true。此时jdk认为该对象已经存在于集合中，所以舍弃。

eg2：覆盖hashCode()，但不覆盖equals()，仍然会导致数据的不唯一性。

修改point类

class Point {      private int x;      private int y;        public Point(int x, int y) {          super();          this.x = x;          this.y = y;      }        @Override      public int hashCode() {          final int prime = 31;          int result = 1;          result = prime * result + x;          result = prime * result + y;          return result;      }        @Override      public String toString() {          return "x:" + x + ",y:" + y;      }  }

输出结果：falsex:1,y:1  x:1,y:1

原因分析：

• 当执行set.add(p1)时（1），集合为空，直接存入集合；
• 当执行set.add(p2)时（2），首先判断该对象p2的hashCode值所在的存储区域是否有相同的hashCode，这里覆盖了hashCode方法，p1和p2的hashCode相等，所以继续判断equals()是否相等，因为这里没有覆盖equals()，默认使用 "" 来判断，而 “” 比较的是两个对象的内存地址，所以这里equals()会返回false，所以集合认为是不同的对象，所以将p2存入集合。
• 当执行set.add(p1)时（3），时，因为p1已经存入集合，同一对象返回的hashCode值是一样的，并且equals返回true。此时认为该对象已经存在于集合中，所以舍弃。

综合上述两个测试，要想保证元素的唯一性，必须同时覆盖hashCode和equals才行。

（注意：在HashSet中插入同一个元素（hashCode和equals均相等）时，新加入的元素会被舍弃，而在HashMap中插入同一个Key（Value 不同）时，原来的元素会被覆盖。）

4、由hashCode()造成的内存泄露问题

如果我们将对象的属性值参与了hashCode的运算中，在进行删除的时候，就不能对其属性值进行修改，否则会导致内存泄露问题。

5、基本数据类型和String类型的hashCode()方法和equals()方法

1. hashCode()：八种基本类型的hashCode()很简单就是直接返回他们的数值大小，String对象是通过一个复杂的计算方式，但是这种计算方式能够保证，如果这个字符串的值相等的话，他们的hashCode就是相等的。
2. equals()：8种基本类型的封装类的equals方法就是直接比较数值，String类型的equals方法是比较字符串的值的。

6、hashcode 在 JVM 发生 GC 前后的值是否发生改变？

对象在 GC 后存储位置会发生改变，那这个对象的 hashcode 会不会发生变化？

答：不会。

Hash算法

1、hash是什么，它的作用

先举个例子。我们每个活在世上的人，为了能够参与各种社会活动，都需要一个用于识别自己的标志。也许你觉得名字或是身份证就足以代表你这个人，但是这种代表性非常脆弱，因为重名的人很多，身份证也可以伪造。最可靠的办法是把一个人的所有基因序列记录下来用来代表这个人，但显然，这样做并不实际。而指纹看上去是一种不错的选择，虽然一些专业组织仍然可以模拟某个人的指纹，但这种代价实在太高了。

而对于在互联网世界里传送的文件来说，如何标志一个文件的身份同样重要。比如说我们下载一个文件，文件的下载过程中会经过很多网络服务器、路由器的中转，如何保证这个文件就是我们所需要的呢？我们不可能去一一检测这个文件的每个字节，也不能简单地利用文件名、文件大小这些极容易伪装的信息，这时候，我们就需要一种指纹一样的标志来检查文件的可靠性，这种指纹就是我们现在所用的Hash算法(也叫散列算法)。

散列算法（Hash Algorithm），又称哈希算法，杂凑算法，是一种从任意文件中创造小的数字「指纹」的方法。与指纹一样，**散列算法就是一种以较短的信息来保证文件唯一性的标志，这种标志与文件的每一个字节都相关，而且难以找到逆向规律。**因此，当原有文件发生改变时，其标志值也会发生改变，从而告诉文件使用者当前的文件已经不是你所需求的文件。

这种标志有何意义呢？之前文件下载过程就是一个很好的例子，事实上，现在大部分的网络部署和版本控制工具都在使用散列算法来保证文件可靠性。而另一方面，我们在进行文件系统同步、备份等工具时，使用散列算法来标志文件唯一性能帮助我们减少系统开销，这一点在很多云存储服务器中都有应用。

以Git为代表的众多版本控制工具都在使用SHA1等散列函数检查文件更新

当然，作为一种指纹，散列算法最重要的用途在于给证书、文档、密码等高安全系数的内容添加加密保护。这一方面的用途主要是得益于散列算法的不可逆性，这种不可逆性体现在，你不仅不可能根据一段通过散列算法得到的指纹来获得原有的文件，也不可能简单地创造一个文件并让它的指纹与一段目标指纹相一致。散列算法的这种不可逆性维持着很多安全框架的运营。

2、hash算法有什么特点

一个优秀的 hash 算法，将能实现：

• 正向快速：给定明文和 hash 算法，在有限时间和有限资源内能计算出 hash 值。
• 逆向困难：给定（若干） hash 值，在有限时间内很难（基本不可能）逆推出明文。
• 输入敏感：原始输入信息修改一点信息，产生的 hash 值看起来应该都有很大不同。
• 冲突避免：很难找到两段内容不同的明文，使得它们的 hash 值一致（发生冲突）。即对于任意两个不同的数据块，其hash值相同的可能性极小；对于一个给定的数据块，找到和它hash值相同的数据块极为困难。

但在不同的使用场景中，如数据结构和安全领域里，其中对某一些特点会有所侧重。

2.1 Hash在管理数据结构中的应用

在用到hash进行管理的数据结构中，就对速度比较重视，对抗碰撞不太看中，只要保证hash均匀分布就可以。比如hashmap，hash值（key）存在的目的是加速键值对的查找，key的作用是为了将元素适当地放在各个桶里，对于抗碰撞的要求没有那么高。换句话说，hash出来的key，只要保证value大致均匀的放在不同的桶里就可以了。但整个算法的set性能，直接与hash值产生的速度有关，所以这时候的hash值的产生速度就尤为重要，以JDK中的String.hashCode()方法为例：

public int hashCode() {    int h = hash;    //hash default value : 0     if (h == 0 && value.length > 0) {        //value : char storage        char val[] = value;        for (int i = 0; i < value.length; i++) {            h = 31 * h + val[i];        }        hash = h;    }    return h;}

很简洁的一个乘加迭代运算，在不少的hash算法中，使用的是异或+加法进行迭代，速度和前者差不多。

2.2 Hash在在密码学中的应用
在密码学中，hash算法的作用主要是用于消息摘要和签名，换句话说，它主要用于对整个消息的完整性进行校验。举个例子，我们登陆知乎的时候都需要输入密码，那么知乎如果明文保存这个密码，那么黑客就很容易窃取大家的密码来登陆，特别不安全。那么知乎就想到了一个方法，使用hash算法生成一个密码的签名，知乎后台只保存这个签名值。由于hash算法是不可逆的，那么黑客即便得到这个签名，也丝毫没有用处；而如果你在网站登陆界面上输入你的密码，那么知乎后台就会重新计算一下这个hash值，与网站中储存的原hash值进行比对，如果相同，证明你拥有这个账户的密码，那么就会允许你登陆。银行也是如此，银行是万万不敢保存用户密码的原文的，只会保存密码的hash值而而已。在这些应用场景里，对于抗碰撞和抗篡改能力要求极高，对速度的要求在其次。一个设计良好的hash算法，其抗碰撞能力是很高的。以MD5为例，其输出长度为128位，设计预期碰撞概率为，这是一个极小极小的数字——而即便是在MD5被王小云教授破解之后，其碰撞概率上限也高达，也就是说，至少需要找次才能有1/2的概率来找到一个与目标文件相同的hash值。而对于两个相似的字符串，MD5加密结果如下：

MD5("version1") = "966634ebf2fc135707d6753692bf4b1e";MD5("version2") = "2e0e95285f08a07dea17e7ee111b21c8";可以看到仅仅一个比特位的改变，二者的MD5值就天差地别了

注 : 其实把hash算法当成是一种加密算法，这是不准确的，我们知道加密总是相对于解密而言的，没有解密何谈加密呢，**HASH的设计以无法解为目的的。**并且如果我们不附加一个随机的salt值，HASH口令是很容易被字典攻击入侵的。

3、hash算法是如何实现的

密码学和信息安全发展到现在，各种加密算法和散列算法已经不是只言片语所能解释得了的。在这里我们仅提供几个简单的概念供大家参考。

作为散列算法，首要的功能就是要使用一种算法把原有的体积很大的文件信息用若干个字符来记录，还要保证每一个字节都会对最终结果产生影响。那么大家也许已经想到了，求模这种算法就能满足我们的需要。

事实上，求模算法作为一种不可逆的计算方法，已经成为了整个现代密码学的根基。只要是涉及到计算机安全和加密的领域，都会有模计算的身影。散列算法也并不例外，一种最原始的散列算法就是单纯地选择一个数进行模运算，比如以下程序。

# 构造散列函数def hash(a):    return a % 8# 测试散列函数功能print(hash(233))print(hash(234))print(hash(235))# 输出结果- 1- 2- 3

很显然，上述的程序完成了一个散列算法所应当实现的初级目标：用较少的文本量代表很长的内容（求模之后的数字肯定小于8）。但也许你已经注意到了，单纯使用求模算法计算之后的结果带有明显的规律性，这种规律将导致算法将能难保证不可逆性。所以我们将使用另外一种手段，那就是异或。

再来看下面一段程序，我们在散列函数中加入一个异或过程。

# 构造散列函数def hash(a):    return (a % 8) ^ 5# 测试散列函数功能print(hash(233))print(hash(234))print(hash(235))输出结果- 4- 7- 6

很明显的，加入一层异或过程之后，计算之后的结果规律性就不是那么明显了。

当然，大家也许会觉得这样的算法依旧很不安全，如果用户使用连续变化的一系列文本与计算结果相比对，就很有可能找到算法所包含的规律。但是我们还有其他的办法。比如在进行计算之前对原始文本进行修改，或是加入额外的运算过程（如移位），比如以下程序。

# 构造散列函数def hash(a):    return (a + 2 + (a << 1)) % 8 ^ 5# 测试散列函数功能print(hash(233))print(hash(234))print(hash(235))输出结果- 0- 5- 6

这样处理得到的散列算法就很难发现其内部规律，也就是说，我们并不能很轻易地给出一个数，让它经过上述散列函数运算之后的结果等于4——除非我们去穷举测试。

上面的算法是不是很简单？事实上，下面我们即将介绍的常用算法MD5和SHA1，其本质算法就是这么简单，只不过会加入更多的循环和计算，来加强散列函数的可靠性。

4、hash有哪些流行的算法

目前流行的 Hash 算法包括 MD5、SHA-1 和 SHA-2。

• MD4（RFC 1320）是 MIT 的 Ronald L. Rivest 在 1990 年设计的，MD 是 Message Digest 的缩写。其输出为 128 位。MD4 已证明不够安全。
• MD5（RFC 1321）是 Rivest 于1991年对 MD4 的改进版本。它对输入仍以 512 位分组，其输出是 128 位。MD5 比 MD4 复杂，并且计算速度要慢一点，更安全一些。MD5 已被证明不具备”强抗碰撞性”。
• SHA （Secure Hash Algorithm）是一个 Hash 函数族，由 NIST（National Institute of Standards and Technology）于 1993 年发布第一个算法。目前知名的 SHA-1 在 1995 年面世，它的输出为长度 160 位的 hash 值，因此抗穷举性更好。SHA-1 设计时基于和 MD4 相同原理，并且模仿了该算法。SHA-1 已被证明不具”强抗碰撞性”。
• 为了提高安全性，NIST 还设计出了 SHA-224、SHA-256、SHA-384，和 SHA-512 算法（统称为 SHA-2），跟 SHA-1 算法原理类似。SHA-3 相关算法也已被提出。

可以看出，上面这几种流行的算法，它们最重要的一点区别就是”强抗碰撞性”。

5、什么是hash算法的碰撞

你可能已经发现了，在实现算法章节的第一个例子，我们尝试的散列算法得到的值一定是一个不大于8的自然数，因此，如果我们随便拿9个数去计算，肯定至少会得到两个相同的值，我们把这种情况就叫做散列算法的「碰撞」（Collision）。

这很容易理解，因为作为一种可用的散列算法，其位数一定是有限的，也就是说它能记录的文件是有限的——而文件数量是无限的，两个文件指纹发生碰撞的概率永远不会是零。

但这并不意味着散列算法就不能用了，因为凡事都要考虑代价，买光所有彩票去中一次头奖是毫无意义的。现代散列算法所存在的理由就是，它的不可逆性能在较大概率上得到实现，也就是说，发现碰撞的概率很小，这种碰撞能被利用的概率更小。

随意找到一组碰撞是有可能的，只要穷举就可以。散列算法得到的指纹位数是有限的，比如MD5算法指纹字长为128位，意味着只要我们穷举21282128次，就肯定能得到一组碰撞——当然，这个时间代价是难以想象的，而更重要的是，仅仅找到一组碰撞并没有什么实际意义。更有意义的是，如果我们已经有了一组指纹，能否找到一个原始文件，让它的散列计算结果等于这组指纹。如果这一点被实现，我们就可以很容易地篡改和伪造网络证书、密码等关键信息。

你也许已经听过MD5已经被破解的新闻——但事实上，即便是MD5这种已经过时的散列算法，也很难实现逆向运算。我们现在更多的还是依赖于海量字典来进行尝试，也就是通过已经知道的大量的文件——指纹对应关系，搜索某个指纹所对应的文件是否在数据库里存在。

因此，MD5在数年前就已经不被推荐作为应用中的散列算法方案，取代它的是SHA家族算法，也就是安全散列算法（Secure Hash Algorithm，缩写为SHA）。

SHA家族算法以及SHA1碰撞
安全散列算法与MD5算法本质上的算法是类似的，但安全性要领先很多——这种领先型更多的表现在碰撞攻击的时间开销更大，当然相对应的计算时间也会慢一点。

SHA家族算法的种类很多，有SHA0、SHA1、SHA256、SHA384等等，它们的计算方式和计算速度都有差别。其中SHA1是现在用途最广泛的一种算法。包括GitHub在内的众多版本控制工具以及各种云同步服务都是用SHA1来区别文件，很多安全证书或是签名也使用SHA1来保证唯一性。长期以来，人们都认为SHA1是十分安全的，至少大家还没有找到一次碰撞案例。

但这一事实在2017年2月破灭了。CWI和Google的研究人员们成功找到了一例SHA1碰撞，而且很厉害的是，发生碰撞的是两个真实的、可阅读的PDF文件。这两个PDF文件内容不相同，但SHA1值完全一样。(对于这件事的影响范围及讨论，可参考知乎上的讨论:如何评价 2 月 23 日谷歌宣布实现了 SHA-1 碰撞？)

所以，对于一些大的商业机构来说， MD5 和 SHA1 已经不够安全，推荐至少使用 SHA2-256 算法。

6、hash在Java中的应用

6.1 HashMap的复杂度

在介绍HashMap的实现之前，先考虑一下，HashMap与ArrayList和LinkedList在数据复杂度上有什么区别。下图是他们的性能对比图：

可以看出HashMap整体上性能都非常不错，但是不稳定，为O(N/Buckets)，N就是以数组中没有发生碰撞的元素，Buckets是因碰撞产生的链表。

注：发生碰撞实际上是非常稀少的，所以N/Bucket_size约等于1

6.2 HashMap的实现

本文以JDK8的API实现进行分析

6.2.1 对key进行Hash计算
在JDK8中，由于使用了红黑树来处理大的链表开销，所以hash这边可以更加省力了，只用计算hashCode并移动到低位就可以了。

static final int hash(Object key) {    int h;    //计算hashCode，并无符号移动到低位    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);}

举个例子: 363771819^(363771819 >>> 16)

0001 0101 1010 1110 1011 0111 1010 1011(363771819)0000 0000 0000 0000 0001 0101 1010 1110(5550) XOR--------------------------------------- =0001 0101 1010 1110 1010 0010 0000 0101(363766277)

这样做可以实现了高地位更加均匀地混到一起。

下面给出在Java中几个常用的哈希码(hashCode)的算法。

• Object类的hashCode. 返回对象的经过处理后的内存地址，由于每个对象的内存地址都不一样，所以哈希码也不一样。这个是native方法，取决于JVM的内部设计，一般是某种C地址的偏移。
• String类的hashCode. 根据String类包含的字符串的内容，根据一种特殊算法返回哈希码，只要字符串的内容相同，返回的哈希码也相同。
• Integer等包装类，返回的哈希码就是Integer对象里所包含的那个整数的数值，例如Integer i1=new Integer(100), i1.hashCode的值就是100 。由此可见，2个一样大小的Integer对象，返回的哈希码也一样。
• int，char这样的基础类，它们不需要hashCode，如果需要存储时，将进行自动装箱操作，计算方法同上。

6.2.2 获取到数组的index的位置
计算了Hash，我们现在要把它插入数组中了

i = (tab.length - 1) & hash；

通过位运算，确定了当前的位置，因为HashMap数组的大小总是2^n，所以实际的运算就是 (0xfff…ff) & hash ，这里的tab.length-1相当于一个mask，滤掉了大于当前长度位的hash，使每个i都能插入到数组中。

6.2.3 生成包装类
这个对象是一个包装类，Node

static class Node<K,V> implements Map.Entry<K,V> {        final int hash;        final K key;        V value;        Node<K,V> next;        //getter and setter .etc.}

6.2.4 插入包装类到数组
(1). 如果输入当前的位置是空的，就插进去，如图，左为插入前，右为插入后

0           0|           |1 -> null   1 - > null|           |2 -> null   2 - > null|           | ..-> null   ..- > null|           | i -> null   i - > new node|           |n -> null   n - > null

(2). 如果当前位置已经有了node，且它们发生了碰撞，则新的放到前面，旧的放到后面，这叫做链地址法处理冲突。

0           0|           |1 -> null   1 - > null|           |2 -> null   2 - > null|           | ..-> null   ..- > null|           | i -> old    i - > new - > old|           |n -> null   n - > null

我们可以发现，失败的hashCode算法会导致HashMap的性能由数组下降为链表，所以想要避免发生碰撞，就要提高hashCode结果的均匀性。

6.3 扩容
如果当表中的75%已经被占用，即视为需要扩容了

(threshold = capacity * load factor ) < size

它主要有两个步骤：

6.3.1 容量加倍
左移1位，就是扩大到两倍，用位运算取代了乘法运算

newCap = oldCap << 1;newThr = oldThr << 1;

6.3.2 遍历计算Hash

for (int j = 0; j < oldCap; ++j) {        Node<K,V> e;        //如果发现当前有Bucket        if ((e = oldTab[j]) != null) {            oldTab[j] = null;            //如果这里没有碰撞            if (e.next == null)                //重新计算Hash，分配位置                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;                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) {                    loTail.next = null;                    newTab[j] = loHead;                }                if (hiTail != null) {                    hiTail.next = null;                    newTab[j + oldCap] = hiHead;                }            }        }    }

由此可以看出扩容需要遍历并重新赋值，成本非常高，所以选择一个好的初始容量非常重要。

6.4 扩容如何提升性能？

• 解决扩容损失：如果知道大致需要的容量，把初始容量设置好以解决扩容损失；
  比如我现在有1000个数据，需要 1000/0.75 = 1333 个坑位，又 1024 < 1333 < 2048，所以最好使用2048作为初始容量。
• 解决碰撞损失：使用高效的HashCode与loadFactor，这个…由于JDK8的高性能出现，这儿问题也不大了。

6.5 HashMap与HashTable的主要区别
在很多的Java基础书上都已经说过了，他们的主要区别其实就是Table全局加了线程同步保护

HashTable线程更加安全，代价就是因为它粗暴的添加了同步锁，所以会有性能损失。
其实有更好的concurrentHashMap可以替代HashTable，一个是方法级，一个是Class级。