了解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;
}
}
}