深入理解java集合框架之---------HashTable集合

HashTable是什么

HashTable是基于哈希表的Map接口的同步实现
HashTable中元素的key是唯一的，value值可重复
HashTable中元素的key和value不允许为null，如果遇到null，则返回NullPointerException
HashTable中的元素是无序的

public class Hashtable<K,V>

    extends Dictionary<K,V>

    implements Map<K,V>, Cloneable, java.io.Serializable{}

HashTable跟HashMap一样，同样是链表散列的数据结构，从源码中我们可以看出，Hashtable 继承于Dictionary类，实现了Map, Cloneable,Serializable接口

Dictionary类是任何可将键映射到相应值的类的抽象父类，每个键和值都是对象
Dictionary源码注释指出 Dictionary 这个类过时了，新的实现类应该实现Map接口

Hashtable成员变量

table：一个Entry[]数组类型，而Entry（在 HashMap 中有讲解过）就是一个单向链表。哈希表的”key-value键值对”都是存储在Entry数组中的
count：Hashtable的大小，它是Hashtable保存的键值对的数量
threshold：Hashtable的阈值，用于判断是否需要调整Hashtable的容量，threshold的值 = （容量 * 负载因子）
loadFactor：负载因子
modCount：用来实现fail-fast机制的

Hashtable构造方法

　　Hashtable 一共提供了 4 个构造方法

public Hashtable(int initialCapacity, float loadFactor)：用指定初始容量和指定加载因子构造一个新的空哈希表
public Hashtable(int initialCapacity)：用指定初始容量和默认的加载因子 (0.75) 构造一个新的空哈希表
public Hashtable()：默认构造函数，容量为 11，加载因子为 0.75
public Hashtable(Map< ? extends K, ? extends V> t)：构造一个与给定的Map具有相同映射关系的新哈希表

public synchronized V put(K key, V value) {

    //确保value不为null

    if (value == null) {

        throw new NullPointerException();

    }

    //确保key不在hashtable中

    //首先，通过hash方法计算key的哈希值，并计算得出index值，确定其在table[]中的位置

    //其次，迭代index索引位置的链表，如果该位置处的链表存在相同的key，则替换value，返回旧的value

    Entry tab[] = table;

    int hash = hash(key);

    int index = (hash & 0x7FFFFFFF) % tab.length;

    for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {

        if ((e.hash == hash) && e.key.equals(key)) {

            V old = e.value;

            e.value = value;

            return old;

        }

    }

    modCount++;

    if (count >= threshold) {

        //如果超过阀值，就进行rehash操作

        rehash();

        tab = table;

        hash = hash(key);

        index = (hash & 0x7FFFFFFF) % tab.length;

    }

    //将值插入，返回的为null

    Entry<K,V> e = tab[index];

    // 创建新的Entry节点，并将新的Entry插入Hashtable的index位置，并设置e为新的Entry的下一个元素

    tab[index] = new Entry<>(hash, key, value, e);

    count++;

    return null;

}

　　存储的流程如下：

判断value是否为空，为空则抛出异常
计算key的hash值，并根据hash值获得key在table数组中的位置index

　　　　如果table[index]元素为空，将元素插入到table[index]位置

如果table[index]元素不为空，则进行遍历链表，如果遇到相同的key，则新的value替代旧的value，并返回旧 value，否则将元素插入到链头，返回null

Hashtable的获取

public synchronized V get(Object key) {

    Entry tab[] = table;

    int hash = hash(key);

    int index = (hash & 0x7FFFFFFF) % tab.length;

    for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {

        if ((e.hash == hash) && e.key.equals(key)) {

            return e.value;

        }

    }

    return null;

}

　　获取的流程如下：

　　1、通过 hash()方法求得key的哈希值

　　2、根据hash值得到index索引

　　3、迭代链表，返回匹配的key的对应的value，找不到则返回null

Hashtable遍历方式

　　Hashtable有4种遍历方式：

//1、使用keys()

Enumeration<String> en1 = table.keys();

    while(en1.hasMoreElements()) {

    en1.nextElement();

}

//2、使用elements()

Enumeration<String> en2 = table.elements();

    while(en2.hasMoreElements()) {

    en2.nextElement();

}

