Java 集合、HashMap 底层实现原理

青旅半醒 2024-04-01 15:43 75阅读 0赞

### 一、Java 集合概述 ###

Java 集合可分为 **Collection** 和 **Map** 两种体系

*  **Collection接口**：单列数据，定义了存取一组对象的方法的集合
    
     *  List：元素有序(指的是存储时，与存放顺序保持一致)、可重复的集合
     *  Set：元素无序、不可重复的集合

###  **1、Collection：** ###

![9319c131616842a7878331376c6dced8.png][]

#### ArrayList和LinkedList的异同？ ####

二者都线程不安全，相对线程安全的Vector，执行效率高。此外，ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。对于随机访问get和set，ArrayList优于LinkedList，因为LinkedList要移动指针。对于新增和删除操作add(特指插入)和remove，LinkedList比较占优势，因为ArrayList要移动数据。

#### ArrayList和Vector的区别？ ####

Vector和ArrayList几乎是完全相同的,唯一的区别在于Vector是同步类(synchronized)，属于强同步类。因此开销就比ArrayList要大，访问要慢。正常情况下,大多数的Java程序员使用ArrayList而不是Vector,因为同步完全可以由程序员自己来控制。Vector每次扩容请求其大小的2倍空间，而ArrayList是1.5倍。Vector还有一个子类Stack。

#### Collection子接口：Set接口 ####

####    Set接口描述 ####

Set接口是Collection的子接口，set接口没有提供额外的方法  
Set 集合不允许包含相同的元素，如果试把两个相同的元素加入同一个Set 集合中，则添加操作失败。  
Set 判断两个对象是否相同不是使用 == 运算符，而是根据 equals() 方法  
Set实现类之一：HashSet

HashSet 是 Set 接口的典型实现，大多数时候使用 Set 集合时都使用这个实现类。  
HashSet 按 Hash 算法来存储集合中的元素，因此具有很好的存取、查找、删除性能。  
HashSet 具有以下特点：不能保证元素的排列顺序、HashSet 不是线程安全的、集合元素可以是 null  
HashSet 集合判断两个元素相等的标准：两个对象通过 hashCode() 方法比较相等，并且两个对象的 equals() 方法返回值也相等。  
对于存放在Set容器中的对象，对应的类一定要重写equals()和hashCode(Object obj)方法，以实现对象相等规则。即：“相等的对象必须具有相等的散列码”。  
向HashSet中添加元素的过程

当向 HashSet 集合中存入一个元素时，HashSet 会调用该对象的 hashCode() 方法来得到该对象的 hashCode 值，然后根据 hashCode 值，通过某种散列函数决定该对象在 HashSet 底层数组中的存储位置。（这个散列函数会与底层数组的长度相计算得到在数组中的下标，并且这种散列函数计算还尽可能保证能均匀存储元素，越是散列分布，该散列函数设计的越好）  
如果两个元素的hashCode()值相等，会再继续调用equals方法，如果equals方法结果为true，添加失败；如果为false，那么会保存该元素，但是该数组的位置已经有元素了，那么会通过链表的方式继续链接。  
如果两个元素的 equals() 方法返回 true，但它们的 hashCode() 返回值不相等，hashSet 将会把它们存储在不同的位置，但依然可以添加成功。  
重写 equals() 方法的基本原则

当一个类有自己特有的“逻辑相等”概念,当改写equals()的时候，总是要改写hashCode()，根据一个类的equals方法（改写后），两个截然不同的实例有可能在逻辑上是相等的，但是，根据Object.hashCode()方法，它们仅仅是两个对象。因此，违反了“相等的对象必须具有相等的散列码”。

####    结论： ####

复写equals方法的时候一般都需要同时复写hashCode方法。通常参与计算hashCode的对象的属性也应该参与到equals()中进行计算。

####    Set实现类之二：LinkedHashSet ####

LinkedHashSet 是 HashSet 的子类  
LinkedHashSet 根据元素的 hashCode 值来决定元素的存储位置，但它同时使用双向链表维护元素的次序，这使得元素看起来是以插入顺序保存的。  
LinkedHashSet插入性能略低于 HashSet，但在迭代访问 Set 里的全部元素时有很好的性能。  
LinkedHashSet 不允许集合元素重复。

### 2、map ###

