Java面试题一：HashMap 和 HashTable 以及 ConcurrentHashMap的原理和区别

最新推荐文章于 2023-01-26 17:44:50 发布

songzi1228

最新推荐文章于 2023-01-26 17:44:50 发布

阅读量447

点赞数 2

分类专栏： Java面试题 Java：数据结构

本文链接：https://blog.youkuaiyun.com/songzi1228/article/details/99974540

版权

Java：数据结构同时被 2 个专栏收录

18 篇文章

订阅专栏

Java面试题

15 篇文章

订阅专栏

本文深入探讨了Java中的HashMap、HashTable和ConcurrentHashMap的原理及区别。HashMap是非线程安全的，允许null值，而HashTable线程安全但效率较低。ConcurrentHashMap通过分段锁实现高效线程安全。它们在继承、底层实现、线程安全、contains方法、null值处理、遍历方式、hash值计算以及扩容策略等方面存在显著差异。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

问题分析：

一、HashMap、HashTable、ConcurrentHashMap的原理

HashTable

HashMap

ConcurrentHashMap

二、HashMap、HashTable和ConcurrentHashMap的区别。

8、内部实现使用的数组初始化和扩容方式不同

三、ConcurrentHashMap

HashTable和HashMap的区别详解（很详细 9w阅读量 157赞简略版答案主要根据此篇文章进行总结）

HashMap 与HashTable的区别（很详细 10w阅读量 66赞）

【Java集合源码剖析】HashMap源码剖析（很详细）

【Java集合源码剖析】Hashtable源码剖析（很详细）

Java集合源码剖析（系列文章 8篇）

面试必备：HashMap、Hashtable、ConcurrentHashMap的原理与区别（简略）

面试题：HashMap的原理、HashTable和HashMap的区别详解（自己的一些转载文章）

数据结构六：HashMap （自己的源码分析，较为详细）

理解Java7和8里面HashMap+ConcurrentHashMap的扩容策略

问题分析：

一般来说，这三个东西基本在面试中 70% 会被问到，而问的方向也不太一样。比如初级的问法是讲讲它们之前的区别，这个我想没什么难度，大多数人还是知道主要核心区别是并发上的处理。此外，内部数据结构的实现、扩容、存取操作这些问题应该是很老生常谈了，这并没有什么好说的，大多数人也都知道。稍微问的深一点的可能会在下面这些点上出问题。哈希碰撞，哈希计算，哈希映射，为什么是头插法，扩容为什么是 2 的幂次等这样的问题。

可以分解为多个问题：

一、HashMap、HashTable、ConcurrentHashMap的原理

二、HashMap、HashTable、ConcurrentHashMap的区别

三、内部数据结构的实现、扩容、存取操作

四、哈希碰撞、哈希计算、哈希映射

五、为什么是头插法？扩容为什么是2的幂次

concurrent 美 [kənˈkɜːrənt] 同时发生的

〇、文档资料

JDK1.8文档中，关于Hashtable的描述：
Hashtable从JDK1.0开始，而从JDK1.2开始，这个类被改造为实现Map接口，使其成为Java Collections Framework。与新的集合实现不同， Hashtable是同步的。如果不需要线程安全的实现，建议使用HashMap代替Hashtable 。如果需要线程安全的并发实现，那么建议使用ConcurrentHashMap代替Hashtable 。

因此，在实际开发中，其实是用不到Hashtable的，只是在面试中常被拿来用而已。

一、HashMap、HashTable、ConcurrentHashMap的原理

面试必备：HashMap、Hashtable、ConcurrentHashMap的原理与区别

HashTable

底层数组+链表实现，无论key还是value都不能为null，线程安全，实现线程安全的方式是在修改数据时锁住整个HashTable，效率低，ConcurrentHashMap做了相关优化
初始size为11，扩容：newsize = olesize*2+1
计算index的方法：index = (hash & 0x7FFFFFFF) % tab.length

HashMap

