java HashMap的插入操作源码分析

基础背景知识：

HashMap的储存结构:采用链表储存

每一个节点的数据结构：

   
   

    
    

     
     final K key;
    
    
    
    

     
     V value;
    
    
    
    

     
     Entry<K,V> next;
    
    
    
    

     
     final int hash;
    
    
   
   

用数组存储数据，一个数据来时根据哈希算法先计算其哈希值，放到相应地方

解决冲突的办法：数组链表，数据存放指针型数据

当冲突特别多的时候，查找数据的效率会收到影响，所以会对其做扩容

扩容的时机当size >= threshold = capcity * load_factor

扩容的办法:重新申请一个数组（table.length * 2）,并且把数据都迁移过来，迁移之后与原来的顺序相反

详解HashMap的插入操作：

put新的数据进去时

   
   

    
    

     
     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;
    
    
    
    

     
         }
    
    
   
   

1、如果put的key已经存在则返回oldValue

2、不重复的话直接插入数据 addEntry

addEntry（）

   
   

    
    

     
     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);
    
    
    
    

     
         }
    
    
   
   

1、先把数据插入

2、有可能会触发resize()

resize（）

   
   

    
    

     
     void resize(int newCapacity) {
    
    
    
    

     
             Entry[] oldTable = table;
    
    
    
    

     
             int oldCapacity = oldTable.length;
    
    
    
    

     
             if (oldCapacity == MAXIMUM_CAPACITY) {
    
    
    
    

     
                 threshold = Integer.MAX_VALUE;
    
    
    
    

     
                 return;
    
    
    
    

     
             }
    
    
    
    

     
      
    
    
    
    

     
             Entry[] newTable = new Entry[newCapacity];
    
    
    
    

     
             transfer(newTable);
    
    
    
    

     
             table = newTable;
    
    
    
    

     
             threshold = (int)(newCapacity * loadFactor);
    
    
    
    

     
         }
    
    
   
   

1、新建一个Entry[] table  数组大小的确定  table.length * 2

2、 参数设置  newcapcity = capcity * 2 ; threshold = newcapcity * load_factory ;

3、 转移数据 transform() 

transform() 

   
   

    
    

     
     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);
    
    
    
    

     
                 }
    
    
    
    

     
             }
    
    
    
    

     
         }
    
    
   
   

1、转移时从table前到后

2、后插入的数据在table里，而原来的数据成为newEntry.next