HashMap的底层存储结构和实现原理

文章目录

• 前言
• 一、HashMap是什么？
• 二、 数组
• 三、 链表
• 四、哈希算法
• 五、哈希冲突
• 总结

---

前言

HashMap实现了Map接口，我们常用来put/get *** 作读存键值对数据，比较典型的key-value结构，那么本文将详细分析此数据结构的底层原理及实现，包括底层存储原理，哈希算法，哈希冲突，源码等等。

一、HashMap是什么？

HashMap实际上是一种数组+链表（jdk1.8后加入红黑树）的一种数据结构，在put *** 作中通过内部定义的算法（哈希算法）找到数组的下标，将数组放在此数组元素中，如果该数组元素已经有了元素（hash冲突），将会把这个数组元素上的链表进行遍历，放在此链表的末尾，内部有next code下一步节点，根据这个来定义位置。

二、 数组

简单的说：数组就是采用一段连续的存储单元来存储数据。 特点：查询快O(1)，删除插入慢O(N)
查询快：因为数组是有自增的下标（索引），查询的时候可以依据索引直接定位到要查询的数据，因此从查询的角度来说效率更高。
删除插入慢：因为：当插入或者删除数据的时候，其他的数据会重新计算下标，重新移位，时间复杂度就是O(N)，假设有一个大小为10的数组，当要在下标4~5之间插入数据时，新数据的下标就为6，而原本为6的数据下标则为7,以此类推在6后面的所有数据都要重新移位，计算下标，除非插入和删除的是最后一个数据。

自己画的一个潦草的图

实际上ArrayList底层就是一个数组实现。

private static final long serialVersionUID = 8683452581122892189L;
private static final int DEFAULT_CAPACITY = 10;
private static final Object[] EMPTY_ELEMENTDATA = new Object[0];
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = new Object[0];
transient Object[] elementData; // 数组
private int size;
private static final int MAX_ARRAY_SIZE = 2147483639;

/** arraylist的add方法 **/
public boolean add(E var1) {
     this.ensureCapacityInternal(this.size + 1);
     this.elementData[this.size++] = var1;
     return true;
}

上面代码是jdk1.8的源码,可以看到“elementData”实际上就是一个数组，所以arrayList的底层实现实际上也是一个数组，也具有查询快，删除插入慢的特性。

三、 链表

是一种根据元素节点逻辑关系排列的一种数据结构，可以保存多个数据，有点像数组的概念，但是数组有个一个缺点——数组的长度 是固定的，不可改变，在长度固定的情况下首选肯定是数组，但是在开发中有时候保存的内容长度是不确定的，这个时候就能用链表来代替数组使用。

/** 每一个链表实际上就是多个节点 **/
class Node {    
	/** 保存数据 **/
	private String data; 
	/** 保存下一个节点 **/
	private Node nextCode;
	/** 每一个Node都必须保存有数据 **/
	public Node(String data){  
		  this.data = data ;
	}
	
	public void setNextCode(Node nextCode){
		  this.nextCode = nextCode ;
	}
	
	public Node getNextCode(){
		  return this.nextCode ;
	}
	
	public String getData(){
		  return this.data ;
	}
}

public class LinkedList {
	 
	public static void main(String[] args) {
		
		/** 1.准备数据 **/
		Node root = new Node("飞机头") ;
		Node n1 = new Node("机厢A") ;
		Node n2 = new Node("机厢B") ;
		/** 链接节点 **/
		root.setNextCode(n1);
		n1.setNextCode(n2);
		/** 2.取出数据 **/
		Node currentNode = root ;  //从当前根节点开始
		while( currentNode !=  null){
			System.out.println(currentNode.getData()) ;
			/** 将下一个节点设置为当前节点 **/
			currentNode = currentNode.getNextCode() ;
		}
 }
}

四、哈希算法