底层数组+链表实现，可以存储null键和null值，线程不安全
初始size为16，扩容：newsize = oldsize*2，size一定为2的n次幂
扩容针对整个Map，每次扩容时，原来数组中的元素依次重新计算存放位置，并重新插入
插入元素后才判断该不该扩容，有可能无效扩容（插入后如果扩容，如果没有再次插入，就会产生无效扩容）
当Map中元素总数超过Entry数组的75%，触发扩容操作，为了减少链表长度，元素分配更均匀
计算index方法：index = hash & (tab.length – 1)

ConcurrentHashMap

底层采用分段的数组+链表实现，线程安全
通过把整个Map分为N个Segment，可以提供相同的线程安全，但是效率提升N倍，默认提升16倍。(读操作不加锁，由于HashEntry的value变量是 volatile的，也能保证读取到最新的值。)
Hashtable的synchronized是针对整张Hash表的，即每次锁住整张表让线程独占，ConcurrentHashMap允许多个修改操作并发进行，其关键在于使用了锁分离技术
有些方法需要跨段，比如size()和containsValue()，它们可能需要锁定整个表而而不仅仅是某个段，这需要按顺序锁定所有段，操作完毕后，又按顺序释放所有段的锁
扩容：段内扩容（段内元素超过该段对应Entry数组长度的75%触发扩容，不会对整个Map进行扩容），插入前检测需不需要扩容，有效避免无效扩容

二、HashMap、HashTable和ConcurrentHashMap的区别。

更加简略回答：

1、底层实现
2、线程安全性不同
3、key和value是否允许null值
4、内部实现使用的数组初始化和扩容方式不同

简略回答：

1、继承的父类
2、底层实现
3、线程安全性不同
4、是否提供contains方法
5、key和value是否允许null值
6、两个遍历方式的内部实现上不同
7、hash值不同
8、内部实现使用的数组初始化和扩容方式不同

较为详细回答：

1、继承的父类

Hashtable继承自Dictionary类，而HashMap和ConcurrentHashMap继承自AbstractMap类。但三者都实现了Map接口。

2、底层实现

HashTable：底层数组+链表实现，无论key还是value都不能为null，线程安全
HashMap：底层数组+链表实现，可以存储null键和null值，线程不安全
ConcurrentHashMap：底层采用分段的数组+链表实现，无论key还是value都不能为null，线程安全

3、线程安全性不同

ConcurrentHashMap集合为什么是线程安全的？

为什么HashMap线程不安全

HashMap的实现是线程不安全的；
Hashtable的线程安全很好理解，因为它对外提供的方法中都加入了synchronized，但也因此导致它的效率比较低。
ConcurrentHashMap通过把整个Map分为N个Segment，可以提供相同的线程安全，但是效率提升N倍，默认提升16倍

Hashtable代码举例：

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

public synchronized V get(Object key) {...}

public synchronized V remove(Object key) {...}

ConcurrentHashMap代码举例（jdk版本为1.8）：也是通过synchronized来实现线程安全的！！

public V put(K key, V value) {
    return putVal(key, value, false);
}

final V putVal(K key, V value, boolean onlyIfAbsent) {
    ...
    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh;
        if (tab == null || (n = tab.length) == 0)
              tab = initTable();
        ...
        else {
             V oldVal = null;
             synchronized (f) {
                ...
             }
        }
    }

}

4、是否提供contains方法

HashMap把Hashtable的contains方法去掉了，改成containsValue和containsKey，因为contains方法容易让人引起误解。

Hashtable则保留了contains，containsValue和containsKey三个方法，其中contains和containsValue功能相同。

ConcurrentHashMap也包含contains，containsValue和containsKey三个方法，但是contains是个抽象的方法

5、key和value是否允许null值

其中key和value都是对象，并且不能包含重复key，但可以包含重复的value。
通过上面的ContainsKey方法和ContainsValue的源码我们可以很明显的看出：
Hashtable中，key和value都不允许出现null值。但是如果在Hashtable中有类似put(null,null)的操作，编译同样可以通过，因为key和value都是Object类型，但运行时会抛出NullPointerException异常，这是JDK的规范规定的。

ConcurrentHashMap跟Hashtable相同。编译没问题，运行时报错。