![518ff6a7d11d453dad80c7ac8b4ad4f6.png][]

#### Map接口 ####

Map接口概述

1.  Map与Collection并列存在。用于保存具有映射关系的数据:key-value
2.  Map 中的 key 和 value 都可以是任何引用类型的数据
3.  Map 中的 key 用Set来存放，不允许重复，即同一个 Map 对象所对应的类，须重写 hashCode()和equals() 方法
4.  常用String类作为Map的“键”
5.  key 和 value 之间存在单向一对一关系，即通过指定的 key 总能找到唯一的、确定的 value
6.  Map接口的常用实现类：HashMap、TreeMap、LinkedHashMap和Properties。其中，HashMap是 Map 接口使用频率最高的实现类

#### **Map实现类之一：HashMap** ####

1.  HashMap是 Map 接口使用频率最高的实现类。
2.  允许使用null键和null值，与HashSet一样，不保证映射的顺序。
3.  所有的key构成的集合是Set:无序的、不可重复的。所以，key所在的类要重写：equals()和hashCode()
4.  所有的value构成的集合是Collection:无序的、可以重复的。所以，value所在的类要重写：equals()
5.  一个key-value构成一个entry
6.  所有的entry构成的集合是Set:无序的、不可重复的
7.  HashMap 判断两个 key 相等的标准是：两个 key 通过 equals() 方法返回 true，hashCode 值也相等。
8.  HashMap 判断两个 value相等的标准是：两个 value 通过 equals() 方法返回 true。

#### Map实现类之三：TreeMap ####

TreeMap存储 Key-Value 对时，需要根据 key-value 对进行排序。TreeMap 可以保证所有的 Key-Value 对处于有序状态。  
TreeSet底层使用红黑树结构存储数据  
TreeMap 的 Key 的排序：  
自然排序：TreeMap 的所有的 Key 必须实现 Comparable 接口，而且所有的 Key 应该是同一个类的对象，否则将会抛出 ClasssCastException  
定制排序：创建 TreeMap 时，传入一个 Comparator 对象，该对象负责对TreeMap 中的所有 key 进行排序。此时不需要 Map 的 Key 实现Comparable 接口  
TreeMap判断两个key相等的标准：两个key通过compareTo()方法或者compare()方法返回0。

####    Map实现类之四：Hashtable ####

Hashtable是个古老的 Map 实现类，JDK1.0就提供了。不同于HashMap，Hashtable是线程安全的。  
Hashtable实现原理和HashMap相同，功能相同。底层都使用哈希表结构，查询速度快，很多情况下可以互用。  
与HashMap不同，Hashtable 不允许使用 null 作为 key 和 value  
与HashMap一样，Hashtable 也不能保证其中 Key-Value 对的顺序  
Hashtable判断两个key相等、两个value相等的标准，与HashMap一致。  
Map实现类之五：Properties  
Properties 类是 Hashtable 的子类，该对象用于处理属性文件  
由于属性文件里的 key、value 都是字符串类型，所以 Properties 里的 key 和 value 都是字符串类型  
存取数据时，建议使用setProperty(String key,String value)方法和getProperty(String key)方法

#### **HashMap的存储结构** ####

*  JDK 7及以前版本：HashMap是数组+链表结构(即为链地址法)
 *  JDK 8版本发布以后：HashMap是数组+链表+红黑树实现。

#### **HashMap源码中的重要常量** ####

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16  默认的初始容量
    static final float DEFAULT_LOAD_FACTOR = 0.75f; //加载因子
    static final int TREEIFY_THRESHOLD = 8; //链表长度的阈值，当超过8时，会进行树化（不绝对，如下面源码分析）
    static final int UNTREEIFY_THRESHOLD = 6; //当树中只有6个或以下，转化为链表
    transient int size; //HashMap的大小
    int threshold; //判断是否扩容的阈值

### HashMap实现原理 ###

####    1.概述 ####

HashMap是基于哈希表的Map接口的非同步实现。元素以键值对的形式存放，并且允许null键和null值，因为key值唯一（不能重复），因此，null键只有一个。另外，hashmap不保证元素存储的顺序，是一种无序的，和放入的顺序并不相同（此类不保证映射的顺序，特别是它不保证该顺序恒久不变）。HashMap是线程不安全的。

#### 2.继承关系 ####

