Java中的HashMap

标签：text   哈希   dfa   .com   nta   log   有序   package   cap   

? HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。
HashMap 继承于AbstractMap，实现了Map、 Cloneable、 java.io. Serializable 接口。
HashMap 的实现不是同步的，这意味着它不是线程安全的。它的key、 value都可以为null。此外，HashMap中的映射不是有序的。
HashMap 的实例有两个参数影响其性能：“初始容量” 和 “加载因子”。容量是哈希表中桶的数量，初始容量 只是哈希表在创建时的容量。加载因子是哈希表在其容量自动增加之前可以达到多满的一种尺度。当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行 rehash 操作（即重建内部数据结构），从而哈希表将具有大约两倍的桶数。
通常，默认加载因子是 0.75, 这是在时间和空间成本上寻求一种折衷。加载因子过高虽然减少了空间开销，但同时也增加了查询成本（在大多数 HashMap 类的操作中，包括 get 和 put 操作，都反映了这一点）。在设置初始容量时应该考虑到映射中所需的条目数及其加载因子，以便最大限度地减少 rehash 操作次数。如果初始容量大于最大条目数除以加载因子，则不会发生 rehash 操作。

HashMap的继承关系

HashMap与Map关系如下图：

HashMap的构造函数

HashMap共有4个构造函数,如下：

// 默认构造函数。
 HashMap()
 // 指定“容量大小”的构造函数
 HashMap(int capacity)
 // 指定“容量大小”和“加载因子”的构造函数
 HashMap(int capacity, float loadFactor)
 // 包含“子Map”的构造函数
 HashMap(Map<? extends K, ? extends V> map)

HashMap的API

复制代码代码如下:

void                  clear()
 Object              clone()
 boolean            containsKey(Object key)
 boolean            containsValue(Object value)
 Set<Entry<K, V>>   entrySet()
 V                      get(Object key)
 boolean            isEmpty()
 Set<K>            keySet()
 V             put(K key, V value)
 void         putAll(Map<? extends K, ? extends V> map)
 V              remove(Object key)
 int            size()
 Collection<V>     values()

二、 HashMap源码

? 为了更了解HashMap的原理，下面对HashMap源码代码作出分析。

package java.util;

import java.io.*;

public class HashMap<K,V>

     extends AbstractMap<K,V>

     implements Map<K,V>, Cloneable, Serializable

{

? // 默认的初始容量是16，必须是2的幂。

? static final int DEFAULT_INITIAL_CAPACITY = 16;

? // 最大容量（必须是2的幂且小于2的30次方，传入容量过大将被这个值替换）

? static final int MAXIMUM_CAPACITY = 1 << 30;

? // 默认加载因子

? static final float DEFAULT_LOAD_FACTOR = 0.75f;

? // 存储数据的Entry数组，长度是2的幂。

? // HashMap是采用拉链法实现的，每一个Entry本质上是一个单向链表

? transient Entry[] table;

? // HashMap的大小，它是HashMap保存的键值对的数量

? transient int size;

? // HashMap的阈值，用于判断是否需要调整HashMap的容量（threshold = 容量*加载因子）

? int threshold;

? // 加载因子实际大小

? final float loadFactor;

? // HashMap被改变的次数

? transient volatile int modCount;

? // 指定“容量大小”和“加载因子”的构造函数

 public HashMap(int initialCapacity, float loadFactor) {

         if (initialCapacity < 0)

             throw new IllegalArgumentException("Illegal initial capacity: " +

                                                initialCapacity);

? // HashMap的最大容量只能是MAXIMUM_CAPACITY

 if (initialCapacity > MAXIMUM_CAPACITY)

             initialCapacity = MAXIMUM_CAPACITY;

         if (loadFactor <= 0 || Float.isNaN(loadFactor))

             throw new IllegalArgumentException("Illegal load factor: " +

                                                loadFactor);

? // 找出“大于initialCapacity”的最小的2的幂

int capacity = 1;

         while (capacity < initialCapacity)

             capacity <<= 1;

? // 设置“加载因子”

        this.loadFactor = loadFactor;

? // 设置“HashMap阈值”，当HashMap中存储数据的数量达到threshold时，就需要将HashMap的容量加倍。

        threshold = (int)(capacity * loadFactor);

? // 创建Entry数组，用来保存数据

table = new Entry[capacity];

         init();

     }

? // 指定“容量大小”的构造函数

public HashMap(int initialCapacity) {

         this(initialCapacity, DEFAULT_LOAD_FACTOR);

     }

? // 默认构造函数。

    public HashMap() {

? // 设置“加载因子”

        this.loadFactor = DEFAULT_LOAD_FACTOR;

? // 设置“HashMap阈值”，当HashMap中存储数据的数量达到threshold时，就需要将HashMap的容量加倍。

        threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);

? // 创建Entry数组，用来保存数据

   table = new Entry[DEFAULT_INITIAL_CAPACITY];

         init();

     }