HashMap中，null可以作为键，这样的键只有一个；可以有一个或多个键所对应的值为null。当get()方法返回null值时，可能是 HashMap中没有该键，也可能使该键所对应的值为null。因此，在HashMap中不能由get()方法来判断HashMap中是否存在某个键，而应该用containsKey()方法来判断。

//编译期没有问题，运行时会报NullPointerException异常
hashtable.put(null, null);
hashtable.put(1, null);

//编译期和运行期没有问题
hashMap.put(null, null);
System.out.println(hashMap.get(null));
//打印为：null

hashMap.put(null, "0");
System.out.println(hashMap.get(null));
//打印为：0

6、遍历方式的内部实现上不同

Hashtable、HashMap都使用了 Iterator。而由于历史原因，Hashtable还使用了Enumeration（枚举）的方式。

ConcurrentHashMap也是用了Enumeration（枚举）的方式。

Enumeration：美 [ɪˌnuːməˈreɪʃn] 枚举

Hashtable

   private <T> Enumeration<T> getEnumeration(int type) {
        if (count == 0) {
            return Collections.emptyEnumeration();
        } else {
            return new Enumerator<>(type, false);
        }
    } 

    private <T> Iterator<T> getIterator(int type) {
        if (count == 0) {
            return Collections.emptyIterator();
        } else {
            return new Enumerator<>(type, true);
        }
    }

HashMap

    final class KeyIterator extends HashIterator
        implements Iterator<K> {
        public final K next() { return nextNode().key; }
    }

    final class ValueIterator extends HashIterator
        implements Iterator<V> {
        public final V next() { return nextNode().value; }
    }

    final class EntryIterator extends HashIterator
        implements Iterator<Map.Entry<K,V>> {
        public final Map.Entry<K,V> next() { return nextNode(); }
    }

ConcurrentHashMap

public Enumeration<V> elements() {
        Node<K,V>[] t;
        int f = (t = table) == null ? 0 : t.length;
        return new ValueIterator<K,V>(t, f, 0, f, this);
}

7、hash值不同

哈希值的使用不同，HashTable直接使用对象的hashCode。而HashMap重新计算hash值，ConcurrentHashMap也是重新计算。

HashTable

public synchronized V put(K key, V value) {
    int hash = key.hashCode();
    int index = (hash & 0x7FFFFFFF) % tab.length;
}

HashMap

static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

ConcurrentHashMap

static final int HASH_BITS = 0x7fffffff; // usable bits of normal node hash

final V putVal(K key, V value, boolean onlyIfAbsent) {
     int hash = spread(key.hashCode());
}

static final int spread(int h) {
    return (h ^ (h >>> 16)) & HASH_BITS;
}

8、内部实现使用的数组初始化和扩容方式不同

理解Java7和8里面HashMap+ConcurrentHashMap的扩容策略

HashTable在不指定容量的情况下的默认容量为11，扩容时，将容量变为原来的2倍加1
HashMap默认容量为16，HashMap扩容时，将容量变为原来的2倍
ConcurrentHashMap默认容量为16，扩容时，将容量变为原来的2倍(JDk1.7)

HashTable

 
    //默认初始容量为11，加载因子为0.75
    public Hashtable() {
        this(11, 0.75f);
    }
    //扩容为2n+1
    protected void rehash() {
        int newCapacity = (oldCapacity << 1) + 1;
    }

HashMap

/**
     * The default initial capacity - MUST be a power of two.
     */
//默认初始容量为16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

final Node<K,V>[] resize() {
    if (oldCap > 0) {
        ...
        //容量和阈值都 double
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
             newThr = oldThr << 1; // double threshold
        }
}

ConcurrentHashMap (JDk1.7)

static final int DEFAULT_INITIAL_CAPACITY = 16;

private void rehash(HashEntry<K,V> node) {
    HashEntry<K,V>[] oldTable = table;
    int oldCapacity = oldTable.length;
    // 2 倍
    int newCapacity = oldCapacity << 1;
    threshold = (int)(newCapacity * loadFactor);
}