总结学习HashMap和HashTable

// get
public V get(Object key) {
    HashMap.Node e;
    return (e = this.getNode(hash(key), key)) == null ? null : e.value;
}

...
...


// put
public V put(K key, V value) {
    return this.putVal(hash(key), key, value, false, true);
}

...
...


// remove
public V remove(Object key) {
    HashMap.Node e;
    return (e = this.removeNode(hash(key), key, (Object)null, false, true)) == null ? 
    		null : e.value;
}

...
...

// get
public synchronized V get(Object key) {
    Hashtable.Entry<?, ?>[] tab = this.table;
    int hash = key.hashCode();
    int index = (hash & 2147483647) % tab.length;

    for(Hashtable.Entry e = tab[index]; e != null; e = e.next) {
        if (e.hash == hash && e.key.equals(key)) {
            return e.value;
        }
    }

    return null;
}

...
...


// put
public synchronized V put(K key, V value) {
    if (value == null) {
        throw new NullPointerException();
    } else {
        Hashtable.Entry<?, ?>[] tab = this.table;
        int hash = key.hashCode();
        int index = (hash & 2147483647) % tab.length;

        for(Hashtable.Entry entry = tab[index]; entry != null; entry = entry.next) {
            if (entry.hash == hash && entry.key.equals(key)) {
                V old = entry.value;
                entry.value = value;
                return old;
            }
        }

        this.addEntry(hash, key, value, index);
        return null;
    }
}

...
...


// remove
public synchronized V remove(Object key) {
    Hashtable.Entry<?, ?>[] tab = this.table;
    int hash = key.hashCode();
    int index = (hash & 2147483647) % tab.length;
    Hashtable.Entry<K, V> e = tab[index];

    for(Hashtable.Entry prev = null; e != null; e = e.next) {
        if (e.hash == hash && e.key.equals(key)) {
            if (prev != null) {
                prev.next = e.next;
            } else {
                tab[index] = e.next;
            }

            ++this.modCount;
            --this.count;
            V oldValue = e.value;
            e.value = null;
            return oldValue;
        }

        prev = e;
    }

    return null;
}

...
...

public class App {

    private static AtomicInteger atomicInteger = new AtomicInteger();

    public static void main(String[] args) throws InterruptedException {
        Map<Integer, Integer> m = new HashMap<>();
        Map<Integer, Integer> map = Collections.synchronizedMap(m);
        //创建线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(10);
        for(int i = 0 ; i < 10000 ; i++) {
            //调用execute()方法创建线程
            threadPool.execute(() -> map.put(atomicInteger.incrementAndGet(), 
            		(int)(Math.random()*100))
        	);
        }
        // 关闭线程池
        threadPool.shutdown();
        threadPool.awaitTermination(1000, TimeUnit.SECONDS);
        System.out.println(map.size());
    }
}

/**
 * Maps the specified <code>key</code> to the specified
 * <code>value</code> in this hashtable. Neither the key nor the
 * value can be <code>null</code>. <p>
 *
 * The value can be retrieved by calling the <code>get</code> method
 * with a key that is equal to the original key.
 *
 * @param      key     the hashtable key
 * @param      value   the value
 * @return     the previous value of the specified key in this hashtable,
 *             or <code>null</code> if it did not have one
 * @exception  NullPointerException  if the key or value is
 *               <code>null</code>
 * @see     Object#equals(Object)
 * @see     #get(Object)
 */
public synchronized V put(K key, V value) {
    // Make sure the value is not null
    if (value == null) {
        throw new NullPointerException();
    }

    // Makes sure the key is not already in the hashtable.
    Entry<?,?> tab[] = table;
    int hash = key.hashCode();
    int index = (hash & 0x7FFFFFFF) % tab.length;
    @SuppressWarnings("unchecked")
    Entry<K,V> entry = (Entry<K,V>)tab[index];
    for(; entry != null ; entry = entry.next) {
        if ((entry.hash == hash) && entry.key.equals(key)) {
            V old = entry.value;
            entry.value = value;
            return old;
        }
    }

    addEntry(hash, key, value, index);
    return null;
}

// iterators

abstract class HashIterator {
    Node<K,V> next;        // next entry to return
    Node<K,V> current;     // current entry
    int expectedModCount;  // for fast-fail
    int index;             // current slot

    HashIterator() {
        expectedModCount = modCount;
        Node<K,V>[] t = table;
        current = next = null;
        index = 0;
        if (t != null && size > 0) { // advance to first entry
            do {} while (index < t.length && (next = t[index++]) == null);
        }
    }

    public final boolean hasNext() {
        return next != null;
    }

    final Node<K,V> nextNode() {
        Node<K,V>[] t;
        Node<K,V> e = next;
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
        if (e == null)
            throw new NoSuchElementException();
        if ((next = (current = e).next) == null && (t = table) != null) {
            do {} while (index < t.length && (next = t[index++]) == null);
        }
        return e;
    }

    public final void remove() {
        Node<K,V> p = current;
        if (p == null)
            throw new IllegalStateException();
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
        current = null;
        K key = p.key;
        removeNode(hash(key), key, null, false, false);
        expectedModCount = modCount;
    }
}