HastTable源码分析

 

概述

HashTable存储的键值对，它的key和value都不可以为Null。

为了能成功的存储健值对，做为key的对象必须实现hashCode()和equals()方法。

           HashTable实例有两个参数影响其性能，初始化容量和加载因子。初始容量是哈希表创建时的容量，注意HashTable的状态为Open。在发生“哈希冲突”的情况下，单个桶会存储多个条目，这些条目必须按顺序搜索。加载因子 是对哈希表在其容量自动增加之前可以达到多满的一个尺度。初始容量和加载因子这两个参数只是对该实现的提示。关于何时以及是否调用 rehash 方法的具体细节则依赖于该实现。

       通常，默认加载因子(.75)在时间和空间成本上寻求一种折衷。加载因子过高虽然减少了空间开销，但同时也增加了查找某个条目的时间（在大多数Hashtable 操作中，包括 get 和 put 操作，都反映了这一点）。

       初始容量主要控制空间消耗与执行 rehash 操作所需要的时间损耗之间的平衡。如果初始容量大于 Hashtable 所包含的最大条目数除以加载因子，则永远 不会发生 rehash 操作。但是，将初始容量设置太高可能会浪费空间。

         如果很多条目要存储在一个 Hashtable 中，那么与根据需要执行自动 rehashing 操作来增大表的容量的做法相比，使用足够大的初始容量创建哈希表或许可以更有效地插入条目。

          HashTable是线程安全的，但是如果在不需要同步的情况下使用HashMap，在高并发同步的情况下使用ConcurrentHashMap。

源码分析

全局变量

HashTable的内部数据载体是一个Entry数组

 private transient Entry<?,?>[] table;

HashTable中Entry对象的总数量

 private transient int count;

table是否要扩容的阈值，当Entry实体的数码超过了这个阈值，就需要对HashTable进行扩容。threshold=capcity*loadFactor

 private int threshold;

加载因子loadFactory。。threshold=capcity*loadFactor，loadFactory意味着HashTable的容量越小，但是桶中的条目数量更多，这意味着查询条目需要花更多的时间，典型的时间换空间。如果loadFactor越小，则意味着要创建的桶的容量更大，相应的查询桶中条目就可以花更少的时间，典型的空间换时间。

private float loadFactor;

Hashtable内部结构变化的次数。包括添加、删除和扩容，都会导致Hashtable内部结构变化

构造方法

四个构造函数

    /**
	 创建一个空的包含初始容量和指定加载因子的HashTable
     */
    public Hashtable(int initialCapacity, float loadFactor) {
		//初始容量不能为负数
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal Load: "+loadFactor);

        if (initialCapacity==0)
            initialCapacity = 1;
        this.loadFactor = loadFactor;
        table = new Entry<?,?>[initialCapacity];
        threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
    }

       /**
        参数为初始化容量
        */
    public Hashtable(int initialCapacity) {
        this(initialCapacity, 0.75f);
    }

    /**
        容量为11，默认加载因子0.75
    */
    public Hashtable() {
        this(11, 0.75f);
    }

    /**
    根据原有集合创建Hashtable
    /*
    public Hashtable(Map<? extends K, ? extends V> t) {
        this(Math.max(2*t.size(), 11), 0.75f);
        putAll(t);
    }

get()函数

获取key对应的Value，如果没有就返回为Null。

 public synchronized V get(Object key) {
        Entry<?,?> tab[] = table;
        //获取key对应的hash值
        int hash = key.hashCode();
		/**
        (hash & 0x7FFFFFFF)对桶的长度桶的容量tab.length取余，定位key具体位于哪个桶
		0x7FFFFFFF = 2的32次方-1=1111111111111111111111111111111
       */
        int index = (hash & 0x7FFFFFFF) % tab.length;
		//遍历桶下的链表，查询对应的key的对象
        for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
            if ((e.hash == hash) && e.key.equals(key)) {
                return (V)e.value;
            }
        }
        return null;
    }

containsKey()函数

containsKey()函数的实现基本与get()函数一致，都是通过查询key对应的具体的桶，然后遍历该桶的链表。

public synchronized boolean containsKey(Object key) {
        Entry<?,?> tab[] = table;
		//获取key对应的hash值
        int hash = key.hashCode();
		//(hash & 0x7FFFFFFF)对桶的长度取余，定位数据具体位于哪个桶
        int index = (hash & 0x7FFFFFFF) % tab.length;
		//遍历桶下的链表，查询对应的节点
        for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
            if ((e.hash == hash) && e.key.equals(key)) {
                return true;
            }
        }
        return false;
    }

 containsValue()函数
  根据值获取对应的keys，多个key对应一个value的情况，返回的key有多个。这个方法查询的代价比containsKey
  昂贵得多，因为要遍历所有的桶，同时要遍历桶的链表一一比较值。

 public boolean containsValue(Object value) {
        return contains(value);
    }

/**
    同步调用
*/ 
public synchronized boolean contains(Object value) {
        if (value