哈希算法是HashMap的底层实现原理里面很重要的一个组成部分，它来决定数据的位置及访问记录，哈希算法也叫散列算法，把我们存在map中的key（任意长度的值）通过此算法变成固定长度的key（地址），通过这个地址访问数据。

通过一张图，我们可以简单看一下

上图主要展示的就是我们存储一个任意长度的key，通过算法转换为一个固定地址。

实际上，hashCode是通过字符串算出它的ascii码，然后进行取模，得到哈希表的下标。

借用上面这张图，我们可以看到“lies”是存储到map里面的key，那么它是由4个字母组成，这4个字母分别的ascii码是l=108 i=105 e=101 s=115,相加等于429，那么这个429就是可以理解为lies的标识，然后通过hsah function（取模）得到哈希表的下标为9，把这个数据存储到下标为9的里面。

之所以要去hash function，主要是为了节省空间，这个也跟上面我所说到的数组的特性有关，假设lies的标识为429，那么数组是有固定长度的，不可能把数组扩容到429，那么这个时候就用到取模。

那么这个时候问题来了！！！敲黑板！！！
取模是为了节省空间，也是为了计算出在哈希表的下标，那么如果相同的ascii值去取模，得到的下标就是相同的，那么一个下标怎么存储两个数据呢？这个就叫哈希冲突（哈希碰撞）

五、哈希冲突

话不多说，先来张图简单看下

借用上面这张图，我们可以大概了解到哈希冲突的意思，“lies”与“foes”的ascii码都是429，那么相同的ascii码去取模，得到的哈希表下标都是9，这个时候就出现了哈希冲突。

那么出现哈希冲突后，不代表不能存储值或者覆盖原先的值，这个时候我们就用到了上面说的链表引入，因为链表是具有下一步指针特性的，当出现哈希冲突的时候，底层特性会将“lies”的下一步节点指向“foes”，那么也就是说在下标为9的结构里面，存储了lies，但是因为链表特性，lies的下一步节点指向了foes，

	public static void main(String[] args) {
		TestEs map = new TestEs();
		map.put("A", "A");
		map.put("B", "B");
		map.put("C", "C");
		map.put("D", "D");
		map.put("E", "E");
	}
	public void put(String key, String value) {
		logger.info("key={},hash值={},存储位置={}", key, key.hashCode(), Math.abs(key.hashCode() % 15));
	}
	
put - key=A,hash值=65,存储位置=5
put - key=B,hash值=66,存储位置=6
put - key=C,hash值=67,存储位置=7
put - key=D,hash值=68,存储位置=8
put - key=E,hash值=69,存储位置=9

上述代码是我写的一个小例子，我进行取模取的是15，通过这个例子可以看到不管运行几次，hash值是不会变的；这也是hash算法的一个特点，是具有幂等性的。

这个时候HashMap的基本组成我想应该有个大概的了解了，那么我们使用PUT *** 作时，究竟是怎么一步步将值存储的呢？又是怎么样的流程呢？这个时候就要解析源码了。

JDK的源码我就不一一截图了，我仿造着源码自己写了套HashMap的实现，并把自己的理解都标注了注释。

首先定义一个Map接口
这个接口我会定义put/get方法 以及存储的接口

package com.company;

public interface Map<K, V> {

	V put(K k, V v);

	V get(K k);

	int size();


	interface Entry<K, V> {
		K getKey();

		V getValue();
	}
}

创建一个实体类，实现定义的Map接口

package com.company;

public class HashMap<K, V> implements Map<K, V> {

	private Entry<K, V> table[] = null;

	int size = 0;

	public HashMap() {
		this.table = new Entry[16];
	}

