消息摘要（Message Digest）又称为数字摘要（Digital Digest）。它是一个唯一对应一个消息或文本的固定长度的值，它由一个单向Hash加密函数对消息进行作用而产生。如果消息在途中改变了，则接收者通过对收到消息的新产生的摘要与原摘要比较，就可知道消息是否被改变了。因此消息摘要保证了消息的完整性。

消息摘要采用单向Hash函数将需加密的明文"摘要"成一串固定位数（如128bit）的密文，这一串密文亦称为数字指纹（Finger Print），它有固定的长度，且不同的明文摘要成密文，其结果总是不同的，而同样的明文其摘要必定一致。这样这串摘要便可成为验证明文是否是“真身”的“指纹”了。

消息摘要具有不可逆性，在消息摘要生成过程中，会丢失很多原文的信息，而且无法找回。一个好的摘要算法，是极难产生Hash碰撞的，也就是找到另一段明文经计算后产生相同的摘要。

相关文章：

• https://www.cnblogs.com/yueshutong/p/11275420.html
• https://www.iteye.com/blog/snowolf-379860

有以下几种：

1、MD5 (Message Digest algorithm 5 消息摘要算法版本5)

MD是应用非常广泛的一个算法家族，尤其是 MD5（Message-Digest Algorithm 5，消息摘要算法版本5），它由MD2、MD3、MD4发展而来，由Ron Rivest（RSA公司）在1992年提出，目前被广泛应用于数据完整性校验、数据（消息）摘要、数据加密等。MD2、MD4、MD5 都产生16字节（128位）的校验值，一般用32位十六进制数表示。MD2的算法较慢但相对安全，MD4速度很快，但安全性下降，MD5比MD4更安全、速度更快。

目前在互联网上进行大文件传输时，都要得用MD5算法产生一个与文件匹配的、存储MD5值的文本文件（后缀名为 .md5或.md5sum），这样接收者在接收到文件后，就可以利用与 SFV 类似的方法来检查文件完整性，目前绝大多数大型软件公司或开源组织都是以这种方式来校验数据完整性，而且部分操作系统也使用此算法来对用户密码进行加密，另外，它也是目前计算机犯罪中数据取证的最常用算法。与MD5 相关的工具有很多，如 WinMD5等。

案例实现：

/**
 * MD5 测试
 * <br/>
 * 参考：https://www.jianshu.com/p/be000cf837b2
 */
class Md5Test {
    public static void main(String[] args) throws NoSuchAlgorithmException {
        /* 得注意加密后字符串的大小写 */
        // 待加密字符
        String originalStr = "111111";
        System.out.println(String.format("待加密字符: %s", originalStr));

        // 已加密字符
        String alreadyDigestStr = "96E79218965EB72C92A549DD5A330112";
        System.out.println(String.format("已加密字符: %s", alreadyDigestStr));

        /* jdk 实现 */
        System.out.println("--------------jdk 实现-----------------");
        // 获取信息摘要对象
        MessageDigest md5 = MessageDigest.getInstance("MD5");

        // 完成摘要
        byte[] digest = md5.digest(originalStr.getBytes());

        // 将摘要转换成 16 进制字符 (大写)
        String javaMd5Str = DatatypeConverter.printHexBinary(digest);

        System.out.println(String.format("%s 加密结果：%s", originalStr, javaMd5Str));

        // 匹配验证
        System.out.println(String.format("验证结果：%b", Objects.equals(javaMd5Str, alreadyDigestStr)));

        /* Apache commons-codec 实现 */
        System.out.println("---------------Apache commons-codec 实现------------");
        // 小写
        String apacheMd5Str = DigestUtils.md5Hex(originalStr.getBytes()).toUpperCase();
        System.out.println(String.format("%s 加密结果：%s", originalStr, apacheMd5Str));
        System.out.println(String.format("验证结果：%b", Objects.equals(apacheMd5Str, alreadyDigestStr)));

        /* spring提供 */
        System.out.println("-----------spring提供-----------");
        // 小写
        String springMd5Str = org.springframework.util.DigestUtils.md5DigestAsHex(originalStr.getBytes()).toUpperCase();
        System.out.println(String.format("%s 加密结果：%s", originalStr, springMd5Str));
        System.out.println(String.format("验证结果：%b", Objects.equals(springMd5Str, alreadyDigestStr)));
    }

}

