Java 哈希机制

标签：

  HashMap<String , Double> map = new HashMap<String , Double>();
      map.put("语文" , 80.0);
      map.put("数学" , 89.0);
      map.put("英语" , 78.2);

 public V put(K key, V value)
       {
           // 如果 key 为 null，调用 putForNullKey 方法进行处理
           if (key == null)
               return putForNullKey(value);
           // 根据 key 的 keyCode 计算 Hash 值
           int hash = hash(key.hashCode());
           // 搜索指定 hash 值在对应 table 中的索引
       <strong> int i = indexFor(hash, table.length);</strong>
           // 如果 i 索引处的 Entry 不为 null，通过循环不断遍历 e 元素的下一个元素
           for (Entry<K,V> e = table[i]; e != null; e = e.next)
           {
               Object k;
               // 找到指定 key 与需要放入的 key 相等（hash 值相同
               // 通过 equals 比较放回 true）
               if (e.hash == hash && ((k = e.key) == key
                   || key.equals(k)))
               {
                   V oldValue = e.value;
                   e.value = value;
                   e.recordAccess(this);
                   return oldValue;
               }
           }
           // 如果 i 索引处的 Entry 为 null，表明此处还没有 Entry
           modCount++;
           // 将 key、value 添加到 i 索引处
           addEntry(hash, key, value, i);
           return null;
       }

 static int hash(int h)
          {
              h ^= (h >>> 20) ^ (h >>> 12);
              return h ^ (h >>> 7) ^ (h >>> 4);
          }

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

 void addEntry(int hash, K key, V value, int bucketIndex)
              {
                  // 获取指定 bucketIndex 索引处的 Entry
                  Entry<K,V> e = table[bucketIndex];      // ①
                  // 将新创建的 Entry 放入 bucketIndex 索引处，并让新的 Entry 指向原来的 Entry
                  table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
                  // 如果 Map 中的 key-value 对的数量超过了极限
                  if (size++ >= threshold)
                      // 把 table 对象的长度扩充到 2 倍。
                      resize(2 * table.length);      // ②
              }

 // 以指定初始化容量、负载因子创建 HashMap
         public HashMap(int initialCapacity, float loadFactor)
         {
             // 初始容量不能为负数
             if (initialCapacity < 0)
                 throw new IllegalArgumentException(
                "Illegal initial capacity: " +
                     initialCapacity);
             // 如果初始容量大于最大容量，让出示容量
             if (initialCapacity > MAXIMUM_CAPACITY)
                 initialCapacity = MAXIMUM_CAPACITY;
             // 负载因子必须大于 0 的数值
             if (loadFactor <= 0 || Float.isNaN(loadFactor))
                 throw new IllegalArgumentException(
                 loadFactor);
             // 计算出大于 initialCapacity 的最小的 2 的 n 次方值。
             int capacity = 1;
             while (capacity < initialCapacity)
                 capacity <<= 1;
             this.loadFactor = loadFactor;
             // 设置容量极限等于容量 * 负载因子
             threshold = (int)(capacity * loadFactor);
             // 初始化 table 数组
             table = new Entry[capacity];              // ①
             init();
         }

public V get(Object key)
                   {
                       // 如果 key 是 null，调用 getForNullKey 取出对应的 value
                       if (key == null)
                           return getForNullKey();
                       // 根据该 key 的 hashCode 值计算它的 hash 码
                       int hash = hash(key.hashCode());
                       // 直接取出 table 数组中指定索引处的值，
                       for (Entry<K,V> e = table[indexFor(hash, table.length)];
                           e != null;
                           // 搜索该 Entry 链的下一个 Entr
                           e = e.next)          // ①
                       {
                           Object k;
                           // 如果该 Entry 的 key 与被搜索 key 相同
                           if (e.hash == hash && ((k = e.key) == key
                               || key.equals(k)))
                               return e.value;
                       }
                       return null;
                   }

  public class HashSet<E>
         extends AbstractSet<E>
         implements Set<E>, Cloneable, java.io.Serializable
     {
         // 使用 HashMap 的 key 保存 HashSet 中所有元素
         private transient HashMap<E,Object> map;
         // 定义一个虚拟的 Object 对象作为 HashMap 的 value
         private static final Object PRESENT = new Object();
         ...
         // 初始化 HashSet，底层会初始化一个 HashMap
         public HashSet()
         {
             map = new HashMap<E,Object>();
         }
         // 以指定的 initialCapacity、loadFactor 创建 HashSet
         // 其实就是以相应的参数创建 HashMap
         public HashSet(int initialCapacity, float loadFactor)
         {
             map = new HashMap<E,Object>(initialCapacity, loadFactor);
         }
         public HashSet(int initialCapacity)
         {
             map = new HashMap<E,Object>(initialCapacity);
         }
         HashSet(int initialCapacity, float loadFactor, boolean dummy)
         {
             map = new LinkedHashMap<E,Object>(initialCapacity
                 , loadFactor);
         }
         // 调用 map 的 keySet 来返回所有的 key
         public Iterator<E> iterator()
         {
             return map.keySet().iterator();
         }
         // 调用 HashMap 的 size() 方法返回 Entry 的数量，就得到该 Set 里元素的个数
         public int size()
         {
             return map.size();
         }
         // 调用 HashMap 的 isEmpty() 判断该 HashSet 是否为空，
         // 当 HashMap 为空时，对应的 HashSet 也为空
         public boolean isEmpty()
         {
             return map.isEmpty();
         }
         // 调用 HashMap 的 containsKey 判断是否包含指定 key
         //HashSet 的所有元素就是通过 HashMap 的 key 来保存的
         public boolean contains(Object o)
         {
             return map.containsKey(o);
         }
         // 将指定元素放入 HashSet 中，也就是将该元素作为 key 放入 HashMap
         public boolean add(E e)
         {
             return map.put(e, PRESENT) == null;
         }
         // 调用 HashMap 的 remove 方法删除指定 Entry，也就删除了 HashSet 中对应的元素
         public boolean remove(Object o)
         {
             return map.remove(o)==PRESENT;
         }
         // 调用 Map 的 clear 方法清空所有 Entry，也就清空了 HashSet 中所有元素
         public void clear()
         {
             map.clear();
         }
         ...
     }

Java 哈希机制

标签：

原文地址：http://blog.csdn.net/ymrfzr/article/details/51209714