	/**
	 * step1：通过key 使用hash算法得到hashCode值
	 * step2：通过hash值取模得到index下标，找到此下标对应的对象
	 * step3：判断当前对象是否为空  为空 可以直接存储
	 * step4：不为空 说明出现了hash冲突 用到next链表特性
	 * step5：返回当前节点对象
	 *
	 * @param k
	 * @param v
	 * @return
	 */
	public V put(K k, V v) {
		/* 通过hash算法  得到要存储数组的下标 */
		int index = hash(k);
		/* 以此下标 获取数组中的对象 */
		Entry<K, V> entry = table[index];
		/* 为空 则证明可以直接进行存储 */
		if (null == entry) {
			table[index] = new Entry(k, v, index, null);
			size++;
		}
		/* 不为空，发生了冲突，使用链表 */
		else {
			table[index] = new Entry(k, v, index, entry);
		}
		return table[index].getValue();
	}

	/**
	 * 这个就是我自己定义hash算法的方法
	 * 这个比较简单，真实的源码会有一些移位的 *** 作
	 * 主要涉及到性能和计算机底层原理的一些东西 这个我还不懂
	 *
	 * @param k
	 * @return
	 */
	private int hash(K k) {
		int index = k.hashCode() % 16;
		return index >= 0 ? index : -index;
	}

	/**
	 * 通过key 进行hash得到 index
	 * 通过index下标获取数组对象
	 * 判断当前对象是否为空 如果不为空
	 * 判断是否相等 如果不相等
	 * 判断next节点是否为空  如果不为空
	 * 判断是否相等 直到相等或者为空。
	 * 返回。
	 *
	 * @param k
	 * @return
	 */
	public V get(K k) {
		if (0 == size) {
			return null;
		}
		int index = hash(k);
		/* 以此下标 获取数组中的对象 */
		Entry<K, V> entry = findValue(table[index], k);
		return null == entry ? null : entry.getValue();
	}

	/**
	 * 采取递归来完成get的步骤
	 *
	 * @param entry
	 * @param k
	 * @return
	 */
	private Entry<K, V> findValue(Entry<K, V> entry, K k) {
		if (k.equals(entry.getKey()) || k == entry.getKey()) {
			return entry;
		} else {
			if (null != entry.next) {
				return findValue(entry.next, k);
			}
		}
		return null;
	}

	public int size() {
		return size;
	}

	class Entry<K, V> implements Map.Entry<K, V> {
		K k;
		V v;
		int hash;
		Entry<K, V> next;

		public Entry(K k, V v, int hash, Entry<K, V> next) {
			this.k = k;
			this.v = v;
			this.hash = hash;
			this.next = next;
		}

		public K getKey() {
			return k;
		}

		public V getValue() {
			return v;
		}
	}
}

测试

package com.company;

public class TestMap {


	public static void main(String[] args) {
		Map<String, String> map = new HashMap<String, String>();
		map.put("知夏", "这是一篇技术分享的文章");
		map.put("爱吃饭的侯", "小侯爱吃饭");
		System.out.println(map.get("知夏"));
		System.out.println(map.get("爱吃饭的侯"));
	}
}

这是参照源码简单写的一个map实现，代码解释，实现原理都写成了注释，实际的源码比这个发杂的多的多，但是这个例子依然是map的实现逻辑，当然这个例子没有实现红黑树。

这里顺便提一下红黑树，简单的说 当数组的容量固定的时候，如果存储的数据超过了数组的固定容量，那么就会出现巨大的哈希冲突，这个时候会使用链表特性，会纵向的无限延申数据，上面我也记录了链表的特性，插入快，查询慢，如果出现了这种情况 对性能和查询是非常不利的，这就是为什么要推出红黑树，红黑树准备再开一篇文章单独记录。

---

总结

写到这里，我们知道了HashMap的结构和底层实现，我们知道它是一种以数组+链表+红黑树为组合的key-value存储的数据结构，它是我们开发中使用率很高的一个朋友，它的底层涵盖了哈希算法，如何解决哈希冲突，如何解决链表无限延申，对数据和结构进行了重新定义，以前呢，我没有想过要去深入了解它，会用就行了，趁着疫情封控在家，花时间整理一下，顺带记录下来，回头忘了可以过来重温下。