运行效果如下：

MD算法可用于密码保护。在用户注册时，利用MD算法取密码的摘要值，存入数据库。在用户登录时，将用户密码再次消息摘要后，与数据库密码进行比较即可得出用户登录结果。流程图如下：

MD5加密，是属于不可逆的。我们知道正常使用MD5加密技术，同一字符，加密后的16进制数是不变的，自从出现彩虹表，对于公司内部员工来说，可以反查数据，获取不可能的权限，所以出现了salt算法。

md5加盐算法，代码如下：

package com.blog.www.util.coder;

import org.apache.commons.codec.digest.DigestUtils;

import java.util.Objects;
import java.util.Random;


/**
 * MD5 加随机盐加密
 * <br/>
 * 参考: <a href='https://www.cnblogs.com/peaceliu/p/7825706.html'>MD5加密+加盐</a>
 * <br/>
 * 基于：{@link DigestUtils}
 * <p>
 * 创建人：leigq <br>
 * 创建时间：2018-12-04 15:42 <br>
 * <p>
 * 修改人： <br>
 * 修改时间： <br>
 * 修改备注： <br>
 * </p>
 */
public class MD5WithSalt {

	/**
	 * 生成含有随机盐的加密字符串
	 * <br>创建人： leigq
	 * <br>创建时间： 2018-12-04 15:35
	 * <br>
	 *
	 * @param data 待加密的字符
	 * @return 加密后的字符(含 16 位随机盐)，大写
	 */
	public static String encrypt(String data) {
		Random r = new Random();
		StringBuilder sb = new StringBuilder(16);
		sb.append(r.nextInt(99999999))
				.append(r.nextInt(99999999));
		int len = sb.length();
		if (len < 16) {
			for (int i = 0; i < 16 - len; i++) {
				sb.append("0");
			}
		}
		String salt = sb.toString();
		String md5WithSaltStr = DigestUtils.md5Hex(data + salt);
		char[] cs = new char[48];
		for (int i = 0; i < 48; i += 3) {
			cs[i] = md5WithSaltStr.charAt(i / 3 * 2);
			char c = salt.charAt(i / 3);
			cs[i + 1] = c;
			cs[i + 2] = md5WithSaltStr.charAt(i / 3 * 2 + 1);
		}
		return new String(cs).toUpperCase();
	}

	/**
	 * 校验密码是否正确
	 * <br>创建人： leigq
	 * <br>创建时间： 2018-12-04 15:38
	 * <br>
	 *
	 * @param data                    待验证的字符(明文)
	 * @param md5StrContainRandomSalt 加密后的字符(含 16 位随机盐)
	 * @return 验证结果
	 */
	public static boolean verify(String data, String md5StrContainRandomSalt) {
		// 32 位加密字符（不含盐）
		char[] cs1 = new char[32];
		// 16 位的随机盐
		char[] cs2 = new char[16];
		for (int i = 0; i < 48; i += 3) {
			cs1[i / 3 * 2] = md5StrContainRandomSalt.charAt(i);
			cs1[i / 3 * 2 + 1] = md5StrContainRandomSalt.charAt(i + 2);
			cs2[i / 3] = md5StrContainRandomSalt.charAt(i + 1);
		}
		String salt = new String(cs2);
		return Objects.equals(DigestUtils.md5Hex(data + salt).toUpperCase(), new String(cs1));
	}
}

测试：

