HashMap如何在JAVA中工作

大多数JAVA开发人员都在使用Map，尤其是HashMap。HashMap是一种存储和获取数据的简单而强大的方法。但有多少开发人员知道HashMap如何在内部工作？几天前，我阅读了java.util.HashMap的大部分源代码（在Java 7中，然后是Java 8），以便深入理解这个基本数据结构。在这篇文章中，我将解释java.util.HashMap的实现，介绍JAVA 8实现中的新功能，并讨论使用HashMaps时的性能，内存和已知问题。

内部存储器

JAVA HashMap类实现了Map <K，V>接口。该接口的主要方法是：

• V put（K键，V值）
• V get（对象键）
• V删除（对象键）
• Boolean containsKey（Object key）

HashMaps使用内部类来存储数据：Entry <K，V>。此条目是一个简单的键值对，包含两个额外数据：

• 对另一个Entry的引用，以便HashMap可以存储单个链接列表等条目
• 一个哈希值，表示密钥的哈希值。存储该散列值以避免每次HashMap需要时计算散列。

以下是JAVA 7中Entry实现的一部分：

static class Entry<K,V> implements Map.Entry<K,V> {         final K key;         V value;         Entry<K,V> next;         int hash; … }

HashMap将数据存储到多个单链接的条目列表（也称为存储桶或存储桶）中。所有列表都在Entry（Entry <K，V> []数组）数组中注册，并且此内部数组的默认容量为16。

 

 下图显示了具有可为空条目数组的HashMap实例的内部存储。每个条目都可以链接到另一个条目以形成链接列表。

 

具有相同散列值的所有键都放在同一个链表（存储桶）中。具有不同散列值的键可以在同一个桶中结束。

当用户调用put（K键，V值）或get（Object键）时，该函数计算条目应该在其中的桶的索引。然后，函数遍历列表以查找具有相同键的Entry（使用键的equals（）函数）。

在get（）的情况下，函数返回与条目关联的值（如果条目存在）。

在put（K key，V value）的情况下，如果条目存在，则函数将其替换为新值，否则它将在单链接列表的头部创建新条目（来自参数中的键和值）。

 

桶的这个索引（链表）由以下3个步骤生成：

• 它首先获取密钥的哈希码。
• 它重新散列哈希码以防止来自密钥的错误哈希函数，该密钥将所有数据放在内部数组的同一索引中
• 它采用重新散列的散列哈希码，并使用数组的长度（减1）对其进行位掩码。此操作可确保索引不能大于数组的大小。您可以将其视为计算优化的模数函数。

以下是处理索引的JAVA 7和8源代码：

// the "rehash" function in JAVA 7 that takes the hashcode of the key static int hash(int h) {     h ^= (h >>> 20) ^ (h >>> 12);     return h ^ (h >>> 7) ^ (h >>> 4); } // the "rehash" function in JAVA 8 that directly takes the key static final int hash(Object key) {     int h;     return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);     } // the function that returns the index from the rehashed hash static int indexFor(int h, int length) {     return h & (length-1); }

为了有效地工作，内部数组的大小需要是2的幂，让我们看看为什么。

想象一下，数组大小为17，掩码值将为16（大小-1）。16的二进制表示是0 ... 010000，因此对于任何散列值H，使用按位公式“H AND 16”生成的索引将是16或0.这意味着大小为17的数组将仅用于2个桶：索引0的那个和索引16的那个，效率不高......

但是，如果现在采用像16这样的2的幂的大小，则按位索引公式为“H AND 15”。15的二进制表示为0 ... 001111，因此索引公式可以输出0到15的值，并且完全使用大小为16的数组。例如：

• 如果H = 952，则其二进制表示为0..0111011 1000，关联索引为0 ... 0 1000  = 8
• 如果H = 1576，其二进制表示为0..01100010 1000，则相关索引为0 ... 0 1000  = 8
• 如果H = 12356146，其二进制表示为0..010111100100010100011 0010，关联索引为0 ... 0 0010= 2
• 如果H = 59843，其二进制表示为0..0111010011100 0011，关联索引为0 ... 0 0011  = 3

 

这就是数组大小为2的幂的原因。这种机制对于开发人员是透明的：如果他选择大小为37的HashMap，Map将在37（64）之后自动选择下一个2的幂，用于其内部数组的大小。

 

自动调整大小