//3、使用keySet()

Iterator<String> it1 = table.keySet().iterator();

    while(it1.hasNext()) {

    it1.next();

}

//4、使用entrySet()

Iterator<Entry<String, String>> it2 = table.entrySet().iterator();

    while(it2.hasNext()) {

    it2.next();

}

Hashtable与HashMap的区别

Hashtable	HashMap
方法是同步的	方法是非同步的
基于Dictionary类	基于AbstractMap，而AbstractMap基于Map接口的实现
key和value都不允许为null，遇到null，直接返回 NullPointerException	key和value都允许为null，遇到key为null的时候，调用putForNullKey方法进行处理，而对value没有处理
hash数组默认大小是11，扩充方式是old*2+1	hash数组的默认大小是16，而且一定是2的指数

多线程存在的问题

　　1、如果涉及到多线程同步时，建议采用HashTable

　　2、没有涉及到多线程同步时，建议采用HashMap

　　3、Collections 类中存在一个静态方法：synchronizedMap()，该方法创建了一个线程安全的 Map 对象，并把它作为一个封装的对象来返回

　　synchronizedMap()其实就是对Map的方法加层同步锁，从源码中可以看出

//Collections.synchronizedMap(Map<K, V>)

public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) {

     return new SynchronizedMap<K,V>(m);

}

private static class SynchronizedMap<K,V> implements Map<K,V>, Serializable {

    private static final long serialVersionUID = 1978198479659022715L;

    private final Map<K,V> m;     // Backing Map

    //同步锁

    final Object      mutex;        // Object on which to synchronize

    SynchronizedMap(Map<K,V> m) {

        if (m==null)

            throw new NullPointerException();

        this.m = m;

        //把this本身作为锁监视器, 这样任何线程访问他的方法都要获取该监视器.

        mutex = this;

    }

    SynchronizedMap(Map<K,V> m, Object mutex) {

        this.m = m;

        this.mutex = mutex;

    }

    public int size() {

        synchronized(mutex) {return m.size();}

    }

    //重写map的emty方法

    public boolean isEmpty() {

        synchronized(mutex) {return m.isEmpty();}

    }

    public boolean containsKey(Object key) {

        synchronized(mutex) {return m.containsKey(key);}

    }

    public boolean containsValue(Object value) {

        synchronized(mutex) {return m.containsValue(value);}

    }

    public V get(Object key) {

        synchronized(mutex) {return m.get(key);}

    }

    public V put(K key, V value) {

        synchronized(mutex) {return m.put(key, value);}

    }

    public V remove(Object key) {

        synchronized(mutex) {return m.remove(key);}

    }

    public void putAll(Map<? extends K, ? extends V> map) {

        synchronized(mutex) {m.putAll(map);}

    }

    public void clear() {

        synchronized(mutex) {m.clear();}

    }

    private transient Set<K> keySet = null;

    private transient Set<Map.Entry<K,V>> entrySet = null;

    private transient Collection<V> values = null;

    //重写keySet方法

    public Set<K> keySet() {

        synchronized(mutex) {

            if (keySet==null)

                //mutex传给SynchronizedSet, 这样对于set内部操作也需要获取锁.

                keySet = new SynchronizedSet<K>(m.keySet(), mutex);

            return keySet;

        }

    }

    public Set<Map.Entry<K,V>> entrySet() {

        synchronized(mutex) {

            if (entrySet==null)

                entrySet = new SynchronizedSet<Map.Entry<K,V>>(m.entrySet(), mutex);

            return entrySet;

        }

    }

    public Collection<V> values() {

        synchronized(mutex) {

            if (values==null)

                values = new SynchronizedCollection<V>(m.values(), mutex);

            return values;

        }

    }

    public boolean equals(Object o) {

        synchronized(mutex) {return m.equals(o);}

    }

    public int hashCode() {

        synchronized(mutex) {return m.hashCode();}

    }

    public String toString() {

        synchronized(mutex) {return m.toString();}

    }

    private void writeObject(ObjectOutputStream s) throws IOException {

        synchronized(mutex) {s.defaultWriteObject();}

    }

}