/**
 * md5 加随机盐测试
 */
class MD5WithSaltTest {

    public static void main(String[] args) {
        // 待加密字符
        String originalStr = "111111";

        // 已加盐加密字符
        String md5WithSaltStr = MD5WithSalt.encrypt(originalStr);

        System.out.println(String.format("%s 加密结果：%s", originalStr, md5WithSaltStr));

        // 不能直接再次加密验证，因为使用了随机盐，每次加密出来的字符串都不同
        boolean verifyResult = MD5WithSalt.verify(originalStr, md5WithSaltStr);

        System.out.println(String.format("验证结果：%b", verifyResult));
    }
}

测试结果如下：

2、SHA (Secure Hash Algorithm 安全散列算法)

SHA（Secure Hash Algorithm）是由美国专门制定密码算法的标准机构——美国国家标准技术研究院（NIST）制定的，SHA系列算法的摘要长度分别为：SHA-1为20字节（160位）、SHA-224为32字节（224位）、SHA-256为32字节（256位）、SHA-384为48字节（384位）、SHA-512为64字节（512位），由于它产生的数据摘要的长度更长，因此更难以发生碰撞，因此较之MD5更为安全，它是未来数据摘要算法的发展方向。由于SHA系列算法的数据摘要长度较长，因此其运算速度与MD5相比，也相对较慢。

目前SHA1的应用较为广泛，主要应用于CA和数字证书中，另外在目前互联网中流行的BT软件中，也是使用SHA1来进行文件校验的。

代码实现：

/**
 * SHA 加密算法测试
 */
class SHATest {
    public static void main(String[] args) throws NoSuchAlgorithmException {
        // 待加密字符
        String originalStr = "111111";
        System.out.println(String.format("待加密字符: %s", originalStr));

        // 已加密字符
        String alreadyDigestStr = "3D4F2BF07DC1BE38B20CD6E46949A1071F9D0E3D";
        System.out.println(String.format("已加密字符: %s", alreadyDigestStr));

        /* jdk 实现 */
        // 获取信息摘要对象 （SHA1），另外还有 SHA-224、SHA-256、SHA-384、SHA-512
        MessageDigest md5 = MessageDigest.getInstance("SHA");

        // 完成摘要
        byte[] digest = md5.digest(originalStr.getBytes());

        // 将摘要转换成 16 进制字符 (大写)
        String javaShaStr = DatatypeConverter.printHexBinary(digest);

        System.out.println(String.format("%s 加密结果：%s", originalStr, javaShaStr));

        // 匹配验证
        System.out.println(String.format("验证结果：%b", Objects.equals(javaShaStr, alreadyDigestStr)));

        /* Apache commons-codec 实现 */
        String apacheShaStr = DigestUtils.sha1Hex(originalStr.getBytes()).toUpperCase();
        System.out.println(String.format("%s 加密结果：%s", originalStr, apacheShaStr));
        System.out.println(String.format("验证结果：%b", Objects.equals(apacheShaStr, alreadyDigestStr)));

        /* SHA256 */
        System.out.println(DigestUtils.sha256Hex(originalStr.getBytes()));
        /* SHA384 */
        System.out.println(DigestUtils.sha384Hex(originalStr.getBytes()));
        /* SHA512 */
        System.out.println(DigestUtils.sha512Hex(originalStr.getBytes()));
    }
}

运行结果如下：

消息鉴别：

3、MAC (Hash Message Authentication Code 散列消息鉴别码)

MAC算法 (Message Authentication Codes消息认证码算法) 含有密钥的散列函数算法，兼容了MD和SHA算法的特性，并在此基础上加上了密钥。因此MAC算法也经常被称作HMAC算法。消息的散列值由只有通信双方知道的密钥来控制。此时Hash值称作MAC。

