首页 > 代码库 > Java中HashSet，HashMap和HashTable的区别（转）

Java中HashSet，HashMap和HashTable的区别（转）

2024-11-24 15:21:02   202人阅读

HashMap、HashSet、HashTable之间的区别是Java程序员的一个常见面试题目，在此仅以此博客记录，并深入源代码进行分析：

在分析之前，先将其区别列于下面

1:HashSet底层采用的是HashMap进行实现的，但是没有key-value，只有HashMap的key set的视图，HashSet不容许重复的对象

2:Hashtable是基于Dictionary类的，而HashMap是基于Map接口的一个实现

3:Hashtable里默认的方法是同步的，而HashMap则是非同步的，因此Hashtable是多线程安全的

4:HashMap可以将空值作为一个表的条目的key或者value,HashMap中由于键不能重复，因此只有一条记录的Key可以是空值，而value可以有多个为空，但HashTable不允许null值(键与值均不行)

5:内存初始大小不同，HashTable初始大小是11，而HashMap初始大小是16

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

7:哈希值的计算方法不同，Hashtable直接使用的是对象的hashCode,而HashMap则是在对象的hashCode的基础上还进行了一些变化

源代码分析：

对于区别1，看下面的源码

//HashSet类的部份源代码  
public class HashSet<E>  
    extends AbstractSet<E>  
    implements Set<E>, Cloneable, java.io.Serializable  
{   //用于类的序列化，可以不用管它  
    static final long serialVersionUID = -5024744406713321676L;  
    //从这里可以看出HashSet类里面真的是采用HashMap来实现的  
    private transient HashMap<E,Object> map;  
  
    // Dummy value to associate with an Object in the backing Map  
    //这里是生成一个对象，生成这个对象的作用是将每一个键的值均关联于此对象，以满足HashMap的键值对  
    private static final Object PRESENT = new Object();  
  
    /** 
     * Constructs a new, empty set; the backing <tt>HashMap</tt> instance has 
     * default initial capacity (16) and load factor (0.75). 
     */  
    //这里是一个构造函数，开构生成一个HashMap对象，用来存放数据  
    public HashSet() {  
    map = new HashMap<E,Object>();  
    }

　　从上面的代码中得出的结论是HashSet的确是采用HashMap来实现的，而且每一个键都关键同一个Object类的对象，因此键所关联的值没有意义，真正有意义的是键。而HashMap里的键是不允许重复的，因此1也就很容易明白了。

对于区别2，继续看源代码如下

//从这里可以看得出Hashtable是继承于Dictionary,实现了Map接口  
public class Hashtable<K,V>  
    extends Dictionary<K,V>  
    implements Map<K,V>, Cloneable, java.io.Serializable {  
//这里可以看出的是HashMap是继承于AbstractMap类，实现了Map接口  
//因此与Hashtable继承的父类不同  
public class HashMap<K,V>  
    extends AbstractMap<K,V>  
    implements Map<K,V>, Cloneable, Serializable

　　区别3，找一个具有针对性的方法看看，这个方法就是put

//Hashtable里的向集体增加键值对的方法，从这里可以明显看到的是  
//采用了synchronized关键字，这个关键字的作用就是用于线程的同步操作  
//因此下面这个方法对于多线程来说是安全的，但这会影响效率     
public synchronized V put(K key, V value) {  
    // Make sure the value is not null  
    //如果值为空的，则会抛出异常  
    if (value =http://www.mamicode.com/= null) {  >

　　

区别4在上面的代码中，已经分析了，可以再细看一下

区别5内存初化大小不同，看看两者的源代码：

public Hashtable() {  
   //从这里可以看出，默认的初始化大小11，这里的11并不是11个字节，而是11个Entry,这个Entry是  
   //实现链表的关键结构  
   //这里的0.75代表的是装载因子  
this(11, 0.75f);  
 }  
//这里均是一些定义  
 public HashMap() {  
 //这个默认的装载因子也是0.75  
     this.loadFactor = DEFAULT_LOAD_FACTOR;  
 //默认的痤为0.75*16  
     threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);  
 //这里开始是默认的初始化大小，这里大小是16  
     table = new Entry[DEFAULT_INITIAL_CAPACITY];  
     init();  
 }

　　

从上面的代码中，可以看出的是两者的默认大小是不同的，一个是11，一个是16

区别6内存的扩容方式，看一看源代码也是很清楚的，其实区别是不大的，看到网上一哥们写的，说两者有区别，其实真正深入源码，区别真不大，一个是2*oldCapacity+1, 一个是2*oldCapacity,你说大吗:）

//Hashtable中调整内存的函数，这个函数没有synchronize关键字，但是protected呦  
protected void rehash() {  
    //获取原来的表大小  
    int oldCapacity = table.length;  
    Entry[] oldMap = table;  
  //设置新的大小为2*oldCapacity+1  
    int newCapacity = oldCapacity * 2 + 1;  
    //开设空间  
    Entry[] newMap = new Entry[newCapacity];  
  //以下就不用管了。。。  
    modCount++;  
    threshold = (int)(newCapacity * loadFactor);  
    table = newMap;  
  
    for (int i = oldCapacity ; i-- > 0 ;) {  
        for (Entry<K,V> old = oldMap[i] ; old != null ; ) {  
        Entry<K,V> e = old;  
        old = old.next;  
  
        int index = (e.hash & 0x7FFFFFFF) % newCapacity;  
        e.next = newMap[index];  
        newMap[index] = e;  
        }  
    }  
    }  
//HashMap中要简单的多了，看看就知道了  
void addEntry(int hash, K key, V value, int bucketIndex) {  
Entry<K,V> e = table[bucketIndex];  
       table[bucketIndex] = new Entry<K,V>(hash, key, value, e);  
       //如果超过了阀值  
       if (size++ >= threshold)  
       //就将大小设置为原来的2倍  
           resize(2 * table.length);  
   }

对于区别7的哈希值计算方法的不同，源码面前，同样是了无秘密

//Hashtable中可以看出的是直接采用关键字的hashcode作为哈希值  
int hash = key.hashCode();  
//然后进行模运算，求出所在哗然表的位置   
int index = (hash & 0x7FFFFFFF) % tab.length;  
//HashMap中的实现  
//这两行代码的意思是先计算hashcode,然后再求其在哈希表的相应位置        
int hash = hash(key.hashCode());  
int i = indexFor(hash, table.length);

上面的HashMap中可以看出关键在两个函数hash与indexFor 

源码如下:

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);  
}  
//求位于哈希表中的位置  
 static int indexFor(int h, int length) {  
     return h & (length-1);  
 }

出处链接：http://www.cnblogs.com/ckwblogs/p/6019419.html

Java中HashSet，HashMap和HashTable的区别（转）


联系
我们