获取索引后，函数（获取，放置或删除）访问/迭代关联的链接列表以查看给定键是否存在现有条目。如果不进行修改，此机制可能会导致性能问题，因为函数需要遍历整个列表以查看条目是否存在。想象一下，内部数组的大小是默认值（16），您需要存储2百万个值。在最佳情况下，每个链表的大小为125 000个条目（2/16百万）。因此，每个get（），remove（）和put（）将导致125 000次迭代/操作。为了避免这种情况，HashMap能够增加其内部数组，以保持非常短的链表。

创建HashMap时，可以使用以下构造函数指定初始大小和loadFactor：

public HashMap(int initialCapacity, float loadFactor)

如果未指定参数，则默认initialCapacity为16，默认loadFactor为0.75。initialCapacity表示链接列表的内部数组的大小。

每次使用put（...）在Map中添加新的键/值时，该函数都会检查是否需要增加内部数组的容量。为此，地图存储了2个数据：

• map的大小：它表示HashMap中的条目数。每次添加或删除条目时都会更新此值。
• 一个阈值：它等于（内部数组的容量）* loadFactor，并在每次调整内部数组大小后刷新

在添加新条目之前，put（...）检查大小是否>阈值，如果是这样，它会重新创建一个大小加倍的新数组。由于新数组的大小已更改，因此索引函数（返回按位操作“hash（key）AND（sizeOfArray-1）”）会发生变化。因此，数组的大小调整会创建两倍的桶（即链接列表），并将  所有现有条目重新分配到存储桶（旧的和新创建的）中。

此调整大小操作的目的是减小链接列表的大小，以便put（），remove（）和get（）方法的时间成本保持较低。调整大小后，其键具有相同散列的所有条目将保留在同一个存储桶中。但是，在转换之后，同一个桶中具有不同散列键的2个条目可能不在同一个桶中。

该图显示了在调整内部数组大小之前和之后的表示。在增加之前，为了获得条目E，地图必须遍历5个元素的列表。调整大小后，同样的get（）只迭代2个元素的链表，调整大小后get（）快2倍！

 

注意：HashMap只增加了内部数组的大小，它没有提供减少它的方法。

 

线程安全

如果你已经知道HashMaps，你知道这不是线程安全的，但为什么呢？例如，假设您有一个只将新数据放入Map的Writer线程和一个从Map读取数据的Reader线程，为什么它不能工作？

因为在自动调整大小机制期间，如果线程尝试放入或获取对象，则映射可能使用旧索引值，并且不会找到条目所在的新存储桶。

最糟糕的情况是2个线程同时放入数据，2个put（）调用同时调整Map的大小。由于两个线程同时修改了链接列表，因此Map最终可能会在其链接列表中出现内部循环。如果您尝试使用内部循环获取列表中的数据，则get（）将永远不会结束。

该哈希表的实现是线程安全的实现，从这种情况可以防止。但是，由于所有CRUD方法都是同步的，因此实现速度非常慢。例如，如果线程1调用get（key1），则线程2调用get（key2），线程3调用get（key3），一次只有一个线程能够获取其值，而其中3个线程可以访问数据与此同时。

自JAVA 5以来，存在一个更安全的线程安全HashMap实现：ConcurrentHashMap。只有桶是同步的，因此多个线程可以同时获取（），remove（）或put（）数据，如果它不意味着访问同一个桶或调整内部数组的大小。最好在多线程应用程序中使用此实现。

 

关键不变性

为什么字符串和整数是HashMap键的良好实现？主要是因为它们是不变的！如果您选择创建自己的Key类并且不使其成为不可变类，则可能会丢失HashMap中的数据。

看看下面的用例：

• 你有一个内部值为“1”的键
• 您使用此键将对象放在HashMap中
• HashMap根据Key的哈希码生成哈希值（因此从“1”开始）
• Map  将此哈希存储  在新创建的Entry中
• 您将键的内部值修改为“2”
• 密钥的哈希值被修改但HashMap不知道它（因为存储了旧的哈希值）
• 您尝试使用修改后的密钥获取对象
• 映射计算密钥的新哈希值（因此从“2”开始）以查找条目所在的链表（桶）
• 情况1：由于您修改了密钥，因此映射会尝试在错误的存储桶中找到该条目，但找不到该条目
•  情况2：幸运的是，修改后的密钥生成与旧密钥相同的桶。然后，映射遍历链表以查找具有相同键的条目。但是为了找到密钥，映射首先比较哈希值，然后调用equals（）比较。由于修改后的密钥与旧散列值（存储在条目中）没有相同的散列，因此映射将不会在链接列表中找到该条目。

这是Java中的一个具体示例。我在我的Map中放了2个键值对，我修改了第一个键，然后尝试获取2个值。只有第二个值从地图返回，第一个值在HashMap中“丢失”：

