자바 집합 시리즈 - Map 의 HashMap 소개 (8)

1. HashMap 의 프로필 (JDK 1.7.0 79 버 전) HashMap 은 해시 표 의 Map 을 바탕 으로 이 루어 진 것 입 니 다. 하나의 Key 는 하나의 Value 에 대응 하여 null 키 와 null 값 을 사용 할 수 있 습 니 다. 맵 의 순 서 를 보장 하지 않 습 니 다. 특히 이 순 서 는 영원히 변 하지 않 습 니 다!동기 화 된 것 도 아니 고영원히 변 하지 않 는 다 는 것 을 어떻게 이해 합 니까?
해시 표 의 항목 수가 로 딩 인자 와 현재 용량 의 곱 을 초과 할 때 해시 표 는 rehash 작업 (즉 내부 데이터 구 조 를 재 구축 하 는 것) 을 합 니 다. 이때 맵 순 서 는 혼 란 스 러 울 수 있 습 니 다!
HashMap 저장 요 소 는 해시 알고리즘 을 통 해 그 중의 요 소 를 각 '통' 사이 에 분산 시 키 는 것 입 니 다.
주: HashMap 은 비 동기 화 와 null 을 사용 할 수 있 는 것 을 제외 하고 HashTable 과 대체적으로 같 습 니 다.so, 뒤 에는 Hash Table 을 소개 하지 않 겠 습 니 다!
2. HashMap 의 상속 관계
  HashMap<K,V>