public class HashMap<K,V> extends AbstractMap<K,V>
        implements Map<K,V>, Cloneable, Serializable

Note：HashMap的扩容操作是一项很耗时的任务，所以如果能估算Map的容量，最好给它一个默认初始值，避免进行多次扩容。HashMap的线程是不安全的，多线程环境中推荐是ConcurrentHashMap

从下图中看出，HashMap底层就是一个数组结构，数组中的每一项又是一个链表。当新建一个HashMap的时候，就会初始化一个数组

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zlbmd4aV90YW4_size_16_color_FFFFFF_t_70]

当列表长度超过8时，就会转换为红黑树结构

#### HashMap的数据存储结构 ####

HashMap类中的Node<K,V>类里有一个Node<K,V> next。那以Node<K,V>.next.next.next这种结构形式存储元素就是所说的链表，而Node<K,V>\[ \] tab就是数组，tab所存储元素为每个链表的第一个元素。

每个数组的位置就是一个哈希值，如果两个值哈希值一样，就会占用一个位置，他们就成了一个链表

Java8优化了这个地方，如果相同哈希值，链表的长度超过8，就从链表转换成红黑树，Node类是HashMap的一个静态内部类，实现了 Map.Entry<K,V>接口。在调用put方法创建一个新的键值对时，会调用newNode方法来创建Node对象

**数据结构**  
  HashMap内部结构是数组（Node\[\] table）和链表结合组成的复合结构，数组被分成一个个桶（bucket），通过哈希值决定键值对在这个数组的寻址；哈希值相同的键值对，则以链表形式存储。需注意的是：链表大小超过阈值（TREEIFY\_THRESHOLD = 8）时，链表就会被改造成树形结构。 下面示意图为一个简单的HashMap示意图：

![1a0c2e6573424b30ada0d5f281700269.png][]

#### HashMap由数组+链表+红黑树进行数据的存储 ####

HashMap采用table数组存储Key-Value的，每一个键值对组成了一个Node节点（JDK1.7为Entry实体，因为jdk1.8加入了红黑树，所以改为Node）。Node节点实际上是一个单向的链表结构，它具有Next指针，可以连接下一个Node节点，以此来解决Hash冲突的问题。

transient Node<K,V>[] table; //默认数组
    
    static class Node<K,V> implements Map.Entry<K,V> {
            final int hash;
            final K key;
            V value;
            Node<K,V> next;
    }

从源码，Node就是数组中的元素，每个 Map.Entry 其实就是一个key-value对，它持有一个指向下一个元素的引用，这就构成了链表。

#### HashMap实现存储和读取 ####

**put操作**

put操作所对应的实现流程如下图所示：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zlbmd4aV90YW4_size_16_color_FFFFFF_t_70 1]

具体的源码实现如下：

//put操作
    public V put(K key, V value) {
         return putVal(hash(key), key, value, false, true);
    }
    
    //计算key对象的hash值
    static final int hash(Object key) { 
         int h;
         return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);//进行与操作
    }
    
    //具体添加细节
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                       boolean evict) {
            Node<K,V>[] tab; //创建数组
            Node<K,V> p; //新节点
            int n, i;
            if ((tab = table) == null || (n = tab.length) == 0)
                n = (tab = resize()).length; //对数组进行初始化
            if ((p = tab[i = (n - 1) & hash]) == null) //(n - 1) & hash 求数组的下标，判断是否有元素。没有
                tab[i] = newNode(hash, key, value, null);  //直接放入
            else { //有元素
                Node<K,V> e; 
                K k;
                //判断存储的节点是否已存在。
                //1.两个对象的hash值不同，一定不是同一个对象
                //2.hash值相同，两个对象也不一定相等
                if (p.hash == hash &&
                    ((k = p.key) == key || (key != null && key.equals(k))))
                    e = p; //存储的节点的key的已存在，直接进行替换
                else if (p instanceof TreeNode) //存储的节点的key的不存在，判断是否为树节点（是不是已经转化为红黑树）
                    e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
                else {//即不存在。也不是树节点，
                    for (int binCount = 0; ; ++binCount) {
                        if ((e = p.next) == null) { //直接找到链表的尾部，直接插入
                            p.next = newNode(hash, key, value, null);
                            if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st 判断链表的长度是否大于可以转化为树结构的阈值
                                treeifyBin(tab, hash); //树化
                            break;
                        }
                        if (e.hash == hash &&
                            ((k = e.key) == key || (key != null && key.equals(k)))) //判断是否和插入对象相同
                            break;
                        p = e;
                    }
                }
                if (e != null) { // existing mapping for key 存在映射的key，覆盖原值，将原值返回
                    V oldValue = e.value;
                    if (!onlyIfAbsent || oldValue == null)
                        e.value = value;
                    afterNodeAccess(e);
                    return oldValue;
                }
            }
            ++modCount;
            if (++size > threshold) //hashmap的容量大于阈值
                resize(); //扩容
            afterNodeInsertion(evict);
            return null;
        }

