HashMap和Hashtable的区别

最新推荐文章于 2024-09-08 10:40:56 发布
最新推荐文章于 2024-09-08 10:40:56 发布
阅读量857 收藏
点赞数
分类专栏： JavaSE 文章标签： java 源码 hashtable hashmap
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Wang_1997/article/details/52336050
版权

加载因子

先来了解个概念：加载因子是表示Hsah表中元素的填满的程度.若:加载因子越大,填满的元素越多,好处是,空间利用率高了,但冲突的机会加大了.反之,加载因子越小,填满的元素越少,好处是:冲突的机会减小了,但:空间浪费多了. 冲突的机会越大,则查找的成本越高.反之,查找的成本越小.因而,查找时间就越小.
简单的说：由于HashMap扩容根据 加载因子*容量 决定,当map中元素个数 > 加载因子*容量时，才会扩容，所以加载因子越大，当然元素存的越多，但是冲突也就越多了。

源码(JDK1.8)简单分析：

HashMap的部分构造函数与成员变量:
 
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {
	//默认初始容量
	static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
	//默认加载因子
	static final float DEFAULT_LOAD_FACTOR = 0.75f;
	//默认最大容量
	static final int MAXIMUM_CAPACITY = 1 << 30;
	//当实际数据大小超过threshold时，HashMap会将容量扩容，threshold＝容量*加载因子
	int threshold;
	//加载因子
	final float loadFactor;
	
    public HashMap(int initialCapacity, float loadFactor) {//传入默认初始大小和加载因子
	    if (initialCapacity < 0)
	        throw new IllegalArgumentException("Illegal initial capacity: " +
	                                           initialCapacity);
	    if (initialCapacity > MAXIMUM_CAPACITY)
	        initialCapacity = MAXIMUM_CAPACITY;
	    if (loadFactor <= 0 || Float.isNaN(loadFactor))
	        throw new IllegalArgumentException("Illegal load factor: " +
	                                           loadFactor);
	    this.loadFactor = loadFactor;
	    this.threshold = tableSizeFor(initialCapacity);
    }
    public HashMap(int initialCapacity) {//传入默认初始容量大小
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }
    public HashMap() {//无参构造
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }
}

HashMap的扩容： 
    
	//重新设置table大小
    final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        if (oldCap > 0) {//当表不为空时
            if (oldCap >= MAXIMUM_CAPACITY) {//判断是否到达最大容量
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)//旧容量进行扩容一倍
                newThr = oldThr << 1; //  threshold也进行1倍扩容
        }
        else if (oldThr > 0) // 表为空,threshold不为空情况   initial capacity was placed in threshold
            newCap = oldThr;
        else {//都为空情况使用默认               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY; //16
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); //12
        }
        if (newThr == 0) {//针对上面的第二种情况
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;//对threshold进行重新赋值
        @SuppressWarnings({"rawtypes","unchecked"})
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];//创建新的哈希表
        table = newTab;//将新的地址赋值给table
        if (oldTab != null) {//如果旧表不为空，将对其复制到新表中
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    if (e.next == null)//表中只有一个Entry情况
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)//TreeNode没研究
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else { // preserve order//有多个Entry，即有链
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
                            next = e.next;
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }


Hashtable的部分构造函数与成员变量:
 
public class Hashtable<K,V>
extends Dictionary<K,V>
implements Map<K,V>, Cloneable, java.io.Serializable {
	//当实际数据大小超过threshold时，进行扩容，threshold＝容量*加载因子
	private int threshold;
	//加载因子
	private float loadFactor;
    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) {//传入初始容量大小的构造，加载因子为0.75
        this(initialCapacity, 0.75f);
    }
    public Hashtable() {//无参构造，默认初始容量为11,加载因子为0.75
        this(11, 0.75f);
    }
}

Hashtable的扩容: 

    protected void rehash() {
        int oldCapacity = table.length;
        Entry<?,?>[] oldMap = table;

        // overflow-conscious code
        int newCapacity = (oldCapacity << 1) + 1;  //扩容的大小为原来的两倍 + 1
        if (newCapacity - MAX_ARRAY_SIZE > 0) {//判断是否超过最大size
            if (oldCapacity == MAX_ARRAY_SIZE)
                // Keep running with MAX_ARRAY_SIZE buckets
                return;
            newCapacity = MAX_ARRAY_SIZE;
        }
        Entry<?,?>[] newMap = new Entry<?,?>[newCapacity];

        modCount++;
        threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);//重新计算 threshold
        table = newMap;
        //将旧表中数据copy到新表中
        for (int i = oldCapacity ; i-- > 0 ;) {
            for (Entry<K,V> old = (Entry<K,V>)oldMap[i] ; old != null ; ) {
                Entry<K,V> e = old;
                old = old.next;

                int index = (e.hash & 0x7FFFFFFF) % newCapacity;
                e.next = (Entry<K,V>)newMap[index];
                newMap[index] = e;
            }
        }
    }