java.lang.Object
      java.util.AbstractMap<K,V>
          java.util.HashMap<K,V>
    :
    K -            
    V -        
        : 
    Serializable, Cloneable, Map<K,V> 
  • AbstractMap 추상 류 를 계승 하여 AbstractMap 은 Map 인터페이스 중의 일부 방법 을 실현 하여 중복 코드 를 감소 시 켰 습 니 다!
  • 맵, Cloneable, java. io. Serializable 인 터 페 이 스 를 실현 하 였 습 니 다!

  • 아 날로 그 관 계 는 전편 의 지도 소 개 를 참조한다.
    3. HashMap 의 API
    HashMap API (1) 구조 함수:
    HashMap() 
                           (16)         (0.75)    HashMap。 
    HashMap(int initialCapacity) 
                                 (0.75)    HashMap。 
    HashMap(int initialCapacity, float loadFactor) 
                                 HashMap。 
    HashMap(Map extends K,? extends V> m) 
                          Map      HashMap。 
    

    (2) 방법
     void clear() 
                           。 
     Object clone() 
                  HashMap        :         。 
     boolean containsKey(Object key) 
                               ,    trueboolean containsValue(Object value) 
                                ,    trueSet> entrySet() 
                             Set   。 
     V get(Object key) 
                        ;        ,            ,    null。 
     boolean isEmpty() 
                       -     ,    trueSet keySet() 
                           Set   。 
     V put(K key, V value) 
                            。 
     void putAll(Map extends K,? extends V> m) 
                                 ,                               。 
     V remove(Object key) 
                             (    )。 
     int size() 
                      -      。 
     Collection values() 
                          Collection   。 
    

    클래스 java. util. AbstractMap 에서 계승 하 는 방법 equals, hashCode, toString!
    4. 소스 코드
    
    public class HashMap<K,V>
        extends AbstractMap
        implements Map, Cloneable, Serializable
    {
    
        /**
         *       -    2  。
         */
        static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16        2^4 = 16
    
        /**
         *      ,         2          2^30(1<<30).
         *        ,      !
         */
        static final int MAXIMUM_CAPACITY = 1 << 30; //2^30
    
        /**
         *              (       0.75)
         */
        static final float DEFAULT_LOAD_FACTOR = 0.75f;
    
        /**
         * An empty table instance to share when the table is not inflated.
         *                  
         */
        static final Entry,?>[] EMPTY_TABLE = {};
    
        /**
         * The table, resized as necessary. Length MUST Always be a power of two.
         *   ,        。       2  。
         */
        transient Entry[] table = (Entry[]) EMPTY_TABLE;
    
        /**
         * The number of key-value mappings contained in this map.
         *  Map        (  )
         */
        transient int size;
    
        /**
         * The next size value at which to resize (capacity * load factor).
         *            (  *    )。
         * @serial
         */
        // HashMap   ,          HashMap   (threshold =   *    )   
        int threshold;
    
        /**
         * The load factor for the hash table.
         *            
         * @serial
         */
        final float loadFactor;
    
        /**
         *   HashMap       ,   HashMap           。
         *           ConcurrentModificationException   !
         */
        transient int modCount;
    
        /**
         * map       ,     ,           。 
         *                                  。
         *
         *             jdk.map.althashing.threshold   。
         *    1             , -1          。
         */
        static final int ALTERNATIVE_HASHING_THRESHOLD_DEFAULT = Integer.MAX_VALUE;
    
        /**
         * holds values which can't be initialized until after VM is booted.
         *     VM          。
         *           
         */
        private static class Holder {
    
            /**
             * Table capacity above which to switch to use alternative hashing.
             *                 。
             */
            static final int ALTERNATIVE_HASHING_THRESHOLD;
    
            static {
                String altThreshold = java.security.AccessController.doPrivileged(
                    new sun.security.action.GetPropertyAction(
                        "jdk.map.althashing.threshold"));
    
                int threshold;
                try {
                    threshold = (null != altThreshold)
                            ? Integer.parseInt(altThreshold)
                            : ALTERNATIVE_HASHING_THRESHOLD_DEFAULT;
    
                    // disable alternative hashing if -1
                    //   -1       
                    if (threshold == -1) {
                        threshold = Integer.MAX_VALUE;
                    }
    
                    if (threshold < 0) {
                        throw new IllegalArgumentException("value must be positive integer.");
                    }
                } catch(IllegalArgumentException failed) {
                    throw new Error("Illegal value for 'jdk.map.althashing.threshold'", failed);
                }
    
                ALTERNATIVE_HASHING_THRESHOLD = threshold;
            }
        }
    
        /**
         * A randomizing value associated with this instance that is applied to
         * hash code of keys to make hash collisions harder to find. If 0 then
         * alternative hashing is disabled.
         *             ,         ,           。
         *      0,       。
         */
        transient int hashSeed = 0;
    
        /**
         *    HashMap,              。
         */
        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);
    
            this.loadFactor = loadFactor; //       0.75
            threshold = initialCapacity; //         2^4 = 16
            init();
        }
    
        /**
         *                      (0.75)    HashMap。
         */
        public HashMap(int initialCapacity) {
            this(initialCapacity, DEFAULT_LOAD_FACTOR);
        }
    
        /**
         *                (16)         (0.75)    HashMap。
         */
        public HashMap() {
            this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
        }
    
        /**
         *             Map      HashMap。
         */
        public HashMap(Map extends K, ? extends V> m) {
            //   map       : (size / 0.75(    ) ) + 1
            this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
                          DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
            inflateTable(threshold);//   table
    
            putAllForCreate(m);
        }
    
        private static int roundUpToPowerOf2(int number) {
            // assert number >= 0 : "number must be non-negative";
            return number >= MAXIMUM_CAPACITY
                    ? MAXIMUM_CAPACITY
                    : (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;
        }
    
        /**
         * Inflates the table.
         */
        private void inflateTable(int toSize) {
            // Find a power of 2 >= toSize
            //    2   >= toSize
            int capacity = roundUpToPowerOf2(toSize);
    
            //     capacity * loadFactor, MAXIMUM_CAPACITY + 1     
            threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
            table = new Entry[capacity];//   table   
            initHashSeedAsNeeded(capacity);
        }
    
        // internal utilities
    
        /**
         *     
         */
        void init() {
        }
    
        /**
         * Initialize the hashing mask value. We defer initialization until we
         * really need it.
         *         。        ,         。
         */
        final boolean initHashSeedAsNeeded(int capacity) {
            boolean currentAltHashing = hashSeed != 0;
            boolean useAltHashing = sun.misc.VM.isBooted() &&
                    (capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);//      Holder.ALTERNATIVE_HASHING_THRESHOLD  
            boolean switching = currentAltHashing ^ useAltHashing;
            if (switching) {
                hashSeed = useAltHashing
                    ? sun.misc.Hashing.randomHashSeed(this)
                    : 0;
            }
            return switching;
        }
    
        /**
         *  hash    ,    hash  
         */
        final int hash(Object k) {
            int h = hashSeed;
            if (0 != h && k instanceof String) {
                return sun.misc.Hashing.stringHash32((String) k);
            }
    
            h ^= k.hashCode();
    
            // 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);
        }
    
        /**
         *  h        ,   &    ,         
         */
        static int indexFor(int h, int length) {
            // assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2";
            return h & (length-1);
        }
    
        /**
         *     
         */
        public int size() {
            return size;
        }
    
        /**
         *      
         */
        public boolean isEmpty() {
            return size == 0;
        }
    
        /**
         * get  key  value
         *
         *       null    null
         */
        public V get(Object key) {
            if (key == null) 
                return getForNullKey();
            Entry entry = getEntry(key);//  key Entry     value
    
            return null == entry ? null : entry.getValue();
        }
    
        /**
         *   key  null,  map       0 , 0   ,  null
         *    Entry    key == null,   Value 
         */
        private V getForNullKey() {
            if (size == 0) {
                return null;
            }
            for (Entry e = table[0]; e != null; e = e.next) {
                if (e.key == null)
                    return e.value;
            }
            return null;
        }
    
        /**
         *   Map       key
         *         true,    false
         */
        public boolean containsKey(Object key) {
            return getEntry(key) != null;
        }
    
        /**
         *    HashMap           。   HashMap       ,   null。
         */
        final Entry getEntry(Object key) {
            if (size == 0) {
                return null;
            }
    
            int hash = (key == null) ? 0 : hash(key);
            for (Entry 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;
        }
    
        /**
         *  map   “key-value”
         *
         */
        public V put(K key, V value) {
            if (table == EMPTY_TABLE) {
                inflateTable(threshold);
            }
            if (key == null)// key == null, value   table[0]
                return putForNullKey(value);
            int hash = hash(key);
            int i = indexFor(hash, table.length);
            for (Entry e = table[i]; e != null; e = e.next) {
                Object k;
            //     Entry      key,      key,      key   value    
                if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                    V oldValue = e.value;
                    e.value = value;
                    e.recordAccess(this);
                    return oldValue;
                }
            }
    
            modCount++;
            //      key  value ,      table[i] ! 
            addEntry(hash, key, value, i);
            return null;
        }
    
        /**
         *  “key null”      table[0]    
         */
        private V putForNullKey(V value) {
            for (Entry e = table[0]; e != null; e = e.next) {
                //       key  null,   ,table[0]    
                if (e.key == null) {
                    V oldValue = e.value;
                    e.value = value;
                    e.recordAccess(this);
                    return oldValue;
                }
            }
            modCount++;
            //      key null    ,      table[0] ! 
            addEntry(0, null, value, 0);
            return null;
        }
    
        /**
         *     。         。  HashMap   “    ”, put   。   
         */
        private void putForCreate(K key, V value) {
            int hash = null == key ? 0 : hash(key);
            int i = indexFor(hash, table.length);
    
    
            for (Entry 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;
                }
            }
    
            createEntry(hash, key, value, i);
        }
    
        private void putAllForCreate(Map extends K, ? extends V> m) {
            for (Map.Entry extends K, ? extends V> e : m.entrySet())
                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;
            }
    
            Entry[] newTable = new Entry[newCapacity];
            transfer(newTable, initHashSeedAsNeeded(newCapacity));
            table = newTable;
            threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
        }
    
        /**
         *              newTable。
         */
        void transfer(Entry[] newTable, boolean rehash) {
            int newCapacity = newTable.length;
            for (Entry e : table) {
                while(null != e) {
                    Entry next = e.next;
                    if (rehash) {
                        e.hash = null == e.key ? 0 : hash(e.key);
                    }
                    int i = indexFor(e.hash, newCapacity);
                    e.next = newTable[i];
                    newTable[i] = e;
                    e = next;
                }
            }
        }
    
        /**
         *  m         HashMap 
         */
        public void putAll(Map extends K, ? extends V> m) {
            int numKeysToBeAdded = m.size();
            if (numKeysToBeAdded == 0)//m    0 ,    
                return;
    
            if (table == EMPTY_TABLE) { //      
                inflateTable((int) Math.max(numKeysToBeAdded * loadFactor, threshold));
            }
    
            /*
             * m       ,  
             */
            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);//              
            }
            //    。         
            for (Map.Entry extends K, ? extends V> e : m.entrySet())
                put(e.getKey(), e.getValue());
        }
    
        /**
         *   “  key”      
         */
        public V remove(Object key) {
            Entry e = removeEntryForKey(key);
            return (e == null ? null : e.value);
        }
    
        /**
         *    “  key”   
         */
        final Entry removeEntryForKey(Object key) {
            if (size == 0) {
                return null;
            }
            int hash = (key == null) ? 0 : hash(key);//key==null ,hash==0
            int i = indexFor(hash, table.length);
            Entry prev = table[i];
            Entry e = prev;
    
            while (e != null) {
                Entry 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 removeMapping(Object o) {
            if (size == 0 || !(o instanceof Map.Entry))
    
        }
    
        /**
         *   HashMap
         */
        public void clear() {
            modCount++;
            Arrays.fill(table, null);//   Arrays.fill  
            size = 0; //  HashMap     0
        }
    
        /**
         *   HashMap       value
         *     value   true
         *     null   null    
         */
        public boolean containsValue(Object value) {
            if (value == null)
                return containsNullValue();
    
            Entry[] tab = table;
            for (int i = 0; i < tab.length ; i++)
                for (Entry e = tab[i] ; e != null ; e = e.next)
                    if (value.equals(e.value))
                        return true;
            return false;
        }
    
        /**
         *  null   containsValue       
         */
        private boolean containsNullValue() {
            Entry[] tab = table;
            for (int i = 0; i < tab.length ; i++)
                for (Entry e = tab[i] ; e != null ; e = e.next)
                    if (e.value == null)
                        return true;
            return false;
        }
    
        /**
         *    Cloneable,  clone   
         */
        public Object clone() {
            HashMap result = null;
            try {
                result = (HashMap)super.clone();
            } catch (CloneNotSupportedException e) {
                // assert false;
            }
            if (result.table != EMPTY_TABLE) {
                result.inflateTable(Math.min(
                    (int) Math.min(
                        size * Math.min(1 / loadFactor, 4.0f),
                        // we have limits...
                        HashMap.MAXIMUM_CAPACITY),
                   table.length));
            }
            result.entrySet = null;
            result.modCount = 0;
            result.size = 0;
            result.init();
            //   putAllForCreate()        HashMap 
            result.putAllForCreate(this);
    
            return result;
        }
    
        //Entry     。   Map.Entry,
        //   getKey(), getValue(), setValue(V value), equals(Object o), hashCode()    
        static class Entry<K,V> implements Map.Entry<K,V> {
            final K key;
            V value;
            Entry next;//     
            int hash;
    
            /**
             *   Entry
             *     "   (h)", " (k)", " (v)", "    (n)" 
             */
            Entry(int h, K k, V v, Entry n) {
                value = v;
                next = n;
                key = k;
                hash = h;
            }
    
            public final K getKey() {
                return key;
            }
    
            public final V getValue() {
                return value;
            }
    
            public final V setValue(V newValue) {
                V oldValue = value;
                value = newValue;
                return oldValue;
            }
    
            //  Entry  。  key value   
            public final boolean equals(Object o) {
                if (!(o instanceof Map.Entry))
                    return false;
                Map.Entry e = (Map.Entry)o;
                Object k1 = getKey();
                Object k2 = e.getKey();
                if (k1 == k2 || (k1 != null && k1.equals(k2))) {
                    Object v1 = getValue();
                    Object v2 = e.getValue();
                    if (v1 == v2 || (v1 != null && v1.equals(v2)))
                        return true;
                }
                return false;
            }
            //  hashcode
            public final int hashCode() {
                return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());
            }
    
            public final String toString() {
                return getKey() + "=" + getValue();
            }
    
    
            void recordAccess(HashMap m) {
            }
    
            void recordRemoval(HashMap m) {
            }
        }
    
        /**
         */
        void addEntry(int hash, K key, V value, int bucketIndex) {
            if ((size >= threshold) && (null != table[bucketIndex])) {
                resize(2 * table.length);//         2 。
                hash = (null != key) ? hash(key) : 0;
                bucketIndex = indexFor(hash, table.length);
            }
    
            createEntry(hash, key, value, bucketIndex);
        }
    
        /**
         * 
         */
        void createEntry(int hash, K key, V value, int bucketIndex) {
            Entry e = table[bucketIndex];
            table[bucketIndex] = new Entry<>(hash, key, value, e);
            size++;
        }
    
        //HashIterator HashMap           ,        。 
        private abstract class HashIterator<E> implements Iterator<E> {
            Entry next;        // next entry to return
            int expectedModCount;   // For fast-fail
            int index;              // current slot
            Entry current;     // current entry
    
            HashIterator() {
                expectedModCount = modCount;
                if (size > 0) { // advance to first entry
                    Entry[] t = table;
                    while (index < t.length && (next = t[index++]) == null)
                        ;
                }
            }
    
            public final boolean hasNext() {
                return next != null;
            }
    
            final Entry nextEntry() {
                if (modCount != expectedModCount)
                    throw new ConcurrentModificationException();
                Entry e = next;
                if (e == null)
                    throw new NoSuchElementException();
    
                if ((next = e.next) == null) {
                    Entry[] t = table;
                    while (index < t.length && (next = t[index++]) == null)
                        ;
                }
                current = e;
                return e;
            }
    
            public void remove() {
                if (current == null)
                    throw new IllegalStateException();
                if (modCount != expectedModCount)
                    throw new ConcurrentModificationException();
                Object k = current.key;
                current = null;
                HashMap.this.removeEntryForKey(k);
                expectedModCount = modCount;
            }
        }
    
        private final class ValueIterator extends HashIterator<V> {
            public V next() {
                return nextEntry().value;
            }
        }
    
        private final class KeyIterator extends HashIterator<K> {
            public K next() {
                return nextEntry().getKey();
            }
        }
    
        private final class EntryIterator extends HashIterator<Map.Entry<K,V>> {
            public Map.Entry next() {
                return nextEntry();
            }
        }
    
        // Subclass overrides these to alter behavior of views' iterator() method
        Iterator newKeyIterator()   {
            return new KeyIterator();
        }
        Iterator newValueIterator()   {
            return new ValueIterator();
        }
        Iterator> newEntryIterator()   {
            return new EntryIterator();
        }
    
    
        // Views
        //   HashMap    ,    set  
        private transient Set> entrySet = null;
    
        /**
         *   key   
         */
        public Set keySet() {
            Set ks = keySet;
            return (ks != null ? ks : (keySet = new KeySet()));
        }
    
        private final class KeySet extends AbstractSet<K> {
            public Iterator iterator() {
                return newKeyIterator();
            }
            public int size() {
                return size;
            }
            public boolean contains(Object o) {
                return containsKey(o);
            }
            public boolean remove(Object o) {
                return HashMap.this.removeEntryForKey(o) != null;
            }
            public void clear() {
                HashMap.this.clear();
            }
        }
    
        /**
         *   AbstractCollection
         */
        public Collection values() {
            Collection vs = values;
            return (vs != null ? vs : (values = new Values()));
        }
    
        private final class Values extends AbstractCollection<V> {
            public Iterator iterator() {
                return newValueIterator();
            }
            public int size() {
                return size;
            }
            public boolean contains(Object o) {
                return containsValue(o);
            }
            public void clear() {
                HashMap.this.clear();
            }
        }
    
        /**
         *  map      
         */
        public Set> entrySet() {
            return entrySet0();
        }
    
        private Set> entrySet0() {
            Set> es = entrySet;
            return es != null ? es : (entrySet = new EntrySet());
        }
    
        private final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
            public Iterator> iterator() {
                return newEntryIterator();
            }
            public boolean contains(Object o) {
                if (!(o instanceof Map.Entry))
                    return false;
                Map.Entry e = (Map.Entry) o;
                Entry candidate = getEntry(e.getKey());
                return candidate != null && candidate.equals(e);
            }
            public boolean remove(Object o) {
                return removeMapping(o) != null;
            }
            public int size() {
                return size;
            }
            public void clear() {
                HashMap.this.clear();
            }
        }
    
        /**
         *    
         */
        private void writeObject(java.io.ObjectOutputStream s)
            throws IOException
        {
            // Write out the threshold, loadfactor, and any hidden stuff
            s.defaultWriteObject();
    
            // Write out number of buckets
            if (table==EMPTY_TABLE) {
                s.writeInt(roundUpToPowerOf2(threshold));
            } else {
               s.writeInt(table.length);
            }
    
            // Write out size (number of Mappings)
            s.writeInt(size);
    
            // Write out keys and values (alternating)
            if (size > 0) {
                for(Map.Entry e : entrySet0()) {
                    s.writeObject(e.getKey());
                    s.writeObject(e.getValue());
                }
            }
        }
    
        private static final long serialVersionUID = 362498820763181265L;
    
        /**
         *     
         */
        private void readObject(java.io.ObjectInputStream s)
             throws IOException, ClassNotFoundException
        {
            // Read in the threshold (ignored), loadfactor, and any hidden stuff
            s.defaultReadObject();
            if (loadFactor <= 0 || Float.isNaN(loadFactor)) {
                throw new InvalidObjectException("Illegal load factor: " +
                                                   loadFactor);
            }
    
            // set other fields that need values
            table = (Entry[]) EMPTY_TABLE;
    
            // Read in number of buckets
            s.readInt(); // ignored.
    
            // Read number of mappings
            int mappings = s.readInt();
            if (mappings < 0)
                throw new InvalidObjectException("Illegal mappings count: " +
                                                   mappings);
    
            // capacity chosen by number of mappings and desired load (if >= 0.25)
            int capacity = (int) Math.min(
                        mappings * Math.min(1 / loadFactor, 4.0f),
                        // we have limits...
                        HashMap.MAXIMUM_CAPACITY);
    
            // allocate the bucket array;
            if (mappings > 0) {
                inflateTable(capacity);
            } else {
                threshold = capacity;
            }
    
            init();  // Give subclass a chance to do its thing.
    
            // Read the keys and values, and put the mappings in the HashMap
            for (int i = 0; i < mappings; i++) {
                K key = (K) s.readObject();
                V value = (V) s.readObject();
                putForCreate(key, value);
            }
        }
    
        //         HashSets   
        int   capacity()     { return table.length; }//   “HashMap    ”  
        float loadFactor()   { return loadFactor;   }//   “HashMap     ” 
    }
    

    5. 총화
    (1): HashMap 은 해시 표를 통 해 키 - value 의 키 값 을 저장 합 니 다. 키 마다 하나의 value 에 대응 하여 키 와 value 를 null 로 허용 합 니 다!hash (2): HashMap 의 인 스 턴 스 는 두 개의 매개 변수 가 그 성능 에 영향 을 줍 니 다. 초기 용량 과 로드 인자 입 니 다.용량 은 해시 표 의 통 수량 이 며, 초기 용량 은 해시 표 가 만 들 때 용량 일 뿐이다.HashMap 의 용량 이 부족 할 때 자동 으로 resize () 를 확장 할 수 있 지만 최대 용량 은 MAXIMUM 입 니 다.CAPACITY==2^30!
    (3): put 와 get 은 모두 null 과 비 null 로 나 누 어 판단 합 니 다!
    (4): resize 는 시간 이 많이 걸 리 는 작업 이기 때문에 우 리 는 HashMap 을 사용 할 때 HashMap 에서 요소 의 개 수 를 미리 예측 하 는 것 이 HashMap 의 성능 을 향상 시 키 는 데 도움 이 된다.(5): hash 값 과 색인 값 을 구 하 는 방법 입 니 다. 이 두 가지 방법 은 바로 HashMap 디자인 의 가장 핵심 적 인 부분 입 니 다. 이들 의 결합 은 해시 표 의 요 소 를 최대한 고 르 게 배열 할 수 있 습 니 다.
    참조:
    HashMap    h&(length-1)        ,          ,       ,   HashMap Hashtable     。  
           ,                  2     。    
          ,length 2       ,h&(length-1)     length  ,           ,        ;  
          ,length 2       ,   ,  length-11,      h&(length-1)        01(    h  ),           ,      ,  
                     ,   lengthlength-10,  h&(length-1)        0,      ,    hash                  ,           ,
          ,length 2     ,      hash          ,                 。

    주: 대상 을 hashmap 의 key 로 저장 하려 면 무엇 을 주의해 야 합 니까?
  • 1. 이 대상 이 가 변 대상 인지 주의해 야 한다.http://www.importnew.com/13384.html
  • 2. hashcode 방법 을 다시 써 야 합 니 다. HashMap 의 소스 코드 에서 HashCode 가 같은 지 비교 하 는 동시에 인용 이 같 거나 equals 가 같은 지 만족 시 켜 야 하기 때 문 입 니 다.

  • 참고 글: HashMap 소스 코드 분석:http://blog.csdn.net/ns_code/article/details/36034955
    첨부:
    JDK 8 에서 HashMap 의 밑바닥 실현:http://ericchunli.iteye.com/blog/2356721
    자바 집합 시리즈 - 자바 집합 개술 (1) 자바 집합 시리즈 - List 집합 의 ArrayList 소개 (2) 자바 집합 시리즈 - List 집합 의 LinkedList 소개 (3) 자바 집합 시리즈 - List 집합 의 Vector 소개 (4) 자바 집합 시리즈 - List 집합 의 Stack 소개 (5) 자바 집합 시리즈 - List 집합 총화 (6)자바 집합 시리즈 - 맵 소개 (7) 자바 집합 시리즈 - 맵 의 HashMap 소개 (8) 자바 집합 시리즈 - 맵 의 TreeMap 소개 (9) 자바 집합 시리즈 - Set 의 HashSet 과 TreeSet 소개 (10)
    멋 지고 (아름 답 고), 예지 (총명 하고), 나 처럼 간단 하고 착 한 당신 이 이 박문 에 문제 가 있 는 것 을 보 았 다 면, 나 는 당신 이 나 를 성장 시 켰 다 는 비판 을 겸허 하 게 받 아 들 였 습 니 다. 읽 어 주 셔 서 감사합니다!오늘 즐 거 운 시간 보 내세 요!
    나의 csdn 블 로 그 를 방문 한 것 을 환영 합 니 다. 우 리 는 함께 성장 합 니 다!
    "뭘 하 든 버 티 면 달라 져! 길에서 비굴 하지 도 거만 하지 도 않 아!"
    블 로그 첫 페이지:http://blog.csdn.net/u010648555

    좋은 웹페이지 즐겨찾기