由上面的源码可知,，当添加一个Key-Value时，我们通过hash()计算出Key所对应的hash值，然后去调用putVal（）真正的执行put操作。

首先判断数组是否为空，如果是，则进行初始化。  
其次，根据\*\*(n - 1) & hash\*\*求出要添加对象所在的索引位置，判断此索引的内容是否为空，如果是，则直接存储，  
如果不是，则判断索引位置的对象和要存储的对象是否相同，首先判断hash值知否相等，在判断key是否相等。（1.两个对象的hash值不同，一定不是同一个对象。2.hash值相同，两个对象也不一定相等）。如果是同一个对象，则直接进行覆盖，返回原值。  
如果不是，则判断是否为树节点对象，如果是，直接添加  
当既不是相同对象，又不是树节点，直接将其插入到链表的尾部。在进行判断是否需要进行树化。  
最后，判断hashmap的size是否达到阈值，进行扩容resize()处理。

####    resize（）扩容操作 ####

当hashmap中的元素越来越多的时候，碰撞的几率也就越来越高（因为数组的长度是固定的），所以为了提高效率，就要对hashmap的数组进行扩容，而在hashmap数组扩容之后，最消耗性能的点就出现了：原数组中的数据必须重新计算其在新数组中的位置，并放进去，这就是resize。

那么hashmap什么时候进行扩容呢？当hashmap中的元素个数超过数组大小loadFactor时，就会进行数组扩容，loadFactor的默认值为0.75，也就是说，默认情况下，数组大小为16，那么当hashmap中元素个数超过160.75=12的时候，就把数组的大小扩展为2\*16=32，即扩大一倍，然后重新计算每个元素在数组中的位置，而这是一个非常消耗性能的操作，所以如果我们已经预知hashmap中元素的个数，那么预设元素的个数能够有效的提高hashmap的性能。

#### 初始化和扩容的具体流程如下： ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zlbmd4aV90YW4_size_16_color_FFFFFF_t_70 2]

#### HashMap的面试相关 ####

**HashMap和Hashtable的区别**

HashMap和Hashtable都实现了Map接口，。主要的区别有：

1.  对Null key 和Null value的支持：HashMap可以接受为null的键值(key)和值(value)，Hashtable不能接受null值，会产生空指针异常。
2.  线程是否安全： HashMap是非synchronized，而Hashtable是synchronized，这意味着Hashtable是线程安全的，多个线程可以共享一个Hashtable；而如果没有正确的同步的话，多个线程是不能共享HashMap的
3.  效率： 由于Hashtable是线程安全的，所以在单线程环境下比HashMap要慢。如果你不需要同步，只需要单一线程，那么使用HashMap性能要好过Hashtable。
4.  初始容量大小和每次扩充容量大小的不同：HashMap初始大小为16，扩容为2的幂次方；HashTable初始为11，扩容为2n+1
5.  底层结构：HashMap会将链表长度大于阈值是转化为红黑树（会先判断当前数组的长度是否小于 64，是则扩容，而不转化），将链表转化为红黑树，以减少搜索时间。Hashtable 没有这样的机制。

#### **HashMap 和 HashSet区别** ####

HashSet 底层就是基于 HashMap 实现的。（HashSet的对象相当于存储在HashMap的Key上，所以保证了唯一性）

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zlbmd4aV90YW4_size_16_color_FFFFFF_t_70 3]

#### **HashSet如何检查重复** ####

