Java_手动实现HashMap（含扩容以及原理）

1.哈希表的基本结构就是“数组+链表” 此外,JDK8中，当链表长度大于8时，为了保证查询速度，链表就转换为红黑树，小于等于6时候就又会变为链表。
原因：根据泊松分布，链表长度为8时候概率极低，转换成红黑树会占用更多的空间，为了保证均衡设为8(红黑树速度比链表快)

2.Entry[] table (将Entry放入到 table数组中) 就是HashMap的核心数组结构，我们也称之为“位桶数组”。

3.一个 Entry对象存储了：(1).key：键对象 (2).value:值对象 (3).next:下一个节点 (4).hash: 键对象的hash值

4.存储方法set的原理:

• (1)首先调用key对象的hashcode()方法，获得hashcode。

• (2)根据hashcode计算出hash值(要求在[0, 数组长度-1]区间) 数组初长度为16

• (3) 一种简单和常用的算法是(相除取余算法)：hash值 = hashcode%数组长度，这种算法可以让hash值均匀的分布在[0,数组长度-1]的区间。 早期的HashTable就是采用这种算法。但是，这种算法由于使用了“除法”，效率低下(jdk1.8之前)。

• (4)JDK1.8后来改进了算法。首先根据key的值计算出hashcode的值，然后根据hashcode计算出hash值(异或其右移十六位)，最后通过hash&（length-1）计算得到存储的位置，并且约定数组长度必须为2的整数幂，这样采用位运算既可实现和hashcode%length算出来的值是一样，也能提高效率，(流程图如下)。
  

• (5).从上图看出h = k.hashCode()) ^ (h >>> 16,为什么要 hashcode 异或其右移十六位的值： JDK1.8 优化了高位运算的算法，通过hashCode()的高16位异或低16位实现：(h = k.hashCode()) ^ (h >>> 16)。这么做可以在数组 table 的 length 比较小的时候，也能保证考虑到高低Bit都参与到Hash的计算中，同时不会有太大的开销。

5.HashMap数组的长度为什么是 2 的幂次方？

如图所示，length为2的幂次方,假设如果 length=16 ，那他的转化为二进制必定是11111……的形式，通过位运算&hash之后得到的数依旧是hash本身，那么可以再length长的数组长均匀分布，效率就高。

在 1、3、5、7、9、11、13、15 等奇数位处没有存放数据。因为hash值在与14（即 1110）进行&运算时，得到的结果最后一位永远都是0，0&一个数之后只能是0，也就是只能存放偶数位，即 0001、0011、0101、0111、1001、1011、1101、1111位置处是不可能存储数据的。

6.寻址方法get原理:

• (1) 获得key的hashcode，通过hash()散列算法（上面的4.(4)）定位到数组的位置。

• (2) 在链表上挨个比较key对象。 调用equals()方法，将key对象和链表上所有节点的key对象进行比较，直到碰到返回true的节点对象为止。

• (3) 返回equals()为true的节点对象的value对象。

• (4).注意: Java中规定，两个内容相同(equals()为true)的对象必须具有相等的hashCode。hash值相同不一定hash和key相同因为区余算法。

7.扩容问题 :HashMap的位桶数组，初始大小为16。实际使用时，显然大小是可变的。如果位桶数组中的元素达到(0.75*数组 length)， 就重新调整数组大小以2倍扩容
原因：0.75是负载因子，如果是0.5的话，数据存储一半就扩容太浪费空间，如果是1的话，数组满了再扩容会有很多哈希冲突，效率就变低了。

class HashNode2<K,V> {//结点的存储空间
	int hash ;
    K key;
    V values;
    HashNode2 next;

}
class SxtHashMap01<K,V>{
	HashNode2 [] table;//位桶数组
	int size ;
	
	public SxtHashMap01(){
	table = new HashNode2[16];
	}
	
	public void put(K key, V values) {
		//关于扩容数组问题没写   可根据ArrayList的扩容方法写出
		HashNode2 <K,V>newNode = new HashNode2<>();
		newNode.hash = Myhash(key.hashCode(),table.length);//hashCode()是Object类的方法获得的是一个独特的值(内存空间值)
		newNode.key = key;
		newNode.values= values;
		newNode.next=null;
		
		HashNode2 temp = table[newNode.hash];
		
		HashNode2 last =null;//记录结尾的结点
		boolean is = false; //用于记录如果 输入的key相同时候不需要加一个结点
		
		if(temp == null) {//数组 哈希值位置为空直接将新节点放入 ,没有哈希冲突
			
			table[newNode.hash]=newNode;
			size++;
			
		}else {//如果不为空就遍历newNode链表
		    while(temp!=null) {
		    	//如果key值相同,就覆盖
		    	if(temp.key.equals(key)) {
		    		temp.values =values;
		    		is = true;
		    		break;
		    	}else {
		    		//key值不相同就遍历下一个
		    		last=temp;
		    		temp = temp.next;
		    	}
		    		
		    }
		if(!is) {//没有重复的key值则加入到链表后面
		   last.next=newNode;
		   size++;
		}
	  }
	}

	public V get(K key) {
		//首先计算哈希值:确定存储这个结点   数组位置
		int hash = Myhash(key.hashCode(),table.length);
		
		V values=null;

		if(table[hash]!=null) {//如果查找到的hash存在那么实例化一个hashNode2的对象
			HashNode2 temp = table[hash];
		
		while(temp!=null) {//当结点不为空时候
		//然后遍历链表查找相同key的值
		if(temp.key.equals(key)) {//查找到之后存储跳出循环，没有相同的key会继续遍历
				values=(V)temp.values;
				break;
		}else {
			temp=temp.next;
		    }
	     }
      }
		return values ;
	}
	
	public int Myhash(int hashcode,int length) {//获得哈希值
		int a = hashcode&(length-1);//取模运算效率低只限定于hashcode为2的整数幂，但是分散性好，  另一种取余运算 hashcode&(length-1)效率高
		System.out.println("hash值为:"+a);
		return a;
	}
	@Override
	public String toString() {//重写toString 使用StringBuilder存储遍历
		StringBuilder sb = new StringBuilder("{");
		
		for(int i = 0;i<table.length;i++) {
			HashNode2 temp = table[i];
			while(temp!=null) {
				sb.append("key="+temp.key+" values="+temp.values+",");
				temp=temp.next;
			}
		}
		sb.setCharAt(sb.length()-1, '}');
		return sb.toString();
	}
	
} 

public class HashMap手动实现底层 {

	public static void main(String[] args) {
		SxtHashMap01<Integer,String>  m = new SxtHashMap01<>();
		m.put(11, "aa");
		m.put(22, "bb");
		m.put(33, "cc");

		m.put(53, "gg");
		m.put(69, "hh");
		m.put(85, "dd");
		
		System.out.println(m);

		System.out.println(m.get(53));
		System.out.println(m.get(69));
		System.out.println(m.get(85));
	}

}