public synchronized V get(Object key) {
       Entry<?,?> tab[] = table;
//key为null这里会报空指针异常
       int hash = key.hashCode();
//计算下标
       int index = (hash & 0x7FFFFFFF) % tab.length;
//查找key
       for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
           if ((e.hash == hash) && e.key.equals(key)) {
               return (V)e.value;
           }
       }
       return null;
   }

//默认初始容量
   private static final int DEFAULT_INITIAL_CAPACITY = 16;
//最大容量
   private static final int MAXIMUM_CAPACITY = 1 << 30;
//默认负载因子
   private static final float DEFAULT_LOAD_FACTOR = 0.75f;
//底层存储结构
   Entry<K,V>[] table;
//数组大小
   private int size;
//扩容阈值
   private int threshold;
//负载因子
   private final float loadFactor;
//referencequeue用于弱引用的回收
   private final ReferenceQueue<Object> queue = new ReferenceQueue<>();
//修改次数
   int modCount;

public V get(Object key) {
    Object k = maskNull(key);
    int h = hash(k);
    Entry<K,V>[] tab = getTable();
    int index = indexFor(h, tab.length);
    Entry<K,V> e = tab[index];
    while (e != null) {
        if (e.hash == h && eq(k, e.get()))
            return e.value;
        e = e.next;
    }
    return null;
}

//treemap中entry的定义，除了k、v还有左右父节点指针，颜色标志位
   static final class Entry<K,V> implements Map.Entry<K,V> {
       K key;
       V value;
       Entry<K,V> left;
       Entry<K,V> right;
       Entry<K,V> parent;
       boolean color = BLACK;

       Entry(K key, V value, Entry<K,V> parent) {
           this.key = key;
           this.value = value;
           this.parent = parent;
       }

       public K getKey() {
           return key;
       }

       public V getValue() {
           return value;
       }

       public V setValue(V value) {
           V oldValue = this.value;
           this.value = value;
           return oldValue;
       }

       public boolean equals(Object o) {
           if (!(o instanceof Map.Entry))
               return false;
           Map.Entry<?,?> e = (Map.Entry<?,?>)o;

           return valEquals(key,e.getKey()) && valEquals(value,e.getValue());
       }

       public int hashCode() {
           int keyHash = (key==null ? 0 : key.hashCode());
           int valueHash = (value==null ? 0 : value.hashCode());
           return keyHash ^ valueHash;
       }

       public String toString() {
           return key + "=" + value;
       }
   }

   public V put(K key, V value) {
       Entry<K,V> t = root;
//root是null，则构建新entry作为root节点
       if (t == null) {
           compare(key, key); // type (and possibly null) check

           root = new Entry<>(key, value, null);
           size = 1;
           modCount++;
           return null;
       }
       int cmp;
       Entry<K,V> parent;
       // split comparator and comparable paths
       Comparator<? super K> cpr = comparator;
       if (cpr != null) {
	//如果设置了比较器，则循环查找插入点，出现相等情况则覆盖原始值
           do {
               parent = t;
               cmp = cpr.compare(key, t.key);
               if (cmp < 0)
                   t = t.left;
               else if (cmp > 0)
                   t = t.right;
               else
                   return t.setValue(value);
           } while (t != null);
       }
       else {
	//如果没有设置比较器，则使用对象内部的compareTo方法进行比较
           if (key == null)
               throw new NullPointerException();
           @SuppressWarnings("unchecked")
               Comparable<? super K> k = (Comparable<? super K>) key;
           do {
               parent = t;
               cmp = k.compareTo(t.key);
               if (cmp < 0)
                   t = t.left;
               else if (cmp > 0)
                   t = t.right;
               else
                   return t.setValue(value);
           } while (t != null);
       }
//找到插入位置，构造新的entry
       Entry<K,V> e = new Entry<>(key, value, parent);
//判断插入左节点还是右节点
       if (cmp < 0)
           parent.left = e;
       else
           parent.right = e;
//红黑树进行调整	
       fixAfterInsertion(e);
       size++;
       modCount++;
       return null;
   }

   public V get(Object key) {
       Entry<K,V> p = getEntry(key);
       return (p==null ? null : p.value);
   }