当你把对象加入HashSet时，HashSet会先计算对象的hashcode值来判断对象加入的位置，同时也会与其他加入的对象的hashcode值作比较，如果没有相符的hashcode，HashSet会假设对象没有重复出现。但是如果发现有相同hashcode值的对象，这时会调用equals()方法来检查hashcode相等的对象是否真的相同。如果两者相同，HashSet就不会让加入操作成功。

#### **HashMap 多线程操作导致死循环问题** ####

当重新调整HashMap大小的时候，确实存在条件竞争，因为如果两个线程都发现HashMap需要重新调整大小了，它们会同时试着调整大小。在调整大小的过程中，存储在链表中的元素的次序会反过来，因为移动到新的bucket位置的时候，HashMap并不会将元素放在链表的尾部，而是放在头部，这是为了避免尾部遍历(tail traversing)。如果条件竞争发生了，那么就死循环了。

## ConcurrentHashMap ##

> 要避免 HashMap 的线程安全问题，有多个解决方法，比如改用 HashTable 或者 Collections.synchronizedMap() 方法。
> 
>   但是这两者都有一个问题，就是性能，无论读还是写，他们两个都会给整个集合加锁，导致同一时间的其他操作阻塞。
> 
>   ConcurrentHashMap 的优势在于兼顾性能和线程安全，一个线程进行写操作时，它会锁住一小部分，其他部分的读写不受影响，其他线程访问没上锁的地方不会被阻塞。

ConcurrentHashMap 由多个 Segment 组合而成。Segment 本身就相当于一个 HashMap 对象。同 HashMap 一样，Segment 包含一个 HashEntry 数组，数组中的每一个 HashEntry 既是一个键值对，也是一个链表的头节点。

单一的 Segment 结构如下：

![79a37b0bd69c429ca59040a18cb7d1ff.png][]

像这样的 Segment 对象，在 ConcurrentHashMap 集合中有多少个呢？有 2 的 N 次方个，共同保存在一个名为 segments 的数组当中。

因此整个ConcurrentHashMap的结构如下：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5MDUxNDEz_size_16_color_FFFFFF_t_70]

可以说，ConcurrentHashMap 是一个二级哈希表。在一个总的哈希表下面，有若干个子哈希表。

`Segment`是它的一个内部类，主要组成如下：

static final class Segment<K,V> extends ReentrantLock implements Serializable {
    	private static final long serialVersionUID = 2249069246763182397L;	
    	// 和 HashMap 中的 HashEntry 作用一样，真正存放数据的桶
    	transient volatile HashEntry<K,V>[] table;
    	transient int count;
    	transient int modCount;
    	transient int threshold;
    	final float loadFactor;
    
    	// ...
    }

### Put 操作 ###

> 首先是通过 key 定位到 Segment，之后在对应的 Segment 中进行具体的 put。

### Get 操作 ###

> Get 操作比较简单：  
>   1、Key 通过 Hash 之后定位到具体的 Segment；  
>   2、再通过一次 Hash 定位到具体的元素上；  
>   3、由于 HashEntry 中的 value 属性是用 volatile 关键词修饰的，保证了内存可见性，所以每次获取时都是最新值。
> 
> ConcurrentHashMap 的 get 方法是非常高效的，因为整个过程都不需要加锁。

### 高并发线程安全 ###

> Put 操作时，锁的是某个 Segment，其他线程对其他 Segment 的读写操作均不影响。因此解决了线程安全问题。

[9319c131616842a7878331376c6dced8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/18dd6d03581e4766bf355dc6ea298756.png
[518ff6a7d11d453dad80c7ac8b4ad4f6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/d6968e83a110408c8695d741e5257b14.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zlbmd4aV90YW4_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/5afdb5cab74e4057a6b9ed790475101c.png
[1a0c2e6573424b30ada0d5f281700269.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/25743fe533fe47428ac474b08b4b0a38.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zlbmd4aV90YW4_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/69a02c75ea24469a93130393b0fe25d4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zlbmd4aV90YW4_size_16_color_FFFFFF_t_70 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/539246bf415c4e51be80e32b841a17a0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zlbmd4aV90YW4_size_16_color_FFFFFF_t_70 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/e0429174a61d4c438c02776b95b16e09.png
[79a37b0bd69c429ca59040a18cb7d1ff.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/5864929731cb4af8987672a0b4192371.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5MDUxNDEz_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/562838a3f4e94c57b192ebed0da394cc.png