해시 맵 에서 해시 표를 투석 하 다.

8654 단어 HashMap
##       

          :



                ,                 。        ,        ,         、     O(1)     。    ,            。    

         :



          ,         。           ,         。



            ,              ,            。  :           Demo。



        , Java          。  :



 -    Array

 -    LinkedList

 -    Queue,      LinkedList

 -       ProirityQueue

 -      Arrays.sort()

 -     TreeList,TreeList  Java    , commons-collections.jar ,     AVL 



      ,       HashMap 。



**  Java         , Java       ,             。     ,    。  ,           。**





##  HashMap

        ,                  。Java HashMap       。  

    ,    ,          。               ,    hash ,      ,               。  HashMap        ,         。             ,HashMap        。  

   ,      HasnMap   :

![HasnMap   ](http://dl.iteye.com/upload/attachment/364590/1c28849c-b67c-3461-b48f-54bd4b023b53.jpg)



  ,            ,     。  

    HashMap       ,          :

###   

```java

    public HashMap(int initialCapacity, float loadFactor) {

        if (initialCapacity < 0)

            throw new IllegalArgumentException("Illegal initial capacity: " +

                                               initialCapacity);

        if (initialCapacity > MAXIMUM_CAPACITY)

            initialCapacity = MAXIMUM_CAPACITY;

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

            throw new IllegalArgumentException("Illegal load factor: " +

                                               loadFactor);



        // Find a power of 2 >= initialCapacity

        int capacity = 1;

        while (capacity < initialCapacity)

            capacity <<= 1;



        this.loadFactor = loadFactor;

        threshold = (int)(capacity * loadFactor);

        table = new Entry[capacity];

        init();

    }

```

`capacity `          

`loadFactor`      (      ,         )  

`threshold`          (=capacity *loadFactor)  

            ,               。   `threshold`   ,     `resize(int newCapacity)`      。        ,     HashMap        ,    Entry   ,Entry HashMap     ,         。     ,             。  

             :

```java

        int capacity = 1;

        while (capacity < initialCapacity)

            capacity <<= 1;

```

        ,             ,    2   。     `initialCapacity`   9,          16.





###   

```java

    public HashMap(int initialCapacity) {

        this(initialCapacity, DEFAULT_LOAD_FACTOR);

    }

```

`DEFAULT_LOAD_FACTOR`    0.75,         。



###   

```java

    public HashMap() {

        this.loadFactor = DEFAULT_LOAD_FACTOR;

        threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);

        table = new Entry[DEFAULT_INITIAL_CAPACITY];

        init();

    }

```

          ,`DEFAULT_INITIAL_CAPACITY `   16。        ,           Entry。



###   

```java

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

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

                      DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);

        putAllForCreate(m);

    }

```

       ,       ,         `putAllForCreate(m);`   。



##     Entry  

      HashMap   ,        ,      。  Entry         ?           ,       :

```java

    static class Entry<K,V> implements Map.Entry<K,V> {

        final K key;

        V value;

        Entry<K,V> next;

        final int hash;

        ... ...

    }

```

      key,  value,       next  ,   hash 。



##HashMap put  

HashMap               ,              ,      ,    。  ,           ,  `put(K key, V value)`      :

```java

    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;

    }

```

           4 ,       。

  ,`key`     `putForNullKey(value);`  :

```java

    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;

    }

```

    ,`null` key               。           `null` key  ,      。  

           `null` key  ,    `addEntry(0, null, value, 0);`   `null` key          。

  `addEntry(0, null, value, 0);`  ,       `put(K key, V value)`    。





----------



             ,                 ,             。

   `put(K key, V value)`      hash ,    `hash(key.hashCode());`:

```java

    static int hash(int h) {

        // This function ensures that hashCodes that differ only by

        // constant multiples at each bit position have a bounded

        // number of collisions (approximately 8 at default load factor).

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

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

    }

```

  ,   `key.hashCode()`  ,   hashCode    hash。      hash ?     ,   0、1      。   `hashCode()`  ,      String :

```java

    public int hashCode() {

	int h = hash;

	if (h == 0) {

	    int off = offset;

	    char val[] = value;

	    int len = count;



            for (int i = 0; i < len; i++) {

                h = 31*h + val[off++];

            }

            hash = h;

        }

        return h;

    }

```

Java 31     hash,c++  33  ,             。





----------

`put(K key, V value)`     hash  ,   `indexFor(hash, table.length);`:

```java

    static int indexFor(int h, int length) {

        return h & (length-1);

    }

```

                    。





----------

  `put(K key, V value)`   `putForNullKey(value);`       ,           key,      value 。

     ,   `addEntry(hash, key, value, i);`  :



```java

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

    }

```

     ,          。  

            ,                  ,      key、value、         key hash 。

       ,           ,             ,      ,           2 , `resize(2 * table.length);`  :

```java

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

    }

```

`resize(int newCapacity) `       ,             ,   `transfer(newTable);`                    :

```java

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

            }

        }

    }

```

`transfer(Entry[] newTable) `       ,           ,   `put(K key, V value)`  。





----------

  ,HashMap     ,     `   `     。  

  ,                      。



##HashMap   

             ,HashMap       ,         ,       ,  CPU100%。       `Collections.synchronizedMap()` Map       。     HashTable。

        ,HashMap      ,         size   。   HashMap     ,                  。  , 50000  ,        HashMap        。  

        ,      :          Map key  ,          `hashCode()`  。




> * [Cmd](http://ghosertblog.github.io/mdeditor/ " Markdown ") * [1]: http://dl.iteye.com/upload/attachment/364590/1c28849c-b67c-3461-b48f-54bd4b023b53.jpg





좋은 웹페이지 즐겨찾기