经过MAC算法得到的摘要值也可以使用十六进制编码表示，其摘要值得长度与实现算法的摘要值长度相同。例如 HmacSHA算法得到的摘要长度就是SHA1算法得到的摘要长度，都是160位二进制数，换算成十六进制的编码为40位。

流程分析：

甲乙双方进行数据交换可以采取如下流程：

1.甲方向乙方公布摘要算法（就是指定要使用的摘要算法名）

2.甲乙双方按照约定构造密钥，双方拥有相同的密钥（一般是一方构造密钥后通知另外一方，此过程不需要通过程序实现，就是双方约定个字符串，但是这个字符串可不是随便设定的，也是通过相关算法获取的）

3.甲方使用密钥对消息做摘要处理，然后将消息和生成的摘要消息一同发送给乙方

4.乙方收到消息后，使用甲方已经公布的摘要算法+约定好的密钥 对收到的消息进行摘要处理。然后比对自己的摘要消息和甲方发过来的摘要消息。甄别消息是否是甲方发送过来的。

代码实现：

/**
 * MAC 算法测试
 */
class MacTest {
	public static void main(String[] args) throws NoSuchAlgorithmException, DecoderException, InvalidKeyException {
		// 待加密字符
		String originalStr = "111111";
		System.out.println(String.format("待加密字符: %s", originalStr));

		// 已加密字符
		String alreadyDigestStr = "74B31DBA9E16CCF752B294A18271BC6A";
		System.out.println(String.format("已加密字符: %s", alreadyDigestStr));

		/* jdk 实现 */
		// 初始化 KeyGenerator, jdk 提供 HmacMD5、HmacSHA1、HmacSHA256、HmacSHA384和 HmacSHA512 四种算法
//		KeyGenerator keyGenerator = KeyGenerator.getInstance("HmacMD5");
		// 产生密钥
//		SecretKey secretKey = keyGenerator.generateKey();
		// 默认密钥
		// byte[] defaultKey = secretKey.getEncoded();
		// 自定义密钥
		byte[] myKey = Hex.decodeHex(new char[]{'a','a','a','a','a','a','a','a','a','a'});
		// 还原密钥
		SecretKey restoreSecretKey = new SecretKeySpec(myKey, "HmacMD5");
		// 实例化 MAC
		Mac mac = Mac.getInstance(restoreSecretKey.getAlgorithm());
		// 初始化 MAC
        mac.init(restoreSecretKey);
        //执行摘要
		byte[] hmacMD5Bytes = mac.doFinal(originalStr.getBytes());
        String encodeHexString = Hex.encodeHexString(hmacMD5Bytes).toUpperCase();
        System.out.println(String.format("%s 加密结果：%s", originalStr, encodeHexString));
		System.out.println(String.format("验证结果：%b", Objects.equals(encodeHexString, alreadyDigestStr)));


		/* apache 实现 */
        // HmacMD5
        HmacUtils hmacMd5 = new HmacUtils(HmacAlgorithms.HMAC_MD5, myKey);
        String apacheHmacMd5 = hmacMd5.hmacHex(originalStr.getBytes()).toUpperCase();
        System.out.println(String.format("%s 加密结果：%s", originalStr, apacheHmacMd5));
        System.out.println(String.format("验证结果：%b", Objects.equals(apacheHmacMd5, alreadyDigestStr)));

        // HmacSHA1
        HmacUtils hmacSha1 = new HmacUtils(HmacAlgorithms.HMAC_SHA_1, KeyGenerator.getInstance(HmacAlgorithms.HMAC_SHA_1.getName()).generateKey().getEncoded());
        String apacheHmacHex1 = hmacSha1.hmacHex(originalStr.getBytes()).toUpperCase();
        System.out.println(String.format("%s 加密结果：%s", originalStr, apacheHmacHex1));

        // HmacSHA256
        HmacUtils hmacSha256 = new HmacUtils(HmacAlgorithms.HMAC_SHA_256, KeyGenerator.getInstance(HmacAlgorithms.HMAC_SHA_256.getName()).generateKey().getEncoded());
        String apacheHmacSha256 = hmacSha256.hmacHex(originalStr.getBytes()).toUpperCase();
        System.out.println(String.format("%s 加密结果：%s", originalStr, apacheHmacSha256));

        // HmacSHA384 , 类似上面

        // HmacSHA512， 类似上面
    }
}