Hashtable和HashMap的比较

以下表格内容参考自：http://www.cnblogs.com/carbs/archive/2012/07/04/2576995.html

 
Hashtable
HashMap
并发操作
使用同步机制，
实际应用程序中，仅仅是Hashtable本身的同步并不能保证程序在并发操作下的正确性，需要高层次的并发保护。
下面的代码试图在key所对应的value值等于x的情况下修改value为x+1
{
 value = hashTable.get(key);
   if(value.intValue()== x){
hashTable.put(key,      new Integer(value.intValue()+1));
   }
}
如2个线程同时执行以上代码，可能放入不是x+1，而是x+2.
没有同步机制，需要使用者自己进行并发访问控制
数据遍历的方式
Iterator 和 Enumeration
Iterator
是否支持fast-fail
用Iterator遍历，支持fast-fail
用Enumeration不支持fast-fail.
支持fast-fail
是否接受值为null的Key 或Value？
不接受
接受
根据hash值计算数组下标的算法
当数组长度较小，并且Key的hash值低位数值分散不均匀时，不同的hash值计算得到相同下标值的几率较高
 
hash = key.hashCode();
index=(hash&0x7FFFFFFF) % tab.length;
优于hashtable，通过对Key的hash做移位运算和位的与运算，使其能更广泛地分散到数组的不同位置
 
hash = hash (k);
index = indexFor(hash, table.length);
 
static int hash(Object x) {
 int h = x.hashCode();
h += ~(h << 9);
 h ^= (h >>> 14);
  h += (h << 4);
 h ^= (h >>> 10);
 return h;
}
static int indexFor(int h, int length) {
return h & (length-1);
}
 
Entry数组的长度
Ø         缺省初始长度为11，
Ø         初始化时可以指定initial capacity
Ø         缺省初始长度为16，
Ø         长度始终保持2的n次方
Ø         初始化时可以指定initial capacity，若不是2的次方，HashMap将选取第一个大于initial capacity 的2n次方值作为其初始长度
LoadFactor负荷因子
0.75
负荷超过（loadFactor * 数组长度）时，内部数据的调整方式
扩展数组：2*原数组长度+1
扩展数组： 原数组长度 * 2
两者都会重新根据Key的hash值计算其在数组中的新位置，重新放置。算法相似，时间、空间效率相同
 
一般情况下，HashMap能够比Hashtable工作的更好、更快，主要得益于它的散列算法，以及没有同步。应用程序一般在更高的层面上实 现了保护机制，而不是依赖于这些底层数据结构的同步，因此，HashMap能够在大多应用中满足需要。推荐使用HashMap，如果需要同步，可以使用同 步工具类将其转换成支持同步的HashMap。

主要总结

1.Hashtable是JDK1.0版本出现的,是线程安全的,效率低,HashMap是JDK1.2版本出现的,是线程不安全的,效率高

2.Hashtable不可以存储null键和null值,HashMap可以存储null键和null值


