HashMap的存储结构及原理-CSDN博客

1、HashMap的数据结构(HashMap通过hashcode对其内容进行快速查找，是无序的)，数据结构中有数组和链表来实现对数据的存储，但这两者基本上是两个极端。
数组：数组的存储区是连续的，占用内存严重，故空间复杂度很大。但数组的二分查找时间度小；数组的特点：寻址容易，插入和删除困难。
链表：链表的储存区离散，占用内存比较宽松，故空间复杂度很小，但时间复杂度大；链表的特点：寻址困难，插入和删除容易。
哈希表
HashMap是由数组+链表组成；寻址容易，插入和删除容易。
（存储单元数组Entry[]，数组里面包含链表）

HashMap其实也是由一个线性的数组实现的。所以可以理解为其存储数据的容器就是一个线性容器；
HashMap里面有一个内部静态类Entry，其重要的属性有key，value，next，从属性key，value 就可以很明显的看出来 Entry就是HashMap键值对实现的一个基础bean；也就是说HashMap的基础就是一个线性数组，这个数组就是Entry[]，Map里面的内容都保存在Entry[]中；

    /** 
     * The table, resized as necessary. Length MUST Always be a power of two. 
     */        
    transient Entry[] table;

2、HashMap的存取实现
2.1：存储
通过把key值进行hash来定位对象的，这样可以提供比线性存储更好的性能。
实际上，Map的底层数据结构就是一个数组的数组（准确的说其实是一个链表+数组）。第一个数组的索引值是key的哈希码。通过这个索引可以定位到第二个数组，第二个数组通过使用equals方法进行线性搜索的方式来查找对象。
这里HashMap用了一个算法。

//存储时候：
int hash=key.hashCode(); //获取key的hashCode，这个值是一个固定的int值
int index=hash%Entry[].length；//获取数组下标：key的hash值对Entry数组长度进行取余
Entry[index]=value；

注意：如果两个key通过hash%Entry[].length得到的index相同，会不会覆盖？
是不会的。**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这个属性链接在一起。所以疑问不用担心。
也就是说Entry[]数组中存储的是最后插入的数据

public V put(K key, V value) {  
       if (key == null)  
           return putForNullKey(value); //null总是放在数组的第一个链表中  
       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;  
           //如果key在链表中已存在，则替换为新value  
           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;  
   }  
 
  
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); //参数e, 是Entry.next  
   //如果size超过threshold，则扩充table大小。再散列  
   if (size++ >= threshold)  
           resize(2 * table.length);  
}

2.2：取值
获取key的hashcode值，通过hash值去hash%Entry[].length获取Entry[hash%Entry[].length]，定位到该数组元素之后，再遍历该元素处的链表。

//取值时候：
int hash=key.hashCode();
int index =hash%Entry[].length;
return Entry[index];
 
[java] view plain copy
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;

当哈希表的容量超过默认容量时，必须要调整table的大小。当容量达到最大值时，该方法Integer.MAX_VALUE返回，这时，就需要创建一张表，将原来的表映射到新表中。

3、HashMap、HashTable和ConcurrentHashMap的线程安全问题
HashMap：线程不安全的。

HashTable：锁住整张hash表，让线程独占。hashMap允许为空。通过分析Hashtable就知道，synchronized是针对整张Hash表的，即每次锁住整张表。让线程独占，安全的背后是巨大的浪费。

ConcurrentHashMap:一个更快的hashmap，它提供了好得多的并发性。多个读操作几乎总可以并发地执行。他是锁段（默认：把hash表分为16个段），在get，put，remove等操作中，ConcurrentHashMap只锁定当前需要用到的段，只有在求size的时候才锁定整张hash表。

hashmap的默认初始长度是多少？为什么这样规定？
默认长度是16，并且每次自动或手动扩展时是2的幂。
Hash算法均匀分布的原则：长度16或者其他2的幂，Length-1的值是所有二进制位全为1，这种情况下，index的结果等同于HashCode后几位的值。只要输入的HashCode本身分布均匀，Hash算法的结果就是均匀的。
resize(2 * table.length)

高并发情况下，为什么hashmap会出现死锁？
HashMap进行存储时，如果size超过当前最大容量*负载因子时候会发生resize，而这段代码中又调用了transfer()方法，而这个方法实现的机制就是将每个链表转化到新链表，并且链表中的位置发生反转，而这在多线程情况下是很容易造成链表回路，从而发生get()死循环。
假如有两个线程P1、P2，以及链表 a=》b=》null
1、P1先执行，执行完"Entry<K,V> next = e.next;"代码后发生阻塞，或者其他情况不再执行下去，此时e=a，next=b
2、而P2已经执行完整段代码，于是当前的新链表newTable[i]为b=》a=》null
3、P1又继续执行"Entry<K,V> next = e.next;"之后的代码，则执行完"e=next;"后，newTable[i]为a《=》b，则造成回路，while(e!=null)一直死循环

void transfer(Entry[] newTable) {
        Entry[] src = table;
        int newCapacity = newTable.length;
        for (int j = 0; j < src.length; j++) {
            Entry<K,V> e = src[j];
            if (e != null) {
                src[j] = null;
                do {
                    Entry<K,V> next = e.next;
                    int i = indexFor(e.hash, newCapacity);
                    e.next = newTable[i];
                    newTable[i] = e;
                    e = next;
                } while (e != null);//this
            }
        }
    }