运行结果：

上面这几种摘要算法，可谓是非可逆加密，就是不可解密的加密方法。我们通常只把他们作为加密的基础。单纯的以上三种的加密并不可靠。

概述

数字摘要也称为消息摘要，它是一个唯一对应一个消息或文本的固定长度的值，它由一个单向Hash函数对消息进行计算而产生。如果消息在传递的途中改变了，接收者通过对收到消息采用相同的Hash重新计算，新产生的摘要与原摘要进行比较，就可知道消息是否被篡改了，因此消息摘要能够验证消息的完整性。消息摘要采用单向Hash函数将需要计算的内容"摘要"成固定长度的串，这个串亦称为数字指纹。这个串有固定的长度，且不同的明文摘要成密文，其结果总是不同的(相对的)，而同样的明文其摘要必定一致。这样这串摘要便可成为验证明文是否是"真身"的"指纹"了。

消息摘要算法：
MD（Message Digest）
SHA（Secure Hash Algorithm）
MAC（Message Authentication Code）
用于验证数据完整性（登录注册、文件校验），登录注册模型分析如下图

消息摘要算法专门用于验证数据完整性，它源于CRC冗余校验算法，派生出MD和SHA两大系列消息算法，在此基础上又衍生出MAC算法。消息摘要算法是数字签名算法的基础。
几乎每种消息摘要算法都大概三种实现方式：Sun、Bouncy Castle和Commons Codes。Sun提供了最基本的算法实现；Bouncy Castle是在Sun基础上做了扩展，实现了Sun未提供的算法；Commons Codes在Sun基础上，对方法做封装，提高易用性。MD算法家族有MD2、MD4、MD5三种算法，在Java 6中通过MessageDigest类提供MD2和MD5两种算法支持；通过Bouncy Castle扩展，可提供MD4算法支持；Commons Codes则直接提高了MD5算法使用的便利性。
MD、SHA、MAC都是加密算法领域的消息摘要算法，与之功能相近的CRC-32则是较古老、用于通信领域实现差错控制的数据完整性验证算法。

1、MD5

MD家族（MD2、4、5）128位摘要信息

2、SHA

模型

应用
1、加入约定Key
2、增加时间戳
3、排序

msg：原始消息+key+时间戳

3、MAC

• MAC(Message Authentication Code)

• HMAC(keyed-Hash Message Authentication Code)，含有密钥的散列算法

• 融合MH、SHA

  • MD系列：
  • SHA系列：HmacSHA1、HmacSHA224、HmacSHA256、HmacSHA384、HmacSHA512

模型：

应用：如SecureCRT（linux远程工具）

消息摘要（Message Digest,MD）

摘要的意思是摘录的要点，文章的摘要是指的是该文章的内容提要。信息领域的消息摘要是对一个数据块的数字指纹。
这里对一段消息的摘要不是该消息的内容提要，而是该消息的数字指纹，是一串固定长度的字符串。消息摘要具有以下属性：

1. 消息改变， 摘要必然不一样
2. 不能伪造相同摘要的不同消息。
   消息摘要最著名的算法就是SHA1和MD5。建议使用SHA1。

消息摘要是数据块的指纹， 在签署合同时，签署双方按上指纹以确定合同的有效性，如果双方签署下一个合同，按的指纹是一样的。而不同的合同产生出来的消息摘要是不一样的，除非两份合同完全一致。

哈希（Hash）及算法

Hash概念及特点

