serial:

serial:

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

Constructs an empty HashMap with the default initial capacity (16) and the default load factor (0.75).

 public HashMap(int initialCapacity) 
{
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

Constructs an empty HashMap with the specified initial capacity and the default load factor (0.75).

Parameters:

initialCapacity - the initial capacity.

Throws:

IllegalArgumentException - if the initial capacity is negative.

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

Constructs a new HashMap with the same mappings as the specified Map. The HashMap is created with default load factor (0.75) and an initial capacity sufficient to hold the mappings in the specified Map.

Parameters:

m - the map whose mappings are to be placed in this map

Throws:

NullPointerException - if the specified map is null

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

Constructs an empty HashMap with the specified initial capacity and load factor.

Parameters:

initialCapacity - the initial capacity

loadFactor - the load factor

Throws:

IllegalArgumentException - if the initial capacity is negative or the load factor is nonpositive

  void addEntry(int hash,
    K key,
    V value,
    int bucketIndex) 
{
        Entry< K,V > e = table[bucketIndex];
        table[bucketIndex] = new Entry<  >(hash, key, value, e);
        if (size++  >= threshold)
            resize(2 * table.length);
}

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.

 int capacity() 
{
 return table.length;
}

 public  void clear() 
{
        modCount++;
        Entry[] tab = table;
        for (int i = 0; i <  tab.length; i++)
            tab[i] = null;
        size = 0;
}

Removes all of the mappings from this map. The map will be empty after this call returns.

 public Object clone() 
{
        HashMap< K,V > result = null;
        try {
            result = (HashMap< K,V >)super.clone();
        } catch (CloneNotSupportedException e) {
            // assert false;
        }
        result.table = new Entry[table.length];
        result.entrySet = null;
        result.modCount = 0;
        result.size = 0;
        result.init();
        result.putAllForCreate(this);
        return result;
}

Returns a shallow copy of this HashMap instance: the keys and values themselves are not cloned.

 public boolean containsKey(Object key) 
{
        return getEntry(key) != null;
}

Returns true if this map contains a mapping for the specified key.

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

Returns true if this map maps one or more keys to the specified value.

  void createEntry(int hash,
    K key,
    V value,
    int bucketIndex) 
{
        Entry< K,V > e = table[bucketIndex];
        table[bucketIndex] = new Entry<  >(hash, key, value, e);
        size++;
}

Like addEntry except that this version is used when creating entries as part of Map construction or "pseudo-construction" (cloning, deserialization). This version needn't worry about resizing the table. Subclass overrides this to alter the behavior of HashMap(Map), clone, and readObject.

 public Set<K, V> entrySet() 
{
        return entrySet0();
}

Returns a Set view of the mappings contained in this map. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. If the map is modified while an iteration over the set is in progress (except through the iterator's own remove operation, or through the setValue operation on a map entry returned by the iterator) the results of the iteration are undefined. The set supports element removal, which removes the corresponding mapping from the map, via the Iterator.remove, Set.remove, removeAll, retainAll and clear operations. It does not support the add or addAll operations.

 public V get(Object key) 
{
        if (key == null)
            return getForNullKey();
        int hash = hash(key.hashCode());
        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;
}

Returns the value to which the specified key is mapped, or {@code null} if this map contains no mapping for the key.

More formally, if this map contains a mapping from a key {@code k} to a value {@code v} such that {@code (key==null ? k==null : key.equals(k))}, then this method returns {@code v}; otherwise it returns {@code null}. (There can be at most one such mapping.)

A return value of {@code null} does not necessarily indicate that the map contains no mapping for the key; it's also possible that the map explicitly maps the key to {@code null}. The containsKey operation may be used to distinguish these two cases.

 final Entry<K, V> getEntry(Object key) 
{
        int hash = (key == null) ? 0 : hash(key.hashCode());
        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;
}

Returns the entry associated with the specified key in the HashMap. Returns null if the HashMap contains no mapping for the key.

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

Applies a supplemental hash function to a given hashCode, which defends against poor quality hash functions. This is critical because HashMap uses power-of-two length hash tables, that otherwise encounter collisions for hashCodes that do not differ in lower bits. Note: Null keys always map to hash 0, thus index 0.

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

Returns index for hash code h.

  void init() 
{

}

Initialization hook for subclasses. This method is called in all constructors and pseudo-constructors (clone, readObject) after HashMap has been initialized but before any entries have been inserted. (In the absence of this method, readObject would require explicit knowledge of subclasses.)

 public boolean isEmpty() 
{
        return size == 0;
}

Returns true if this map contains no key-value mappings.

 public Set<K> keySet() 
{
        Set< K > ks = keySet;
        return (ks != null ? ks : (keySet = new KeySet()));
}

Returns a Set view of the keys contained in this map. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. If the map is modified while an iteration over the set is in progress (except through the iterator's own remove operation), the results of the iteration are undefined. The set supports element removal, which removes the corresponding mapping from the map, via the Iterator.remove, Set.remove, removeAll, retainAll, and clear operations. It does not support the add or addAll operations.

 float loadFactor() 
{
 return loadFactor;
}

 Iterator<K, V> newEntryIterator() 
{
        return new EntryIterator();
}

 Iterator<K> newKeyIterator() 
{
        return new KeyIterator();
}

 Iterator<V> newValueIterator() 
{
        return new ValueIterator();
}

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

Associates the specified value with the specified key in this map. If the map previously contained a mapping for the key, the old value is replaced.

 public  void putAll(Map<? extends K, ? extends V> m) 
{
        int numKeysToBeAdded = m.size();
        if (numKeysToBeAdded == 0)
            return;
        /*
         * Expand the map if the map if the number of mappings to be added
         * is greater than or equal to threshold.  This is conservative; the
         * obvious condition is (m.size() + size)  >= threshold, but this
         * condition could result in a map with twice the appropriate capacity,
         * if the keys to be added overlap with the keys already in this map.
         * By using the conservative calculation, we subject ourself
         * to at most one extra resize.
         */
        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());
}

Copies all of the mappings from the specified map to this map. These mappings will replace any mappings that this map had for any of the keys currently in the specified map.

 public V remove(Object key) 
{
        Entry< K,V > e = removeEntryForKey(key);
        return (e == null ? null : e.value);
}

Removes the mapping for the specified key from this map if present.

 final Entry<K, V> removeEntryForKey(Object key) 
{
        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;
        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;
}

Removes and returns the entry associated with the specified key in the HashMap. Returns null if the HashMap contains no mapping for this key.

 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;
        while (e != null) {
            Entry< K,V > next = e.next;
            if (e.hash == hash && e.equals(entry)) {
                modCount++;
                size--;
                if (prev == e)
                    table[i] = next;
                else
                    prev.next = next;
                e.recordRemoval(this);
                return e;
            }
            prev = e;
            e = next;
        }
        return e;
}

Special version of remove for EntrySet.

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

Rehashes the contents of this map into a new array with a larger capacity. This method is called automatically when the number of keys in this map reaches its threshold. If current capacity is MAXIMUM_CAPACITY, this method does not resize the map, but sets threshold to Integer.MAX_VALUE. This has the effect of preventing future calls.

 public int size() 
{
        return size;
}

Returns the number of key-value mappings in this map.

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

Transfers all entries from current table to newTable.

 public Collection<V> values() 
{
        Collection< V > vs = values;
        return (vs != null ? vs : (values = new Values()));
}

Returns a Collection view of the values contained in this map. The collection is backed by the map, so changes to the map are reflected in the collection, and vice-versa. If the map is modified while an iteration over the collection is in progress (except through the iterator's own remove operation), the results of the iteration are undefined. The collection supports element removal, which removes the corresponding mapping from the map, via the Iterator.remove, Collection.remove, removeAll, retainAll and clear operations. It does not support the add or addAll operations.