Java HashMap源码分析

publicclassMyMap<K,V>{
privateintsize;//当前容量
privatestaticintINIT_CAPACITY=16;//默认容量
privateEntry<K,V>[]container;//实际存储数据的数组对象
privatestaticfloatLOAD_FACTOR=0.75f;//装载因子
privateintmax;//能存的最大的数=capacity*factor

//自己设置容量和装载因子的构造器
publicMyMap(intinit_Capaticy,floatload_factor){
if(init_Capaticy<0)
thrownewIllegalArgumentException("Illegalinitialcapacity:"
+init_Capaticy);
if(load_factor<=0||Float.isNaN(load_factor))
thrownewIllegalArgumentException("Illegalloadfactor:"+load_factor);
this.LOAD_FACTOR=load_factor;
max=(int)(init_Capaticy*load_factor);
container=newEntry[init_Capaticy];
}

//使用默认参数的构造器
publicMyMap(){
this(INIT_CAPACITY,LOAD_FACTOR);
}

/**
*存
*
*@paramk
*@paramv
*@return
*/
publicbooleanput(Kk,Vv){
//1.计算K的hash值
//因为自己很难写出对不同的类型都适用的Hash算法，故调用JDK给出的hashCode()方法来计算hash值
inthash=k.hashCode();
//将所有信息封装为一个Entry
Entry<K,V>temp=newEntry(k,v,hash);
if(setEntry(temp,container)){
//大小加一
size++;
returntrue;
}
returnfalse;
}

/**
*扩容的方法
*
*@paramnewSize
*新的容器大小
*/
privatevoidreSize(intnewSize){
//1.声明新数组
Entry<K,V>[]newTable=newEntry[newSize];
max=(int)(newSize*LOAD_FACTOR);
//2.复制已有元素,即遍历所有元素，每个元素再存一遍
for(intj=0;j<container.length;j++){
Entry<K,V>entry=container[j];
//因为每个数组元素其实为链表，所以…………
while(null!=entry){
setEntry(entry,newTable);
entry=entry.next;
}
}
//3.改变指向
container=newTable;

}

/**
*将指定的结点temp添加到指定的hash表table当中
*添加时判断该结点是否已经存在
*如果已经存在，返回false
*添加成功返回true
*@paramtemp
*@paramtable
*@return
*/
privatebooleansetEntry(Entry<K,V>temp,Entry[]table){
//根据hash值找到下标
intindex=indexFor(temp.hash,table.length);
//根据下标找到对应元素
Entry<K,V>entry=table[index];
//3.若存在
if(null!=entry){
//3.1遍历整个链表，判断是否相等
while(null!=entry){
//判断相等的条件时应该注意，除了比较地址相同外，引用传递的相等用equals()方法比较
//相等则不存，返回false
if((temp.key==entry.key||temp.key.equals(entry.key))&&
temp.hash==entry.hash&&(temp.value==entry.value||temp.value.equals(entry.value))){
returnfalse;
}

elseif(temp.key==entry.key&&temp.value!=entry.value){
entry.value=temp.value;
returntrue;
}

//不相等则比较下一个元素
elseif(temp.key!=entry.key){
//到达队尾，中断循环
if(null==entry.next){
break;
}
//没有到达队尾，继续遍历下一个元素
entry=entry.next;
}
}
//3.2当遍历到了队尾，如果都没有相同的元素，则将该元素挂在队尾
addEntry2Last(entry,temp);
returntrue;
}
//4.若不存在,直接设置初始化元素
setFirstEntry(temp,index,table);
returntrue;
}

privatevoidaddEntry2Last(Entry<K,V>entry,Entry<K,V>temp){
if(size>max){
reSize(container.length*4);
}
entry.next=temp;

}

/**
*将指定结点temp，添加到指定的hash表table的指定下标index中
*@paramtemp
*@paramindex
*@paramtable
*/
privatevoidsetFirstEntry(Entry<K,V>temp,intindex,Entry[]table){
//1.判断当前容量是否超标，如果超标，调用扩容方法
if(size>max){
reSize(table.length*4);
}
//2.不超标，或者扩容以后，设置元素
table[index]=temp;
//！！！！！！！！！！！！！！！
//因为每次设置后都是新的链表，需要将其后接的结点都去掉
//NND，少这一行代码卡了哥哥7个小时（代码重构）
temp.next=null;
}

/**
*取
*
*@paramk
*@return
*/
publicVget(Kk){
Entry<K,V>entry=null;
//1.计算K的hash值
inthash=k.hashCode();
//2.根据hash值找到下标
intindex=indexFor(hash,container.length);
//3。根据index找到链表
entry=container[index];
//3。若链表为空，返回null
if(null==entry){
returnnull;
}
//4。若不为空，遍历链表，比较k是否相等,如果k相等，则返回该value
while(null!=entry){
if(k==entry.key||entry.key.equals(k)){
returnentry.value;
}
entry=entry.next;
}
//如果遍历完了不相等，则返回空
returnnull;

}

/**
*根据hash码，容器数组的长度,计算该哈希码在容器数组中的下标值
*
*@paramhashcode
*@paramcontainerLength
*@return
*/
publicintindexFor(inthashcode,intcontainerLength){
returnhashcode&(containerLength-1);

}

/**
*用来实际保存数据的内部类,因为采用挂链法解决冲突，此内部类设计为链表形式
*
*@param<K>key
*@param<V>
*value
*/
classEntry<K,V>{
Entry<K,V>next;//下一个结点
Kkey;//key
Vvalue;//value
inthash;//这个key对应的hash码，作为一个成员变量，当下次需要用的时候可以不用重新计算

//构造方法
Entry(Kk,Vv,inthash){
this.key=k;
this.value=v;
this.hash=hash;

}

//相应的getter()方法

}
}

publicclassTest{

publicstaticvoidmain(String[]args){
MyMap<String,String>mm=newMyMap<String,String>();
LongaBeginTime=System.currentTimeMillis();//记录BeginTime
for(inti=0;i<1000000;i++){
mm.put(""+i,""+i*100);
}
LongaEndTime=System.currentTimeMillis();//记录EndTime
System.out.println("inserttime-->"+(aEndTime-aBeginTime));

LonglBeginTime=System.currentTimeMillis();//记录BeginTime
mm.get(""+100000);
LonglEndTime=System.currentTimeMillis();//记录EndTime
System.out.println("seachtime--->"+(lEndTime-lBeginTime));
}
}