? // 包含“子Map”的构造函数

    public HashMap(Map<? extends K, ? extends V> m) {

        this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,

                      DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);

? // 将m中的全部元素逐个添加到HashMap中

   putAllForCreate(m);

     }

     static int hash(int h) {

         h ^= (h >>> 20) ^ (h >>> 12);

         return h ^ (h >>> 7) ^ (h >>> 4);

     }

? // 返回索引值

? // h & (length-1)保证返回值的小于length

static int indexFor(int h, int length) {

         return h & (length-1);

     }

     public int size() {

         return size;

     }

     public boolean isEmpty() {

         return size == 0;

     }

? // 获取key对应的value

public V get(Object key) {

         if (key == null)

             return getForNullKey();

? // 获取key的hash值

        int hash = hash(key.hashCode());

? // 在“该hash值对应的链表”上查找“键值等于key”的元素

  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;

     }

? // 获取“key为null”的元素的值

? // HashMap将“key为null”的元素存储在table[0]位置！

 private V getForNullKey() {

         for (Entry<K,V> e = table[0]; e != null; e = e.next) {

             if (e.key == null)

                 return e.value;

         }

         return null;

     }

? // HashMap是否包含key

public boolean containsKey(Object key) {

         return getEntry(key) != null;

     }

? // 返回“键为key”的键值对

    final Entry<K,V> getEntry(Object key) {

? // 获取哈希值

? // HashMap将“key为null”的元素存储在table[0]位置，“key不为null”的则调用hash()计算哈希值

        int hash = (key == null) ? 0 : hash(key.hashCode());

? // 在“该hash值对应的链表”上查找“键值等于key”的元素

 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 != null && key.equals(k))))

                 return e;

         }

         return null;

     }

? // 将“key-value”添加到HashMap中

    public V put(K key, V value) {

? // 若“key为null”，则将该键值对添加到table[0]中。

        if (key == null)

            return putForNullKey(value);

? // 若“key不为null”，则计算该key的哈希值，然后将其添加到该哈希值对应的链表中。

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取代旧的value。然后退出！

if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {

                 V oldValue = e.value;

                 e.value = value;

                 e.recordAccess(this);

                 return oldValue;

             }

         }

? // 若“该key”对应的键值对不存在，则将“key-value”添加到table中

modCount++;

         addEntry(hash, key, value, i);

         return null;

     }

? // putForNullKey()的作用是将“key为null”键值对添加到table[0]位置

  private V putForNullKey(V value) {

         for (Entry<K,V> e = table[0]; e != null; e = e.next) {

             if (e.key == null) {

                 V oldValue = e.value;

                 e.value = value;

                 e.recordAccess(this);

                 return oldValue;

             }

         }

? // 这里的完全不会被执行到!

 modCount++;

         addEntry(0, null, value, 0);

         return null;

     }

? // 创建HashMap对应的“添加方法”，

? // 它和put()不同。putForCreate()是内部方法，它被构造函数等调用，用来创建HashMap

? // 而put()是对外提供的往HashMap中添加元素的方法。

 private void putForCreate(K key, V value) {

         int hash = (key == null) ? 0 : hash(key.hashCode());

         int i = indexFor(hash, table.length);

? // 若该HashMap表中存在“键值等于key”的元素，则替换该元素的value值

for (Entry<K,V> e = table[i]; e != null; e = e.next) {

             Object k;

             if (e.hash == hash &&

                 ((k = e.key) == key || (key != null && key.equals(k)))) {

                 e.value = value;

                 return;

             }

         }

? // 若该HashMap表中不存在“键值等于key”的元素，则将该key-value添加到HashMap中

        createEntry(hash, key, value, i);

    }