//直接根据排序查找
   final Entry<K,V> getEntry(Object key) {
//如果默认比较器不为空，则使用默认比较器进行比较
       if (comparator != null)
           return getEntryUsingComparator(key);
       if (key == null)
           throw new NullPointerException();
       @SuppressWarnings("unchecked")
           Comparable<? super K> k = (Comparable<? super K>) key;
//默认比较器为空，则使用compareTo方法进行比较
       Entry<K,V> p = root;
       while (p != null) {
           int cmp = k.compareTo(p.key);
           if (cmp < 0)
               p = p.left;
           else if (cmp > 0)
               p = p.right;
           else
               return p;
       }
       return null;
   }

   public V put(K key, V value) {
//检查key必须是keyType或者其子类，否则报错
       typeCheck(key);
//ordinal用于返回该枚举值在枚举类中的顺序，根据声明顺序而定，此处以该值作为下标
       int index = key.ordinal();
//取出旧值
       Object oldValue = vals[index];
//如果value为null，此处maskNull会返回一个固定的Object来代替
       vals[index] = maskNull(value);
       if (oldValue == null)
           size++;
       return unmaskNull(oldValue);
   }

//先判断是否合法，合法就通过ordinal访问下标，否则返回null
   public V get(Object key) {
       return (isValidKey(key) ?
               unmaskNull(vals[((Enum<?>)key).ordinal()]) : null);
   }
//判断key是否合法
   private boolean isValidKey(Object key) {
       if (key == null)
           return false;

//判断类型是否合法 
       Class<?> keyClass = key.getClass();
       return keyClass == keyType || keyClass.getSuperclass() == keyType;
   }

   public V remove(Object key) {
//判断类型是否合法
       if (!isValidKey(key))
           return null;
//找到下标
       int index = ((Enum<?>)key).ordinal();
//获取旧值
       Object oldValue = vals[index];
//释放该位置
       vals[index] = null;
       if (oldValue != null)
           size--;
       return unmaskNull(oldValue);
   }

//默认初始大小，必须是2的幂次，
   private static final int DEFAULT_CAPACITY = 32;
//最小容量
   private static final int MINIMUM_CAPACITY = 4;
//最大容量
   private static final int MAXIMUM_CAPACITY = 1 << 29;
//存储结构
   transient Object[] table; // non-private to simplify nested class access
//键值对个数
   int size;
//修改次数
   transient int modCount;
//null key对应的value
   static final Object NULL_KEY=new Object();

   public V put(K key, V value) {
//如果key==null，返回一个固定的Object对象作为键
       final Object k = maskNull(key);

       retryAfterResize: for (;;) {
           final Object[] tab = table;
           final int len = tab.length;
	//求元素对应的数组下标值
           int i = hash(k, len);
	//如果发生hash冲突，会调用nextKeyIndex向后探测没有使用的位置
           for (Object item; (item = tab[i]) != null;
                i = nextKeyIndex(i, len)) {
	//此处注意，判断键是否相等使用==，不是用equals
               if (item == k) {
                   @SuppressWarnings("unchecked")
		//冲突则把value替换，返回旧值
                       V oldValue = (V) tab[i + 1];
                   tab[i + 1] = value;
                   return oldValue;
               }
           }
	//更新size
           final int s = size + 1;
           // Use optimized form of 3 * s.
           // Next capacity is len, 2 * current capacity.
           if (s + (s << 1) > len && resize(len))
               continue retryAfterResize;

           modCount++;
	//key放在i
           tab[i] = k;
	//value放在i+1
           tab[i + 1] = value;
           size = s;
           return null;
       }
   }

   public V get(Object key) {
//如果key是null，返回null对应的Object对象
       Object k = maskNull(key);
       Object[] tab = table;
       int len = tab.length;
//查找key对应的下标
       int i = hash(k, len);
//遍历table，由于采用向后探测的方式解决hash冲突，所以这里回循环找下去
       while (true) {
           Object item = tab[i];
	//找到对应key，返回value
           if (item == k)
               return (V) tab[i + 1];
           if (item == null)
               return null;
	//若没有找到，有可能发生hash冲突，向后寻找
           i = nextKeyIndex(i, len);
       }
   }

  public V remove(Object key) {
      Object k = maskNull(key);
      Object[] tab = table;
      int len = tab.length;
      int i = hash(k, len);

      while (true) {
          Object item = tab[i];
          if (item == k) {
              modCount++;
              size--;
              @SuppressWarnings("unchecked")
                  V oldValue = (V) tab[i + 1];
//删除value
              tab[i + 1] = null;
//删除key
              tab[i] = null;
//该位置上的元素被删除后查找后面是否有元素可以被往前移动
              closeDeletion(i);
              return oldValue;
          }
          if (item == null)
              return null;
          i = nextKeyIndex(i, len);
      }
  }

//用于存储数据的数组
   protected Object[] elementData;

//元素个数
   protected int elementCount;

//扩容时增加的容量
   protected int capacityIncrement;