public class MutableKeyTest {       public static void main(String[] args) {           class MyKey {             Integer i;               public void setI(Integer i) {                 this.i = i;             }               public MyKey(Integer i) {                 this.i = i;             }               @Override             public int hashCode() {                 return i;             }               @Override             public boolean equals(Object obj) {                 if (obj instanceof MyKey) {                     return i.equals(((MyKey) obj).i);                 } else                     return false;             }           }           Map<MyKey, String> myMap = new HashMap<>();         MyKey key1 = new MyKey(1);         MyKey key2 = new MyKey(2);           myMap.put(key1, "test " + 1);         myMap.put(key2, "test " + 2);           // modifying key1         key1.setI(3);           String test1 = myMap.get(key1);         String test2 = myMap.get(key2);           System.out.println("test1= " + test1 + " test2=" + test2);       }   }

输出为：“test1 = null test2 = test 2”。正如预期的那样，Map无法使用修改后的密钥1检索字符串1。

 

JAVA 8的改进

HAVMap的内部表示在JAVA 8中发生了很大变化。实际上，JAVA 7中的实现需要1k行代码，而JAVA 8中的实现需要2k行。除了链接的条目列表之外，我之前说过的大部分内容都是正确的。在JAVA8中，您仍然拥有一个数组，但它现在存储的节点包含与条目完全相同的信息，因此也是链接列表：

以下是JAVA 8中Node实现的一部分：

static class Node<K,V> implements Map.Entry<K,V> {      final int hash;      final K key;      V value;      Node<K,V> next;

那么与JAVA 7的最大区别是什么？好吧，节点可以扩展到TreeNodes。TreeNode是一种红黑树结构，可以存储更多信息，以便它可以添加，删除或获取O（log（n））中的元素。

仅供参考，这里是存储在TreeNode中的数据的详尽列表

static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {     final int hash; // inherited from Node<K,V>     final K key; // inherited from Node<K,V>     V value; // inherited from Node<K,V>     Node<K,V> next; // inherited from Node<K,V>     Entry<K,V> before, after;// inherited from LinkedHashMap.Entry<K,V>     TreeNode<K,V> parent;     TreeNode<K,V> left;     TreeNode<K,V> right;     TreeNode<K,V> prev;     boolean red;

红黑树是自平衡二叉搜索树。尽管新添加或删除了节点，但它们的内部机制确保它们的长度始终为log（n）。使用这些树的主要优点是在许多数据位于内部表的相同索引（存储桶）中的情况下，树中的搜索将花费  O（log（n）），而它将花费O（n）带有链表。

如您所见，树占用的空间比链表更多（我们将在下一部分中讨论它）。

通过继承，内部表可以包含 Node（链表）和 TreeNode（红黑树）。Oracle决定使用具有以下规则的两种数据结构：
- 如果内部表中的给定索引（存储桶）有超过8个节点，则链表将转换为红黑树
- 如果对于给定索引（存储桶） ）在内部表中有少于6个节点，树被转换为链表

此图显示了JAVA 8 HashMap的内部数组，其中包含两个树（在存储桶0处）和链接列表（在存储桶1,2和3处）。Bucket 0是一棵树，因为它有超过8个节点。

 

内存开销

JAVA 7

使用HashMap需要以内存为代价。在JAVA 7中，HashMap在条目中包装键值对。一个条目有：

• 对下一个条目的引用
• 预先计算的哈希（整数）
• 对密钥的引用
• 对价值的参考

此外，JAVA 7 HashMap使用Entry的内部数组。假设JAVA 7 HashMap包含N个元素且其内部数组具有容量CAPACITY，则额外的内存成本约为：

sizeOf（整数）* N + sizeOf（参考）*（3 * N + C）

哪里：

• 整数的大小取决于4个字节
• 引用的大小取决于JVM / OS / Processor，但通常是4个字节。

这意味着开销通常是16 * N + 4 * CAPACITY字节

提醒：在自动调整Map之后，内部数组的CAPACITY等于N之后的下一个2的幂。

注意：从JAVA 7开始，H​​ashMap类有一个惰性初始化。这意味着即使您分配了HashMap，在第一次使用put（）方法之前，内部数组条目（成本为4 * CAPACITY字节）也不会在内存中分配。

JAVA 8

使用JAVA 8实现，获取内存使用变得有点复杂，因为Node可以包含与Entry相同的数据或相同的数据加上6个引用和布尔值（如果它是TreeNode）。

如果所有节点都只是节点，则JAVA 8 HashMap的内存消耗与JAVA 7 HashMap相同。

如果所有节点都是TreeNodes，则JAVA 8 HashMap的内存消耗将变为：

N * sizeOf（整数）+ N * sizeOf（布尔值）+ sizeOf（参考）*（9 * N +容量）

在大多数标准JVM中，它等于44 * N + 4 * CAPACITY字节

 

性能问题

倾斜的HashMap与均衡的HashMap相比

在最好的情况下，get（）和put（）方法的时间复杂度成本为O（1）。但是，如果你不处理密钥的哈希函数，你最终可能会得到非常慢的put（）和get（）调用。put（）和get的良好性能取决于将数据重新分配到内部数组（桶）的不同索引中。如果你的密钥的哈希函数设计不合理，你将有一个偏斜重新分区（无论内部数组的容量有多大）。所有使用最大链接列表的put（）和get（）都会很慢，因为它们需要迭代整个列表。在最坏的情况下（如果大多数数据都在相同的存储区中），最终可能会出现O（n）时间复杂度。
这是一个视觉示例。第一张图片显示了倾斜的HashMap，第二张图片显示了平衡的HashMap。

 

在这个倾斜的HashMap的情况下，对桶0的get（）/ put（）操作是昂贵的。获得入门K将花费6次迭代

在这个平衡良好的HashMap的情况下，获得Entry K将花费3次迭代。两个HashMaps都存储相同数量的数据并具有相同的内部数组大小。唯一的区别是分配桶中条目的哈希（密钥）函数。

这是JAVA中的一个极端示例，我创建了一个散列函数，将所有数据放在同一个桶中，然后我添加了200万个元素。

public class Test {       public static void main(String[] args) {           class MyKey {             Integer i;             public MyKey(Integer i){                 this.i =i;             }               @Override             public int hashCode() {                 return 1;             }               @Override             public boolean equals(Object obj) {             …             }           }         Date begin = new Date();         Map <MyKey,String> myMap= new HashMap<>(2_500_000,1);         for (int i=0;i<2_000_000;i++){             myMap.put( new MyKey(i), "test "+i);         }           Date end = new Date();         System.out.println("Duration (ms) "+ (end.getTime()-begin.getTime()));     } }

在我的核心i5-2500k @ 3.6Ghz上使用java 8u40 需要超过45分钟（我在45分钟后停止了这个过程）。

现在，如果我运行相同的代码，但这次我使用以下哈希函数

@Override     public int hashCode() {         int key = 2097152-1;         return key+2097152*i; }

它需要46秒，这是更好的方式！此散列函数具有比前一个更好的重新分区，因此put（）调用更快。

如果我使用以下散列函数运行相同的代码，该函数提供更好的散列重新分区

@Override public int hashCode() { return i; }

现在需要2秒钟。

我希望你意识到哈希函数的重要性。如果在JAVA 7上运行相同的测试，结果对于第一和第二种情况会更糟（因为在JAVA 7中，put的时间复杂度是JAVA 7中的O（n）对比O（log（n））

使用HashMap时，您需要为键找到一个哈希函数，将键扩展到最可能的桶中。为此，您需要避免哈希冲突。String对象是一个很好的密钥，因为它具有良好的散列函数。整数也很好，因为它们的哈希码是它们自己的值。

 

调整开销大小

如果需要存储大量数据，则应创建初始容量接近预期容量的HashMap。

如果不这样做，Map将采用默认大小16，factorLoad为0.75。第一个put（）将非常快，但是第12个（16 * 0.75）将重新创建一个新的内部数组（带有相关的链表/树），新容量为32个。第13个到第23个将快速但是第24个（32 * 0.75）将重新创建（再次）昂贵的新表示，使内部数组的大小加倍。内部调整大小操作将出现在put（）的第48，第96，第192，...调用中。在低音量时，内部阵列的完全重新创建是快速的，但是在高音量时它可能需要几秒到几分钟。通过初始设置您的预期大小，您可以避免这些  昂贵的操作。

但是有一个缺点：如果你设置一个非常高的数组大小，如2 ^ 28，而你的阵列只使用2 ^ 26个桶，你将浪费大量内存（在这种情况下大约2 ^ 30字节）。

 

结论

对于简单的用例，您不需要知道HashMaps如何工作，因为您不会看到O（1）和O（n）或O（log（n））操作之间的区别。但是，了解最常用的数据结构之一的底层机制主义总是更好。而且，对于java开发人员来说，这是一个典型的面试问题。

在高容量时，了解它是如何工作以及理解密钥的散列函数的重要性变得很重要。

我希望这篇文章能帮助您深入了解HashMap的实现。