? // 将“m”中的全部元素都添加到HashMap中。

? // 该方法被内部的构造HashMap的方法所调用。

    private void putAllForCreate(Map<? extends K, ? extends V> m) {

? // 利用迭代器将元素逐个添加到HashMap中

 for (Iterator<? extends Map.Entry<? extends K, ? extends V>> i = m.entrySet().iterator(); i.hasNext(); ) {

             Map.Entry<? extends K, ? extends V> e = i.next();

             putForCreate(e.getKey(), e.getValue());

         }

     }

? // 重新调整HashMap的大小，newCapacity是调整后的单位

 void resize(int newCapacity) {

         Entry[] oldTable = table;

         int oldCapacity = oldTable.length;

         if (oldCapacity == MAXIMUM_CAPACITY) {

             threshold = Integer.MAX_VALUE;

             return;

         }

? // 新建一个HashMap，将“旧HashMap”的全部元素添加到“新HashMap”中，

? // 然后，将“新HashMap”赋值给“旧HashMap”。

Entry[] newTable = new Entry[newCapacity];

         transfer(newTable);

         table = newTable;

         threshold = (int)(newCapacity * loadFactor);

     }

? // 将HashMap中的全部元素都添加到newTable中

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

             }

         }

     }

? // 将"m"的全部元素都添加到HashMap中

    public void putAll(Map<? extends K, ? extends V> m) {

? // 有效性判断

 int numKeysToBeAdded = m.size();

         if (numKeysToBeAdded == 0)

             return;

? // 计算容量是否足够，

? // 若“当前实际容量 < 需要的容量”，则将容量x2。

 if (numKeysToBeAdded > threshold) {

             int targetCapacity = (int)(numKeysToBeAdded / loadFactor + 1);

             if (targetCapacity > MAXIMUM_CAPACITY)

                 targetCapacity = MAXIMUM_CAPACITY;

             int newCapacity = table.length;

             while (newCapacity < targetCapacity)

                 newCapacity <<= 1;

             if (newCapacity > table.length)

                 resize(newCapacity);

         }

? // 通过迭代器，将“m”中的元素逐个添加到HashMap中。

 for (Iterator<? extends Map.Entry<? extends K, ? extends V>> i = m.entrySet().iterator(); i.hasNext(); ) {

             Map.Entry<? extends K, ? extends V> e = i.next();

             put(e.getKey(), e.getValue());

         }

     }

? // 删除“键为key”元素

public V remove(Object key) {

         Entry<K,V> e = removeEntryForKey(key);

         return (e == null ? null : e.value);

     }

? // 删除“键为key”的元素

    final Entry<K,V> removeEntryForKey(Object key) {

? // 获取哈希值。若key为null，则哈希值为0；否则调用hash()进行计算

int hash = (key == null) ? 0 : hash(key.hashCode());

         int i = indexFor(hash, table.length);

         Entry<K,V> prev = table[i];

         Entry<K,V> e = prev;

? // 删除链表中“键为key”的元素

? // 本质是“删除单向链表中的节点”

while (e != null) {

            Entry<K,V> next = e.next;

            Object k;

            if (e.hash == hash &&

                ((k = e.key) == key || (key != null && key.equals(k)))) {

                modCount++;

                size--;

                if (prev == e)

                    table[i] = next;

                else

                    prev.next = next;

                e.recordRemoval(this);

                return e;

            }

            prev = e;

            e = next;

        }

        return e;

    }

? // 删除“键值对”

     final Entry<K,V> removeMapping(Object o) {

         if (!(o instanceof Map.Entry))

             return null;

         Map.Entry<K,V> entry = (Map.Entry<K,V>) o;

         Object key = entry.getKey();

         int hash = (key == null) ? 0 : hash(key.hashCode());

         int i = indexFor(hash, table.length);

         Entry<K,V> prev = table[i];

         Entry<K,V> e = prev;

更多资深讲师相关课程资料、学习笔记请入群后向管理员免费获取，更有专业知识答疑解惑。入群即送价值499元在线课程一份。

QQ群号：560819979

敲门砖（验证信息）：多瑙河

Java中的HashMap

标签：text   哈希   dfa   .com   nta   log   有序   package   cap   

原文地址：http://blog.51cto.com/13477015/2176438