Hash,直译是“哈希”，更常见的翻译是“散列”，也有翻译为“杂凑”。其定义是将任意长度的输入通过散列算法换成固定长度的输出，这个输出就是散列值。
以数学中求模算法为例： 9%2的结果是1， 19%2的结果也是1，但哈希算法远比这复杂。其输入可以是字符串、文本或是文件，其输出是固定长度的哈希值。

Hash函数分类

Hash算法，也称Hash函数或散列函数。哈希算法将数据打乱混合，创建一个唯一的哈希值。
Hash函数是一种单向的加密体制，将任意长度的输入经过转换得到固定长度的输出，但这个过程不可逆，只有加密过程，没有解密过程。常见的哈希函数分类有：

1. 加法Hash： 利用加法构造。
2. 位运算 Hash： 利用移位或异或来混合输入元素。
3. 乘法Hash
4. 除法Hash
5. 查表Hash
6. 混合Hash：混合以上的方式，比如MD5等

Hash碰撞（Collision）

不同的输入使用Hash函数获取的Hash值如果相同，则称发生了碰撞。也就是不同的消息，产生相同的消息摘要。
对于简单的加法或是乘法函数，出现碰撞的可能性很大；对于MD5等算法，虽然概率非常小，但是在理论和现实中都是存在的，这样的算法也就是不安全的了。
好的Hash函数（f）应当满足以下3个条件：

1. 不能从应变量得到自变量。也就是f(x)=y函数，对于任意的y, 不能找到x。
2. 弱无碰撞性。给定x1∈A,找x2∈B，，使得f(x1)=f(x2)，在计算上是不可能的
3. 强无碰撞性，寻找x1，x2，使得f(x1)=f(x2)，在计算上也是不可行的。
   碰撞的处理方法有两类： 开放寻址法(Open Addressing)和链接法（Chaining）。

Hash算法

常见的Hash算法有：MD（Message Digest，消息摘要）、SHA（Secure Hash Algorithm，安全摘要）和MAC（Message Authentication Code,消息认证码）。
MD5和SHA1应该是目前适用最为广泛的Hash算法，这两个算法是在MD4基础上产生。

1. MD4， MD是Message Digest的简写，由MIT（麻省理工）在1990年设计，是基于32位系统实现。输出128位。

2. MD5， 1991年MD4改进。相比MD4，速度稍慢，但更安全。
   MD5以512位分组来处理输入信息，每一分组会分为16个32bit子分组，经过算法处理后，最终输出有4个32位分组组成，将这4个32位分组级联组成 128位散列值。

3. SHA-1，输出160位。

4. SHA-2，包括SHA-224、SHA-256、SHA-384、SHA-512，后面是输出的位数。

5. MAC，带密钥的Hash函数。
   MD5和SHA函数都只有一个输入参数：消息。 如果增加一个密钥（key）的参数，则会生成一个加密的消息摘要。

Hash算法比较

信息摘要越长，发生碰撞的几率就越低，破解难度就越大，但同时，耗费的性能和占用的空间就越高。
这里主要比较MD5和SHA-1的差异。
MD5摘要长度128bit，SHA-１摘要长度160bit，SHA-1比MD5多出了32bit，也就是对原文的碰撞几率降低了2^32 = 324294967296倍，但SHA-1比MD5性能略低。
摘要最终的。
在https://www.cmd5.com/ 可以查到使用不同摘要算法产生的字符串。

应用

消息摘要可以用来加密字串和验证内容是否被篡改，依据此特性，实际的应用包括：

1. 数据完整性检查（Data Integrity Check）
   用作SSL/TLS/IPsec, 原始数据生成消息摘要，共享对称密钥加密，接收方逆操作

2. 数字证书签名（Digital Certification Signature）
   将服务器的数字证书生成消息摘要，用CA的私钥加密，这个MD就变成了CA的数字签名，附在原始证书的末尾，作为CA签名的数字证书
   服务端与客户端认证时，将CA签名证书发给客户端，客户端拥有CA的公钥（手动或浏览器安装），可以解密CA的数字签名，得到消息摘要。然后客户端自身使用Hash算法运算数字证书，比较两个消息摘要是否一致，一致则认证通过。

