从源码层理解Hashtable中的put和get

 首先我们先看put方法：将指定 key 映射到此哈希表中的指定 value。注意这里键key和值value都不可为空。

 public synchronized V put(K key, V value) {
         // 确保value不为null
         if (value == null) {
             throw new NullPointerException();
         }

         /*
          * 确保key在table[]是不重复的
          * 处理过程：
          * 1、计算key的hash值，确认在table[]中的索引位置
          * 2、迭代index索引位置，如果该位置处的链表中存在一个一样的key，则替换其value，返回旧值
          */
         Entry tab[] = table;
         int hash = hash(key);    //计算key的hash值
         int index = (hash & 0x7FFFFFFF) % tab.length;     //确认该key的索引位置
         //迭代，寻找该key，替换
         for (Entry e = tab[index] ; e != null ; e = e.next) {
             if ((e.hash == hash) && e.key.equals(key)) {
                 V old = e.value;
                 e.value = value;
                 return old;
             }
         }

         modCount++;
         if (count >= threshold) {  //如果容器中的元素数量已经达到阀值，则进行扩容操作
             rehash();
             tab = table;
             hash = hash(key);
             index = (hash & 0x7FFFFFFF) % tab.length;
         }

         // 在索引位置处插入一个新的节点
         Entry e = tab[index];
         tab[index] = new Entry<>(hash, key, value, e);
         //容器中元素+1
         count++;
         return null;
     }

        put方法的整个处理流程是：计算key的hash值，根据hash值获得key在table数组中的索引位置，然后迭代该key处的Entry链表（我们暂且理解为链表），若该链表中存在一个这个的key对象，那么就直接替换其value值即可，否则在将改key-value节点插入该index索引位置处。如下：

        首先我们假设一个容量为5的table，存在8、10、13、16、17、21。他们在table中位置如下：

        然后我们插入一个数：put(16,22)，key=16在table的索引位置为1，同时在1索引位置有两个数，程序对该“链表”进行迭代，发现存在一个key=16,这时要做的工作就是用newValue=22替换oldValue16，并将oldValue=16返回。

        在put(33,33)，key=33所在的索引位置为3，并且在该链表中也没有存在某个key=33的节点，所以就将该节点插入该链表的第一个位置。

        在HashTabled的put方法中有两个地方需要注意：

        1、HashTable的扩容操作，在put方法中，如果需要向table[]中添加Entry元素，会首先进行容量校验，如果容量已经达到了阀值，HashTable就会进行扩容处理rehash()，如下:

 protected void rehash() {
         int oldCapacity = table.length;
         //元素
         Entry[] oldMap = table;

         //新容量=旧容量 * 2 + 1
         int newCapacity = (oldCapacity << 1) + 1;
         if (newCapacity - MAX_ARRAY_SIZE > 0) {
             if (oldCapacity == MAX_ARRAY_SIZE)
                 return;
             newCapacity = MAX_ARRAY_SIZE;
         }

         //新建一个size = newCapacity 的HashTable
         Entry[] newMap = new Entry[];

         modCount++;
         //重新计算阀值
         threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
         //重新计算hashSeed
         boolean rehash = initHashSeedAsNeeded(newCapacity);

         table = newMap;
         //将原来的元素拷贝到新的HashTable中
         for (int i = oldCapacity ; i-- > 0 ;) {
             for (Entry old = oldMap[i] ; old != null ; ) {
                 Entry e = old;
                 old = old.next;

                 if (rehash) {
                     e.hash = hash(e.key);
                 }
                 int index = (e.hash & 0x7FFFFFFF) % newCapacity;
                 e.next = newMap[index];
                 newMap[index] = e;
             }
         }
     }

        在这个rehash()方法中我们可以看到容量扩大两倍+1，同时需要将原来HashTable中的元素一一复制到新的HashTable中，这个过程是比较消耗时间的，同时还需要重新计算hashSeed的，毕竟容量已经变了。这里对阀值啰嗦一下：比如初始值11、加载因子默认0.75，那么这个时候阀值threshold=8，当容器中的元素达到8时，HashTable进行一次扩容操作，容量 = 11* 2 + 1 =23，而阀值threshold=23*0.75 = 17，当容器元素再一次达到阀值时，HashTable还会进行扩容操作，一次类推。

     2、在计算索引位置index时，HashTable进行了一个与运算过程（hash & 0x7FFFFFFF）下面是计算key的hash值，这里hashSeed发挥了作用。

 private int hash(Object k) {
         return hashSeed ^ k.hashCode();
     }

        相对于put方法，get方法就会比较简单，处理过程就是计算key的hash值，判断在table数组中的索引位置，然后迭代链表，匹配直到找到相对应key的value,若没有找到返回null。

 public synchronized V get(Object key) {
         Entry tab[] = table;
         int hash = hash(key);
         int index = (hash & 0x7FFFFFFF) % tab.length;
         for (Entry e = tab[index] ; e != null ; e = e.next) {
             if ((e.hash == hash) && e.key.equals(key)) {
                 return e.value;
             }
         }
         return null;
     }