java HashMap的实现

 

 

今天很好奇，去看了HashMap的实现代码

 

    这个是插入代码：

 

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

 

    哈希函数： 

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

 

     key.hashCode()的实现

 

     Object.java中的实现

 

    public native int hashCode();

 

 

     HashMap.java中的实现

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

 

 

  反正这用到了hash函数（废话吗）！！

 

  中间插入下

 

  public HashMap() {

  this.loadFactor = DEFAULT_LOAD_FACTOR;
        threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
        table = new Entry[DEFAULT_INITIAL_CAPACITY];
        init();
    }

 

    hashmap是用数组来保存的  table = new Entry[DEFAULT_INITIAL_CAPACITY];

    最初是初始化16个存储位置。

    static final int DEFAULT_INITIAL_CAPACITY = 16;

 

 

    回来在看插入的代码

    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;  //如有有相同的key，那么就返回了
            }
        }

        modCount++;
        addEntry(hash, key, value, i);
        return null;
    }

 

 

  里面他做了一个for循环，查找是否有相同的key，如果有，那么就覆盖掉

 

   /**

     * Returns index for hash code h.
     */
    static int indexFor(int h, int length) {
        return h & (length-1);
    }

 

   返回一个索引

    addEntry(hash, key, value, i); //添加数据了，当另一个方法中去了

 

    /**

     * Adds a new entry with the specified key, value and hash code to
     * the specified bucket.  It is the responsibility of this
     * method to resize the table if appropriate.
     *
     * Subclass overrides this to alter the behavior of put method.
     */
    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);
    }

 

  添加一个实体对象了，还包含了一个方法，这个方法应该是

当数组中都满了，创建新的数组，然后复制原来的数到新的数组中去。不是平常的for循环复制了，要引入hash函数。

 

 

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

 

   有又新的方法

    /**

     * Transfers all entries from current table to newTable.

        转移当前的数组到新的数组，不是Copy，是转移
     */
    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);
            }
        }
    }

 

 

 他们的代码写的真好啊。。。。。。