3. 数据校验（Checksum），验证软件没有被篡改。
   将原始文件生成MD5 Checksum，用户下载完文件，计算下载文件的MD5 Checksum，如果相同，则文件完好。
   以JDK 8的下载为例，在https://www.oracle.com/webfolder/s/digest/8u241checksum.html可以看到安装文件的Checksum。界面如下：
   

4. 数据来源可靠性认证

5. 密码加密， 密码通过Hash算法（比如MD5）加密后存入数据库，即使被截取了，也无法得到原密码。

MD5等算法的安全性

在实际应用中，MD5产生的消息摘要除了用来验证数据的完整性，也常被用来对密码加密。在很多应用中，用户的密码都会被MD5加密后存入数据库。但密码丢失时，一般就只能重置密码而无法找回。这看上去很完美。但2004年的国家密码学年会上，山东大学王小云教授的"破译md5、haval－128、md4以及ripemd－128算法"的报告，实现了MD5的破译。更神奇的还是来看 http://www.cmd5.com/ 这个网站。
在密文输入消息摘要，点“查询”之后就可以看到原文了。

这看上去有悖摘要算法的原理，不是压缩计算？不是不可逆吗？ 为什么可以得到原文呢？看一下该网站的介绍稍稍安心了。该网站通过反向查询的方法获取结果，存储了大量的原文和摘要的对应。但是不管怎样， MD5等都不是很安全了。

哈希表（HashMap,Hash Table）

在Java等语言中， HashMap是一种常用的数据结构，以键值对的方式存储和访问数据的格式，优势是查找数据较快。
哈希表，也成为散列表，是基于快速存储的角度而设计，该数据结构可以理解为一个线性表，但其中的元素不是紧密排列的。
把键映射到表中位置的函数就是映射函数。
在HashMap中的较好的散列函数是使数据元素更快的被定位，常见的方法有：

1. 直接寻址， 去关键字或关键子的某个线性函数为散列地址。 表达式为：
   H(key)=key 或 H(key)=akey+b
   比如： 以公司员工的出生年月日为键。
2. 数字分析法。 找出数字的规律，尽可能利用这些数据构造冲突几率较低的散列地址。
   沿用上面的示例，出生年月日有很大的可能性出现冲突。这时候可以分析数据，找到合适的键。
3. 平方取中法。取关键字平方后的中间几位作为散列地址。
4. 折叠法。将关键字分割成位数相同的几部分，最后一部分位数可以不同，然后取这及部分的叠加和作为散列地址。
5. 随机数法。 选择一随机函数，取关键字的随机值作为散列地址，通常适用于关键子长度不同的场合。
6. 除留余数法。取关键子被某个不大于散列表长m的数p除后所得的余数为散列地址。

哈希表、数组和链表

• 数组是元素的有序序列，在内存中也是按照这个先后顺序连续存放在一起。在Java中的整型数组 int a[10]。
• 链表是物理上非连续、非顺序的存储结构，数据元素的逻辑顺序通过链表中的指针链接次序实现。
  简单数据结构如下：
  
  数组寻址容易，也就是查找容易，但插入和删除难； 链表寻址困难，但插入和删除容易。如果将数组和链表组合在一起，就可以发挥两者的优势。
  
  如何根据数组的特征计算下标就要使用哈希算法了。哈希算法根据Key来定位其在HashMap中的位置。
  在JDK 8中，通过hashCode()的高16位异或低16位实现的：(h = k.hashCode()) ^ (h >>> 16)，主要是从速度、功效、质量来考虑的。以上方法得到的int的hash值，然后再通过h & (table.length -1)来得到该对象在数据中保存的位置。