源码剖析——HashMap、HashTable、HashSet的区别

1、HashMap、HashTable 实际上是数组和链表的结合

2、HashMap、HashTable 不允许添加相同key，若添加了已经存在的key，则会以最新的替代原来的，并返回上次的value
3、HashMap允许添加key或value为null，HashTable不允许添加key或value为null
4、HashMap线程不安全，性能高，HashTable线程安全，方法中加synchronized关键字，性能较差
5、HashSet内部是基于HashMap实现的，也就是hashMap的key形成了HashSet,value为

    private static final Object PRESENT = new Object();

HashMap元素key相同的话，不会另外添加到HashMap中，而是更新相同的key的value，这就保证了Hashset不能存储相同的数据。

    public boolean add(E e) {        return map.put(e, PRESENT)==null;    }

6、内存扩容时采取的方式也不同，Hashtable采用的是2*old+1,而HashMap是2*old，HashSet是2*old。


7、剖析CRUD：

HashMap&&HashTable：

Create（增加）:

    public V put(K key, V value) {        if (table == EMPTY_TABLE) {            inflateTable(threshold);        }        if (key == null)            return putForNullKey(value);        int hash = hash(key);        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;    }

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

    void addEntry(int hash, K key, V value, int bucketIndex) {        if ((size >= threshold) && (null != table[bucketIndex])) {            resize(2 * table.length);            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<K,V> e = table[bucketIndex];        table[bucketIndex] = new Entry<>(hash, key, value, e);        size++;    }

        Entry(int h, K k, V v, Entry<K,V> n) {            value = v;            next = n;            key = k;            hash = h;        }

思路：1、首先通过key计算hash值 然后得到在table[]中的位置
2、然后根据put顺序，新增的放在链头，最先的放在链尾，从而形成hashmap结构为横向为数组table[]，然后纵向为相同keyhash值的Entry<K,V>链表的形式。

Retrieve（查询）:

    public V get(Object key) {        if (key == null)            return getForNullKey();        Entry<K,V> entry = getEntry(key);        return null == entry ? null : entry.getValue();    }

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

思路：1、首先清楚结构是横向数组+纵向链表，首先利用key算出hash得到在数组中的索引值
2、得到索引值，然后e = e.next遍历链表，key相等则返回value
思考：首先初始化一个hashMap然后先添加数据，直到table.length发生改变，那么再get，那么indexFor(hash, table.length)的值不是和table.length 没发生改变前不一样吗，那么还能取出正确的数据吗？
多虑了，首先hashMap每次put，当里面的存储的数据大于table的容量的时候，就会自动将table的扩大2倍，看如下源码

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

在扩容的时候会重新生成一个空的数组，然后将老的数组中的数组重新按照新的table生成hash值，这样hashMap中数据的次序也会发生改变，但是这样就会保证put和get的hash都是同步的。

    void transfer(Entry[] newTable, boolean rehash) {        int newCapacity = newTable.length;        for (Entry<K,V> e : table) {            while(null != e) {                Entry<K,V> 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;            }        }    }

Update（修改）: （无）

Delete（删除）:

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

   final Entry<K,V> removeEntryForKey(Object key) {        if (size == 0) {            return null;        }        int hash = (key == null) ? 0 : hash(key);        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;    }

思路：先找到然后和链表remove方法差不多，修改prev、next

看一下：HashMap、HashTable、HashSet都实现了java.io.Serializable这个序列化的接口，并且里面存储数据的数组都用transient关键字，然后利用writeObject和readObject两个方法来实现序列化操作时写入、读出。