嘻嘻兮
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HashMap 和 Hashtable 的区别
seowen的开发 小本子
03-27 218
1、HashMap 和 Hashtable 都实现了 Map、Cloneable（可复制）、Serializable（可序列化）这三个接口。 2、HashMap 继承AbstractMap， Hashtable 继承Dictionary。 3、HashMap 在只有一个线程访问的情况下，效率高于Hashtable。 4、先有Hashtable （始于初始版本，作者:Json Bloch）,后...
HashMap和Hashtable的详细区别
热门推荐
qq_35181209的博客
07-05 4万+
HashMap和Hashtable的区别 两者最主要的区别在于Hashtable是线程安全，而HashMap则非线程安全。Hashtable的实现方法里面都添加了synchronized关键字来确保线程同步，因此相对而言HashMap性能会高一些，我们平时使用时若无特殊需求建议使用HashMap，在多线程环境下若使用HashMap需要使用Collections.synchronizedMap()方法
hashmap和hashtable的区别
若圆之意
12-04 490
[java] view plaincopy public class Hashtable       extends Dictionary       implements Map, Cloneable, java.io.Serializable   [java] view plaincopy public clas
hashmap和hashtable区别
Alpha_Paser的博客
04-28 637
1、继承不同。 public class Hashtable extends Dictionary implements Map public class HashMap extends AbstractMap implements Map 2 产生时间不同 Hashtable是java一开始发布时就提供的键值映射的数据结构，而HashMap产生于JDK1.2。虽然Hashtable比HashMa...
HashMap 和 HashTable 区别
akunshouyoudou的博客
07-11 141
转载：https://www.jianshu.com/p/5c34133ed372 rawer关注 0.12017.01.13 15:15*字数 293阅读 5202评论 1喜欢 3 HashMap 不是线程安全的 HashMap 是 map 接口的实现类，是将键映射到值的对象，其中键和值都是对象，并且不能包含重复键，但可以包含重复值。HashMap 允许 null key 和...
Hashmap和hashtable区别
Michaeles的博客
10-17 1923
1.相同点： （1）都是map的实现类，都是键值对集合； （2）里边的元素都是无序的，跟添加顺序无关； 2.不同点： （1）HashMap允许有一个null键和多个null值； （2）HashMap不是线程安全的，HashTable是线程安全的。...
HashMap 和 Hashtable的区别
09-01
HashMap 和 Hashtable 是 Java 集合框架中两个重要的 Map 实现，它们虽然都是用来存储键值对的数据结构，但在很多方面存在显著的区别。以下将详细分析它们的主要差异、工作原理和适用场景。 1. **线程安全性** - `...
有关hashMap跟hashTable的区别，说法正确的是？
12-21
在Java编程语言中，`HashMap`和`HashTable`都是实现`Map`接口的数据结构，用于存储键值对。它们在很多方面有所不同，这些差异主要体现在线程安全性、迭代器类型、null值支持以及哈希码处理等方面。以下是关于两者...
java面试题——详解HashMap和Hashtable 的区别
09-01
HashMap 和 Hashtable 是 Java 中两种常用的哈希表数据结构，它们都是用来存储键值对的数据结构，但它们在设计和实现上有显著的区别。以下是对这两者差异的详细解释： 1. **线程安全性**： - `Hashtable` 是线程...
HashMap和HashTable区别共2页.pdf.zi
11-21
在Java编程语言中，`HashMap`和`HashTable`是两种常用的集合类，它们都是用于存储键值对的数据结构。这两个类都实现了`Map`接口，但它们之间存在一些显著的区别，这些差异主要体现在线程安全性、null值处理、迭代...
HashMap 和 Hashtable 的区别?
一刀的博客
10-12 135
1. 线程是否安全： HashMap 是非线程安全的，HashTable 是线程安全的；HashTable 内部的方法基本都经过synchronized 修饰。（如果你要保证线程安全的话就使用 ConcurrentHashMap 吧！）； 2. 效率： 因为线程安全的问题，HashMap 要比 HashTable 效率高一点。另外，HashTable 基本被淘汰，不要在代码中使用它； 3. 对...
HashMap和HashTable区别
weixin_58724261的博客
06-07 1万+
Hashtable的查找、插入和删除操作平均时间复杂度为O(1)，但是在极端情况下，因为哈希冲突的原因，可能会退化到O(n)。HashMap中可以存储null值和null键，但是要注意，当使用null作为键时，由于无法调用null的hashCode()方法，因此只能将其放在哈希表的第一个位置，它们是无序的。另外，由于HashMap采用链表和红黑树的数据结构，可以更好地处理哈希冲突，因此HashMap的查找、插入和删除操作都是常数时间O(1)。线程安全性指在多线程环境下，数据的并发访问是否会产生问题。
讲述HashMap和HashTable的区别
我真的不会java的博客
08-22 415
HashMap和HashTable的区别 哈希表由数组+链表组成，一个长度为16的数组中，每个元素存储的是一个链表的头结点。而HashMap和Hashtable就是哈希表结构。 数组的存储空间是连续的，占用内存严重，故空间复杂度很大，但是查找时间复杂度较小。数组的特点：寻址容易，插入和删除困难。 链表的存储空间是离散的，占用内存比较宽松，故空间复杂度较小，但查找时间复杂度较大。链表的特点：寻址困难，插入和删除容易。 继承类不同： 1.HashMap继承AbstractMap 2.Hashtable继承Dic
spring事务详细讲解-深入浅出
最新发布
小电玩
09-08 460
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
HashMap 和 Hashtable 区别
03-10
HashMap 和 Hashtable 都是用于存储键值对的数据结构，它们在功能上非常相似，但也存在一些区别。 1. 线程安全性：Hashtable 是线程安全的，即多个线程可以同时访问一个 Hashtable 实例而不需要额外的同步措施。而 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值