手写实现HashMap代码

了解HashMap底层=数组+链表

   HashMap底层源码通过 链表法 来解决hash冲突，找到hash值对应位置不为空,维护一个链表

   ThreadLocal底层源码，ThreadLocalMap中通过 线性探测 解决hash冲突，找到hash值对应位置不为空，依次向后找不为空为止

public interface  DIYMap<K,V> {
	//Map双列集合 基本功能是 快速取
	public V put(K k,V v);
	//快速取
	public V get(K k);

	//定义一个内部接口
	public interface Entry<K,V>{
		public K getKey();
		
		public V getValue();
	}
}

import java.util.ArrayList;
import java.util.List;
/*
	了解hashmap中entry实体的结构
	crc16算法
	hashmap底层=数组+链表
	通过hash算法带来的好处， 快存快取  / 数组在存的时候是需要遍历的
	HashMap底层是怎么回事?
		
 */
public class DIYHashMap<K, V> implements DIYMap<K, V>{
	//定义默认数组大小
	private  int defaultLenth=16;
	//负载因子，扩容标准    useSize/数组长度>0.75扩容
	private double defaultAddSizeFactor=0.75;
	//使用数组位置的总数
	private double useSize;
	//定义Map 骨架之一数组
	private Entry<K, V>[] table;

	public DIYHashMap(int defaultLenth, double defaultAddSizeFactor) {
		if(defaultLenth<0){
			throw new IllegalArgumentException("数组长度为负数"+defaultLenth);
		}
		if(defaultAddSizeFactor<=0 || Double.isNaN(defaultAddSizeFactor)){
			throw new IllegalArgumentException("扩容标准必须大于0的数字"+defaultLenth);
		}
	
		this.defaultLenth = defaultLenth;
		this.defaultAddSizeFactor = defaultAddSizeFactor;
		
		table=new Entry[defaultLenth];
	}

	//快速存取 hash算法
	public V put(K k, V v) {
		if(useSize>defaultAddSizeFactor*defaultLenth){
			//扩容
			up2Size();
		}
		//通过key来计算出 存储的位置
		int index=getIndex(k,table.length);
	
		Entry<K, V> entry=table[index];
		Entry<K, V> newEntry=new Entry<K, V>(k, v, null);
		if(entry==null){
			table[index]=newEntry;
			useSize++;
		}else{//维护数组相同位置队列
			Entry<K, V> tmp;
			while((tmp=table[index])!=null){
				tmp=tmp.next;
			}
			tmp.next=newEntry;
		}
		return newEntry.getValue();
	}

	private int getIndex(K k, int length) {
		//通常hashCode 取膜法
		int m=length-1;
		int index=hash(k.hashCode()) & m;
		return index >= 0 ? index : -index;
	}

	//创建自己的hash算法，保证计算出的位置 在数组中均匀分布
	private int hash(int hashCode) {
		hashCode=hashCode^((hashCode>>>20)^(hashCode>>>12));
		return hashCode^((hashCode>>>7)^(hashCode>>>4));
	}

	//扩容数组
	private void up2Size() {
		Entry<K, V>[] newTable=new Entry[defaultLenth*2];
		//将原table中的entry重新，散列到新的table中
		againHash(newTable);
	}

	//将原table中的entry重新，散列到新的table中
	private void againHash(Entry<K, V>[] newTable) {
		//数组里面对象 封装到list中,包括同一位置 有列表结构的都解析出来
		List<Entry<K,V>> entryList=new ArrayList<Entry<K,V>>();
		for(int i=0;i<table.length;i++){
			if(table[i]==null){
				continue;
			}
			findEntryByNext(table[i],entryList);
		}
		if(entryList.size()>0){
			useSize=0;
			defaultLenth=defaultLenth*2;
			table=newTable;
			for (Entry<K, V> entry : entryList) {
				if(entry.next!=null){
					entry.next=null;
				}
				put(entry.getKey(), entry.getValue());
			}
		}
	}

	private void findEntryByNext(Entry<K, V> entry, List<Entry<K, V>> entryList) {
		if(entry!=null && entry.next!=null){
			//这个entry对象已经形成链表结构
			entryList.add(entry);
			//递归 将链表中的entry实体 都一次封装到entryList链表中
			findEntryByNext(entry.next, entryList);
		}else{
			entryList.add(entry);
		}
	}

	//快取
	public V get(K k) {
		//通过key来计算出 存储的位置
		int index=getIndex(k,table.length);
			
		Entry<K, V> entry=table[index];
		
		if(entry==null){
			throw new NullPointerException();
		}

		return findValueByKey(k,entry);
	}
	
	private V findValueByKey(K k, Entry<K, V> entry) {
		
		if(k == entry.getKey() || k.equals(entry.getKey())){
			return entry.v;
		}else if(entry.next!=null){
			return findValueByKey(k,entry.next);
		}
		return null;
	}


	class Entry<K, V> implements DIYMap.Entry<K, V>{

		K k;
		V v;
		//指向被this挤压下去的entry
		Entry<K, V> next;
		
		public Entry(K k, V v, Entry<K, V> next) {
			this.k = k;
			this.v = v;
			this.next = next;
		}

		@Override
		public K getKey() {
			return k;
		}

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