hashmap

数组的特点是：寻址容易，插入和删除困难；而 链表的特点是：寻址困难，插入和删除容易。那么我们能不能综合两者的特性，做出一种寻址容易，插入删除也容易的数据结构？答案是肯定的，这就是我们要提起的 哈希表，哈希表有多种不同的实现方法，我接下来解释的是最常用的一种方法 ——  拉链法，我们可以理解为 “ 链表的数组 ”  ，如图：

　　从上图我们可以发现哈希表是由数组+链表组成的，一个长度为16的数组中，每个元素存储的是一个链表的头结点。那么这些元素是按照什么样的规则存储到数组中呢。一般情况是通过hash(key)%len获得，也就是元素的key的哈希值对数组长度取模得到。比如上述哈希表中，12%16=12,28%16=12,108%16=12,140%16=12。所以12、28、108以及140都存储在数组下标为12的位置。

　　HashMap其实也是一个线性的数组实现的,所以可以理解为其存储数据的容器就是一个线性数组。这可能让我们很不解，一个线性的数组怎么实现按键值对来存取数据呢？这里HashMap有做一些处理。

　　1.首先HashMap里面实现一个静态内部类Entry，其重要的属性有 key , value, next，从属性key,value我们就能很明显的看出来Entry就是HashMap键值对实现的一个基础bean，我们上面说到HashMap的基础就是一个线性数组，这个数组就是Entry[]，Map里面的内容都保存在Entry[]里面。

2.HashMap的存取实现

     既然是线性数组，为什么能随机存取？这里HashMap用了一个小算法，大致是这样实现：

//存储时:
int hash = key.hashCode();// 这个hashCode方法这里不详述,只要理解每个key的hash是一个固定的int值
int index = hash % Entry[].length;
Entry[index] = value;

//取值时:
int hash = key.hashCode();
int index = hash % Entry[].length;
return Entry[index];

到这里我们轻松的理解了HashMap通过键值对实现存取的基本原理

    3.疑问：如果两个key通过hash%Entry[].length得到的index相同，会不会有覆盖的危险？

　　这里HashMap里面用到链式数据结构的一个概念。上面我们提到过Entry类里面有一个next属性，作用是指向下一个Entry。打个比方， 第一个键值对A进来，通过计算其key的hash得到的index=0，记做:Entry[0] = A。一会后又进来一个键值对B，通过计算其index也等于0，现在怎么办？HashMap会这样做:B.next = A,Entry[0] = B,如果又进来C,index也等于0,那么C.next = B,Entry[0] = C；这样我们发现index=0的地方其实存取了A,B,C三个键值对,他们通过next这个属性链接在一起。所以疑问不用担心。也就是说数组中存储的是最后插入的元素。到这里为止，HashMap的大致实现，我们应该已经清楚了。

　　当然HashMap里面也包含一些优化方面的实现，这里也说一下。比如：Entry[]的长度一定后，随着map里面数据的越来越长，这样同一个index的链就会很长，会不会影响性能？HashMap里面设置一个因素（也称为因子），随着map的size越来越大，Entry[]会以一定的规则加长长度。

 

 

 

一.概述

在Java中每一个对象都有一个哈希码，这个值可以通过hashCode()方法获得。hashCode()的值和对象的equals方法息息相关，是两个对象的值是否相等的依据，所以当我们覆盖一个类的equals方法的时候也必须覆盖hashCode方法。

例如String的hashCode方法为：

1 2 3 4 5 6 7 8 9 10 11 12 13 14

public   int  hashCode ( )   { int  h   =  hash ; if   (h   ==   0 )   { int  off   =  offset ; char  val [ ]   =  value ; int  len   =  count ; for   ( int  i   =   0 ;  i   &lt ;  len ;  i ++ )   { h   =   31 *h   +  val [off ++ ] ; } hash   =  h ; } return  h ; }

可以看得出，一个字符串的哈希值为s[0]*31^(n-1) + s[1]*31^(n-2) + … + s[n-1]，是一个整数。也就是说所有的字符串可以通过hashCode()将其映射到整数的区间中，由于在java中整数的个数是有限的（四个字节有正负，第一位为符号位-2^31~2^31-1），当s[0]*31^(n-1) + s[1]*31^(n-2) + … + s[n-1]足够大的时候可能会溢出，导致其变成负值。从上面的情况我们可以看出两个不同的字符串可能会被映射到同一个整数，发生冲突。因此java的开发人员选择了31这个乘数因子，尽量使得各个字符串映射的结果在整个java的整数域内均匀分布。

谈完java对象的哈希码，我们来看看今天的主角HashMap，HashMap可以看作是Java实现的哈希表。HashMap中存放的是key-value对，对应的类型为java.util.HashMap.Entry，所以在HashMap中数据都存放在一个Entry引用类型的数组table中。这里key是一个对象，为了把对象映射到table中的一个位置，我们可以通过求余法来，所以我们可以使用 [key的hashCode % table的长度]来计算位置（当然在实际操作的时候由于需要考虑table上的key的均匀分布可能需要对key的hashCode做一些处理）。

 

二.源码解析

 

相关属性

首先肯定是需要一个数组table，作为数据结构的骨干。

1	transient  Entry [ ]  table ;

这边定义了一个Entry数组的引用。
继续介绍几个概念把

• capacity容量 是指数组table的长度
• loadFactor 装载因子，是实际存放量/capacity容量 的一个比值，在代码中这个属性是描述了装载因子的最大值，默认大小为0.75
• threshold（阈值）代表hashmap存放内容数量的一个临界点，当存放量大于这个值的时候，就需要将table进行夸张，也就是新建一个两倍大的数组，并将老的元素转移过去。threshold = (int)(capacity * loadFactor);

 

put方法详解

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

public  V put (K key, V value )   {           if   (key   ==   null )               return  putForNullKey (value ) ;           int  hash   =  hash (key. hashCode ( ) ) ;           int  i   =  indexFor (hash, table. length ) ;           for   (Entry <K,V >  e   =  table [i ] ;  e   !=   null ;  e   =  e. next )   {               Object  k ;               if   (e. hash   ==  hash   &&   ( (k   =  e. key )   ==  key   ||  key. equals (k ) ) )   {                 V oldValue   =  e. value ;                 e. value   =  value ;                 e. recordAccess ( this ) ;                   return  oldValue ;               }           }         modCount ++;         addEntry (hash, key, value, i ) ;           return   null ;       }

在HashMap中我们的key可以为null，所以第一步就处理了key为null的情况。
当key为非null的时候，你也许会认为：恩，直接和table长度相除取模吧，但是这里没有，而是又好像做了一次哈希，这是为什么呢？这个还得先看indexFor(hash, table.length)方法，这个方法是决定存放位置的

1 2 3

static   int  indexFor ( int  h,   int  length )   {           return  h   &   (length - 1 ) ;       }

明眼的都可以发现，因为在HashMap中table的长度为2^n（我们把运算都换成二进制进行考虑），所以h & (length-1)就等价于h%length，这也就是说，如果对原本的hashCode不做变换的话，其除去低length-1位后的部分不会对key在table中的位置产生任何影响，这样只要保持低length-1位不变，不管高位如何都会冲突，所以就想办法使得高位对其结果也产生影响，于是就对hashCode又做了一次哈希

1 2 3 4 5 6 7

static int hash(int h) {         // This function ensures that hashCodes that differ only by         // constant multiples at each bit position have a bounded         // number of collisions (approximately 8 at default load factor).         h ^= (h >>> 20) ^ (h >>> 12);         return h ^ (h >>> 7) ^ (h >>> 4);     }

当找到key所对应的位置的时候，对对应位置的Entry的链表进行遍历，如果以及存在key的话，就更新对应的value，并返回老的value。如果是新的key的话，就将其增加进去。modCount是用来记录hashmap结构变化的次数的，这个在hashmap的fail-fast机制中需要使用（当某一个线程获取了map的游标之后，另一个线程对map做了结构修改的操作，那么原先准备遍历的线程会抛出异常）。addEntry的方法如下

1 2 3 4 5 6

void  addEntry ( int  hash, K key, V value,   int  bucketIndex )   {     Entry <K,V >  e   =  table [bucketIndex ] ;         table [bucketIndex ]   =   new  Entry <K,V > (hash, key, value, e ) ;           if   (size ++   >=  threshold )             resize ( 2   *  table. length ) ;       }

 

get方法

1 2 3 4 5 6 7 8 9 10 11 12 13

public  V get ( Object  key )   {           if   (key   ==   null )               return  getForNullKey ( ) ;           int  hash   =  hash (key. hashCode ( ) ) ;           for   (Entry <K,V >  e   =  table [indexFor (hash, table. length ) ] ;              e   !=   null ;              e   =  e. next )   {               Object  k ;               if   (e. hash   ==  hash   &&   ( (k   =  e. key )   ==  key   ||  key. equals (k ) ) )                   return  e. value ;           }           return   null ;       }

get方法其实就是将key以put时相同的方法算出在table的所在位置，然后对所在位置的链表进行遍历，找到hash值和key都相等的Entry并将value返回。