JAVA提高十二：HashMap深入分析

首先想说的是关于HashMap源码的分析园子里面应该有很多，并且都是分析得很不错的文章，但是我还是想写出自己的学习总结，以便加深自己的理解，因此就有了此文，另外因为小孩过来了，因此更新速度可能放缓了，(#^.^#)

一、HashMap的简单使用

学习任何一个集合，首先最基本的是学会使用，因此首先我们看下如何使用HashMap，以及我们经常使用的方法又有哪些，代码如下：

package study.collection;import java.util.HashMap;
import java.util.Map;public class TestMap
{public static void main(String[] args) {Map map = new HashMap();map.put("张三", new Wife("六亦菲"));map.put("李四",new Wife("杨咪"));map.put("王五",new Wife("赵丽英"));System.out.println(map.get("张三"));System.out.println(map.containsKey("王五"));map.remove("李四");System.out.println(map.size());}}class Wife
{private String name;public Wife(){}public Wife(String name) {super();this.name = name;}@Overridepublic String toString(){return "Wife [name=" + name + "]";}
}

上面主要演示了hashmap 中的几个主要方法，如put() get() remove() size() 等方法，实际map中还有很多的方法，如下：

说明：圆形 -- 对外提供的public 方法正方形 ---内部使用的private 方法三角形 --- static 方法。

二、HashMap的概述

上面我们介绍了HashMap的基本使用方法，下面我们进一步来分析下HashMap，而不在仅仅在于会使用。

2.1 HashMap的定义

HashMap基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了不同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同.）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。值得注意的是HashMap不是线程安全的，如果想要线程安全的HashMap，可以通过Collections类的静态方法synchronizedMap获得线程安全的HashMap。

 Map map = Collections.synchronizedMap(new HashMap());

我们来看下Map的类定义：

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

从上面的HashMap 此类的定义来看，我可以这样来理解HashMap; 它实现了Map接口，继承了AbstractMap,其中Map接口定义了键映射到值得规则，而AbstractMap类提供了Map接口中主要的实现，是为了最大限度的减少实际开发人员在实现HashMap所需要的工作。

2.2 HashMap的构造函数

HashMap提供了四个构造函数：

HashMap()：构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。

HashMap(int initialCapacity)：构造一个带指定初始容量和默认加载因子 (0.75) 的空 HashMap。

HashMap(int initialCapacity, float loadFactor)：构造一个带指定初始容量和加载因子的空 HashMap。

HashMap(Map<? extends K,? extends V> m) ：构造一个映射关系与指定 Map 相同的新 HashMap。

在这里提到了两个参数：初始容量，加载因子。这两个参数是影响HashMap性能的重要参数，其中容量表示哈希表中桶的数量，初始容量是创建哈希表时的容量，加载因子是哈希表在其容量扩容之前可以达到多满的一种尺度【阀值=加载因子*容量】，加载因子它衡量的是一个散列表的空间的使用程度，加载因子越大表示散列表的装填程度越高，反之愈小。对于使用链表法的散列表来说，查找一个元素的平均时间是O(1+a)，因此如果加载因子越大，对空间的利用更充分，然而后果是查找效率的降低；如果加载因子太小，那么散列表的数据将过于稀疏，对空间造成严重浪费。系统默认加载因子为0.75，一般情况下我们是无需修改的。

HashMap是一种支持快速存取的数据结构，要了解它的性能必须要了解它的数据结构。

2.3 HashMap的数据结构

我们知道在Java中最常用的两种结构是数组和模拟指针(引用)，几乎所有的数据结构都可以利用这两种来组合实现，HashMap也是如此，其底层为数组+链表实现；如果采用数组那么必然就涉及到数组的索引的问题，那么这个索引是什么呢？就是通过key的hashcode计算出来的，采用数组的好处就在于可以快速的访问，可以回忆下List集合中ArrayList.就是典型的底层为数组，所以访问的速度很快，但是如果单纯的采用数组，那么为什么hashmap 又有链表结构呢？这个是因为数组的缺陷是插入元素和删除元素比较慢，而链表具备的就是插入和删除快的特点，因此为了结合这两种特性于是就采用了数组加链表的结构进行。我们看下源码就可以看出：

public HashMap(int initialCapacity, float loadFactor) {//初始容量不能<0if (initialCapacity < 0)throw new IllegalArgumentException("Illegal initial capacity: "+ initialCapacity);//初始容量不能 > 最大容量值，HashMap的最大容量值为2^30if (initialCapacity > MAXIMUM_CAPACITY)initialCapacity = MAXIMUM_CAPACITY;//负载因子不能 < 0if (loadFactor <= 0 || Float.isNaN(loadFactor))throw new IllegalArgumentException("Illegal load factor: "+ loadFactor);// 计算出大于 initialCapacity 的最小的 2 的 n 次方值。int capacity = 1;while (capacity < initialCapacity)capacity <<= 1;this.loadFactor = loadFactor;//设置HashMap的容量极限，当HashMap的容量达到该极限时就会进行扩容操作threshold = (int) (capacity * loadFactor);//初始化table数组table = new Entry[capacity];init();}

从源码中可以看出，每次新建一个HashMap时，都会初始化一个table数组。table数组的元素为Entry节点。

static class Entry<K,V> implements Map.Entry<K,V> {final K key;V value;Entry<K,V> next;final int hash;/*** Creates new entry.*/Entry(int h, K k, V v, Entry<K,V> n) {value = v;next = n;key = k;hash = h;}.......}

其中Entry为HashMap的内部类，它包含了键key、值value、下一个节点next，以及hash值，这是非常重要的，正是由于Entry才构成了table数组的项为链表。

总结：

HashMap的底层主要是基于数组和链表来实现的，它之所以有相当快的查询速度主要是因为它是通过计算散列码来决定存储的位置。HashMap中主要是通过key的hashCode来计算hash值的，只要hashCode相同，计算出来的hash值就一样。如果存储的对象对多了，就有可能不同的对象所算出来的hash值是相同的，这就出现了所谓的hash冲突。学过数据结构的同学都知道，解决hash冲突的方法有很多，HashMap底层是通过链表来解决hash冲突的。

图中，0~15部分即代表哈希表，也称为哈希数组，数组的每个元素都是一个单链表的头节点，链表是用来解决冲突的，如果不同的key映射到了数组的同一位置处，就将其放入单链表中。

从上图我们可以发现哈希表是由数组+链表组成的，一个长度为16的数组中，每个元素存储的是一个链表的头结点Bucket桶。那么这些元素是按照什么样的规则存储到数组中呢。一般情况是通过hash(key)%len获得，也就是元素的key的哈希值对数组长度取模得到。比如上述哈希表中，12%16=12,28%16=12,108%16=12,140%16=12。所以12、28、108以及140都存储在数组下标为12的位置。

HashMap其实也是一个线性的数组实现的,所以可以理解为其存储数据的容器就是一个线性数组。这可能让我们很不解，一个线性的数组怎么实现按键值对来存取数据呢？这里HashMap有做一些处理。

HashMap里面实现一个静态内部类Entry【可以看上面的源码】，其重要的属性有 key , value, next【单链表】，从属性key,value我们就能很明显的看出来Entry就是HashMap键值对实现的一个基础bean，我们上面说到HashMap的基础就是一个线性数组，这个数组就是Entry[]，Map里面的内容都保存在Entry[]里面。即HashMap其实就是一个Entry数组，Entry对象中包含了键和值，其中next也是一个Entry对象，它就是用来处理hash冲突的，形成一个链表。

说明：链表结构中如果存放的数据太多，JDK1.8会使用红黑树存储来提高查找（get）性能.

三、HashMap的源码解析

我们先重点分析HashMap的两个重要方法：put 和 get方法，也是我们最常使用的方法：

public V put(K key, V value) {// 若“key为null”，则将该键值对添加到table[0]中。if (key == null) return putForNullKey(value);// 若“key不为null”，则计算该key的哈希值，然后将其添加到该哈希值对应的链表中。int hash = hash(key.hashCode());//搜索指定hash值在对应table中的索引int i = indexFor(hash, table.length);// 循环遍历Entry数组,若“该key”对应的键值对已经存在，则用新的value取代旧的value。然后退出！for (Entry<K,V> e = table[i]; e != null; e = e.next) { Object k;if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { //如果key相同则覆盖并返回旧值V oldValue = e.value;e.value = value;e.recordAccess(this);return oldValue;}}//修改次数+1modCount++;//将key-value添加到table[i]处
     addEntry(hash, key, value, i);return null;
}

上面程序中用到了一个重要的内部接口：Map.Entry，每个 Map.Entry 其实就是一个 key-value 对。从上面程序中可以看出：当系统决定存储 HashMap 中的 key-value 对时，完全没有考虑 Entry 中的 value，仅仅只是根据 key 来计算并决定每个 Entry 的存储位置。这也说明了前面的结论：我们完全可以把 Map 集合中的 value 当成 key 的附属，当系统决定了 key 的存储位置之后，value 随之保存在那里即可。
我们慢慢的来分析这个函数，第2和3行的作用就是处理key值为null的情况，我们看看putForNullKey(value)方法：

private V putForNullKey(V value) {for (Entry<K,V> e = table[0]; e != null; e = e.next) {if (e.key == null) {   //如果有key为null的对象存在，则覆盖掉V oldValue = e.value;e.value = value;e.recordAccess(this);return oldValue;}}modCount++;addEntry(0, null, value, 0); //如果键为null的话，则hash值为0return null;}

注意：如果key为null的话，hash值为0，对象存储在数组中索引为0的位置。即table[0]

我们再回去看看put方法中第4行，它是通过key的hashCode值计算hash码，下面是计算hash码的函数：

//计算hash值的方法 通过键的hashCode来计算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);}

得到hash码之后就会通过hash码去计算出应该存储在数组中的索引，计算索引的函数如下：

 static int indexFor(int h, int length) { //根据hash值和数组长度算出索引值return h & (length-1);  //这里不能随便算取，用hash&(length-1)是有原因的，这样可以确保算出来的索引是在数组大小范围内，不会超出}

这个我们要重点说下，我们一般对哈希表的散列很自然地会想到用hash值对length取模（即除法散列法），Hashtable中也是这样实现的，这种方法基本能保证元素在哈希表中散列的比较均匀，但取模会用到除法运算，效率很低，HashMap中则通过h&(length-1)的方法来代替取模。

h&(length - 1)，这句话除了上面的取模运算外还有一个非常重要的责任：均匀分布table数据和充分利用空间。

接下来，我们分析下为什么哈希表的容量一定要是2的整数次幂。首先，length为2的整数次幂的话，h&(length-1)就相当于对length取模，这样便保证了散列的均匀，同时也提升了效率；其次，length为2的整数次幂的话，为偶数，这样length-1为奇数，奇数的最后一位是1，这样便保证了h&(length-1)的最后一位可能为0，也可能为1（这取决于h的值），即与后的结果可能为偶数，也可能为奇数，这样便可以保证散列的均匀性，而如果length为奇数的话，很明显length-1为偶数，它的最后一位是0，这样h&(length-1)的最后一位肯定为0，即只能为偶数，这样任何hash值都只会被散列到数组的偶数下标位置上，这便浪费了近一半的空间，因此，length取2的整数次幂，是为了使不同hash值发生碰撞的概率较小，这样就能使元素在哈希表中均匀地散列。

举例：这里我们假设length为16(2^n)和15，h为5、6、7。

当length=15时，6和7的结果一样，这样表示他们在table存储的位置是相同的，也就是产生了碰撞，6、7就会在一个位置形成链表，这样就会导致查询速度降低。诚然这里只分析三个数字不是很多，那么我们就看0-15。

从上面的图表中我们看到总共发生了8此碰撞，同时发现浪费的空间非常大，有1、3、5、7、9、11、13、15处没有记录，也就是没有存放数据。这是因为他们在与14进行&运算时，得到的结果最后一位永远都是0，即0001、0011、0101、0111、1001、1011、1101、1111位置处是不可能存储数据的，空间减少，进一步增加碰撞几率，这样就会导致查询速度慢。而当length = 16时，length – 1 = 15 即1111，那么进行低位&运算时，值总是与原来hash值相同，而进行高位运算时，其值等于其低位值。所以说当length = 2^n时，不同的hash值发生碰撞的概率比较小，这样就会使得数据在table数组中分布较均匀，查询速度也较快。

根据上面 put 方法的源代码可以看出，当程序试图将一个key-value对放入HashMap中时，程序首先根据该 key 的 hashCode() 返回值决定该 Entry 的存储位置：

　　如果两个 Entry 的 key 的 hashCode() 返回值相同，那它们的存储位置相同。
　　如果这两个 Entry 的 key 通过 equals 比较返回 true，新添加 Entry 的 value 将覆盖集合中原有 Entry 的 value，但key不会覆盖。　　
　　如果这两个 Entry 的 key 通过 equals 比较返回 false，新添加的 Entry 将与集合中原有 Entry 形成 Entry 链，而且新添加的 Entry 位于 Entry 链的头部

具体说明继续看 addEntry() 方法的说明。

void addEntry(int hash, K key, V value, int bucketIndex) {Entry<K,V> e = table[bucketIndex]; //如果要加入的位置有值，将该位置原先的值设置为新entry的next,也就是新entry链表的下一个节点table[bucketIndex] = new Entry<>(hash, key, value, e);if (size++ >= threshold) //如果大于临界值就扩容resize(2 * table.length); //以2的倍数扩容}

参数bucketIndex就是indexFor函数计算出来的索引值，第2行代码是取得数组中索引为bucketIndex的Entry对象，第3行就是用hash、key、value构建一个新的Entry对象放到索引为bucketIndex的位置，并且将该位置原先的对象设置为新对象的next构成链表。

第4行和第5行就是判断put后size是否达到了临界值threshold，如果达到了临界值就要进行扩容，HashMap扩容是扩为原来的两倍。

resize()方法如下：

重新调整HashMap的大小，newCapacity是调整后的单位

void resize(int newCapacity) {Entry[] oldTable = table;int oldCapacity = oldTable.length;if (oldCapacity == MAXIMUM_CAPACITY) {threshold = Integer.MAX_VALUE;return;}Entry[] newTable = new Entry[newCapacity];transfer(newTable);//用来将原先table的元素全部移到newTable里面table = newTable;  //再将newTable赋值给tablethreshold = (int)(newCapacity * loadFactor);//重新计算临界值}

新建了一个HashMap的底层数组，上面代码中第10行为调用transfer方法，将HashMap的全部元素添加到新的HashMap中,并重新计算元素在新的数组中的索引位置

当HashMap中的元素越来越多的时候，hash冲突的几率也就越来越高，因为数组的长度是固定的。所以为了提高查询的效率，就要对HashMap的数组进行扩容，数组扩容这个操作也会出现在ArrayList中，这是一个常用的操作，而在HashMap数组扩容之后，最消耗性能的点就出现了：原数组中的数据必须重新计算其在新数组中的位置，并放进去，这就是resize

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

上面讲完了put的方法，接下来我们看下get方法：

public V get(Object key) {   if (key == null)   return getForNullKey();   int hash = hash(key.hashCode());   for (Entry<K,V> e = table[indexFor(hash, table.length)];   e != null;   e = e.next) {   Object k;   if (e.hash == hash && ((k = e.key) == key || key.equals(k)))   return e.value;   }   return null;
}

有了上面存储时的hash算法作为基础，理解起来这段代码就很容易了。从上面的源代码中可以看出：从HashMap中get元素时，首先计算key的hashCode，找到数组中对应位置的某一元素，然后通过key的equals方法在对应位置的链表中找到需要的元素。

归纳起来简单地说，HashMap 在底层将 key-value 当成一个整体进行处理，这个整体就是一个 Entry 对象。HashMap 底层采用一个 Entry[] 数组来保存所有的 key-value 对，当需要存储一个 Entry 对象时，会根据hash算法来决定其在数组中的存储位置，在根据equals方法决定其在该数组位置上的链表中的存储位置；当需要取出一个Entry时，也会根据hash算法找到其在数组中的存储位置，再根据equals方法从该位置上的链表中取出该Entry。

四、HashMap重要知识点

1.性能参数：

HashMap 包含如下几个构造器：
HashMap()：构建一个初始容量为 16，负载因子为 0.75 的 HashMap。
HashMap(int initialCapacity)：构建一个初始容量为 initialCapacity，负载因子为 0.75 的 HashMap。
HashMap(int initialCapacity, float loadFactor)：以指定初始容量、指定的负载因子创建一个 HashMap。
HashMap的基础构造器HashMap(int initialCapacity, float loadFactor)带有两个参数，它们是初始容量initialCapacity和加载因子loadFactor。
initialCapacity：HashMap的最大容量，即为底层数组的长度。
loadFactor：负载因子loadFactor定义为：散列表的实际元素数目(n)/ 散列表的容量(m)。负载因子衡量的是一个散列表的空间的使用程度，负载因子越大表示散列表的装填程度越高，反之愈小。对于使用链表法的散列表来说，查找一个元素的平均时间是O(1+a)，因此如果负载因子越大，对空间的利用更充分，然而后果是查找效率的降低；如果负载因子太小，那么散列表的数据将过于稀疏，对空间造成严重浪费。
HashMap的实现中，通过threshold字段来判断HashMap的最大容量：

threshold = (int)(capacity * loadFactor);

结合负载因子的定义公式可知，threshold就是在此loadFactor和capacity对应下允许的最大元素数目，超过这个数目就重新resize，以降低实际的负载因子。默认的的负载因子0.75是对空间和时间效率的一个平衡选择。当容量超出此最大容量时， resize后的HashMap容量是容量的两倍：

if (size++ >= threshold)      resize(2 * table.length);

2.HashCode的重要性

HashMap中对Key的HashCode要做一次rehash，防止一些糟糕的Hash算法生成的糟糕的HashCode，那么为什么要防止糟糕的HashCode？

糟糕的HashCode意味着的是Hash冲突，即多个不同的Key可能得到的是同一个HashCode，糟糕的Hash算法意味着的就是Hash冲突的概率增大，这意味着HashMap的性能将下降，表现在两方面：

1、有10个Key，可能6个Key的HashCode都相同，另外四个Key所在的Entry均匀分布在table的位置上，而某一个位置上却连接了6个Entry。这就失去了HashMap的意义，HashMap这种数据结构性高性能的前提是，Entry均匀地分布在table位置上，但现在确是1 1 1 1 6的分布。所以，我们要求HashCode有很强的随机性，这样就尽可能地可以保证了Entry分布的随机性，提升了HashMap的效率。

2、HashMap在一个某个table位置上遍历链表的时候的代码：

if (e.hash == hash && ((k = e.key) == key || key.equals(k)))

看到，由于采用了"&&"运算符，因此先比较HashCode，HashCode都不相同就直接pass了，不会再进行equals比较了。HashCode因为是int值，比较速度非常快，而equals方法往往会对比一系列的内容，速度会慢一些。Hash冲突的概率大，意味着equals比较的次数势必增多，必然降低了HashMap的效率了。

3.HashMap的table为什么是transient的

一个非常细节的地方：

transient Entry[] table;

看到table用了transient修饰，也就是说table里面的内容全都不会被序列化，这么写的原因？

因为HashMap是基于HashCode的，HashCode作为Object的方法，是native的：

public native int hashCode();

这意味着的是：HashCode和底层实现相关，不同的虚拟机可能有不同的HashCode算法。再进一步说得明白些就是，可能同一个Key在虚拟机A上的HashCode=1，在虚拟机B上的HashCode=2，在虚拟机C上的HashCode=3。

这就有问题了，Java自诞生以来，就以跨平台性作为最大卖点，好了，如果table不被transient修饰，在虚拟机A上可以用的程序到虚拟机B上可以用的程序就不能用了，失去了跨平台性，因为：

1、Key在虚拟机A上的HashCode=100，连在table[4]上

2、Key在虚拟机B上的HashCode=101，这样，就去table[5]上找Key，明显找不到

整个代码就出问题了。因此，为了避免这一点，Java采取了重写自己序列化table的方法，在writeObject选择将key和value追加到序列化的文件最后面：

private void writeObject(java.io.ObjectOutputStream s)throws IOException
{
Iterator<Map.Entry<K,V>> i =(size > 0) ? entrySet0().iterator() : null;// Write out the threshold, loadfactor, and any hidden stuff
s.defaultWriteObject();// Write out number of buckets
s.writeInt(table.length);// Write out size (number of Mappings)
s.writeInt(size);// Write out keys and values (alternating)
if (i != null) {while (i.hasNext()) {Map.Entry<K,V> e = i.next();s.writeObject(e.getKey());s.writeObject(e.getValue());}}
}

而在readObject的时候重构HashMap数据结构：

private void readObject(java.io.ObjectInputStream s)throws IOException, ClassNotFoundException
{
// Read in the threshold, loadfactor, and any hidden stuff
s.defaultReadObject();// Read in number of buckets and allocate the bucket array;
int numBuckets = s.readInt();
table = new Entry[numBuckets];init();  // Give subclass a chance to do its thing.// Read in size (number of Mappings)
int size = s.readInt();// Read the keys and values, and put the mappings in the HashMap
for (int i=0; i<size; i++) {K key = (K) s.readObject();V value = (V) s.readObject();putForCreate(key, value);
}
}

一种麻烦的方式，但却保证了跨平台性。

这个例子也告诉了我们：尽管使用的虚拟机大多数情况下都是HotSpot，但是也不能对其它虚拟机不管不顾，有跨平台的思想是一件好事。

4.HashMap和Hashtable的区别

HashMap和Hashtable是一组相似的键值对集合，它们的区别也是面试常被问的问题之一，我这里简单总结一下HashMap和Hashtable的区别：

1、Hashtable是线程安全的，Hashtable所有对外提供的方法都使用了synchronized，也就是同步，而HashMap则是线程非安全的

2、Hashtable不允许空的value，空的value将导致空指针异常，而HashMap则无所谓，没有这方面的限制

3、上面两个缺点是最主要的区别，另外一个区别无关紧要，我只是提一下，就是两个的rehash算法不同，Hashtable的是：

private int hash(Object k) {// hashSeed will be zero if alternative hashing is disabled.return hashSeed ^ k.hashCode();
}

这个hashSeed是使用sun.misc.Hashing类的randomHashSeed方法产生的。HashMap的rehash算法上面看过了，也就是：

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);
}

五、自己动手写一个简单的HashMap

我们来动手实现一个简单的hashmap

package study.collection;public class MyMap001
{/*** 定义一个数组来存放所有的key 和 Value 的值,这里先假设数组的大小为很大的一个.实际底层为数组加链表 数组存在扩容的场景* 扩容在前面MyArrayList 中讲过了,所以这里就不重复去做了，因此设置为了990大小.*/MyEntry[]  arr  = new MyEntry[990];/*** 大小*/int size;public void put(Object key,Object value){MyEntry e = new MyEntry(key,value);//解决键值重复的处理for(int i=0;i<size;i++){if(arr[i].key.equals(key)){arr[i].value=value;return ;}}arr[size++] = e;}public Object get(Object key){/*** 遍历寻找*/for(int i=0;i<size;i++){if(arr[i].key.equals(key)){return arr[i].value;}}return null;}/*** 遍历寻找* @param key* @return*/public boolean containsKey(Object key){for(int i=0;i<size;i++){if(arr[i].key.equals(key)){return true;}}return false;}public boolean containsValue(Object value){for(int i=0;i<size;i++){if(arr[i].value.equals(value)){return true;}}return false;}public static void main(String[] args) {MyMap001 m = new MyMap001();m.put("张三", new Wife("杨洋"));m.put("李四", new Wife("王五"));Wife w = (Wife) m.get("张三");System.out.println(w); }}/*** *  Map 中存放的一个key 一个Value**/
class MyEntry {Object key;Object value;public MyEntry(Object key, Object value) {super();this.key = key;this.value = value;}
}

上面的缺陷为：查询效率低，遍历元素的过程。因为所有的元素都存在数组中，采用的数组方式，没有结合链表。

改进；结合链表机制。

package study.collection;import java.util.LinkedList;public class MyMap002
{LinkedList[]  arr  = new LinkedList[9]; //Map的底层结构就是：数组+链表! 暂时不关注扩容int size;public void put(Object key,Object value){MyEntry  e = new MyEntry(key,value);//计算hash值int hash = key.hashCode();//防止存在负数hash = hash<0?-hash:hash;//取模int a = hash%arr.length;if(arr[a]==null){//此索引处没有元素LinkedList list = new LinkedList();list.add(e);arr[a] = list;}else{//如果存在元素，则先取出LinkedList list = arr[a];//遍历此节点上面的链表是否重复元素for(int i=0;i<list.size();i++){MyEntry e2 = (MyEntry) list.get(i);//是否重复if(e2.key.equals(key)){e2.value = value;  //键值重复直接覆盖！return;}}//链表节点上面追加元素
            arr[a].add(e);}//a:1000-->1   b:10000-->13
    }public Object get(Object key){int a = key.hashCode()%arr.length;if(arr[a]!=null){LinkedList list = arr[a];for(int i=0;i<list.size();i++){MyEntry e = (MyEntry) list.get(i);if(e.key.equals(key)){return e.value;}}}return null;}public static void main(String[] args) {MyMap002 m = new MyMap002();m.put("张三", new Wife("杨洋"));m.put("李四", new Wife("王五"));Wife w = (Wife) m.get("张三");System.out.println(w); }
}

上面是一个简单的实现优化，也只是实现了最基本的功能，但重点在于理解原理和hashmap的原理

六、HashMap源码注释

package java.util;
import java.io.*;  public class HashMap<K,V>  extends AbstractMap<K,V>  implements Map<K,V>, Cloneable, Serializable
{  // 默认的初始容量（容量为HashMap中槽的数目）是16，且实际容量必须是2的整数次幂。  static final int DEFAULT_INITIAL_CAPACITY = 16;  // 最大容量（必须是2的幂且小于2的30次方，传入容量过大将被这个值替换）  static final int MAXIMUM_CAPACITY = 1 << 30;  // 默认加载因子为0.75 static final float DEFAULT_LOAD_FACTOR = 0.75f;  // 存储数据的Entry数组，长度是2的幂。  // HashMap采用链表法解决冲突，每一个Entry本质上是一个单向链表  transient Entry[] table;  // HashMap的底层数组中已用槽的数量  transient int size;  // HashMap的阈值，用于判断是否需要调整HashMap的容量（threshold = 容量*加载因子）  int threshold;  // 加载因子实际大小  final float loadFactor;  // HashMap被改变的次数  transient volatile int modCount;  // 指定“容量大小”和“加载因子”的构造函数  public HashMap(int initialCapacity, float loadFactor) {  if (initialCapacity < 0)  throw new IllegalArgumentException("Illegal initial capacity: " +  initialCapacity);  // HashMap的最大容量只能是MAXIMUM_CAPACITY  if (initialCapacity > MAXIMUM_CAPACITY)  initialCapacity = MAXIMUM_CAPACITY;  //加载因此不能小于0if (loadFactor <= 0 || Float.isNaN(loadFactor))  throw new IllegalArgumentException("Illegal load factor: " +  loadFactor);  // 找出“大于initialCapacity”的最小的2的幂  int capacity = 1;  while (capacity < initialCapacity)  capacity <<= 1;  // 设置“加载因子”  this.loadFactor = loadFactor;  // 设置“HashMap阈值”，当HashMap中存储数据的数量达到threshold时，就需要将HashMap的容量加倍。  threshold = (int)(capacity * loadFactor);  // 创建Entry数组，用来保存数据  table = new Entry[capacity];  init();  }  // 指定“容量大小”的构造函数  public HashMap(int initialCapacity) {  this(initialCapacity, DEFAULT_LOAD_FACTOR);  }  // 默认构造函数。  public HashMap() {  // 设置“加载因子”为默认加载因子0.75  this.loadFactor = DEFAULT_LOAD_FACTOR;  // 设置“HashMap阈值”，当HashMap中存储数据的数量达到threshold时，就需要将HashMap的容量加倍。  threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);  // 创建Entry数组，用来保存数据  table = new Entry[DEFAULT_INITIAL_CAPACITY];  init();  }  // 包含“子Map”的构造函数  public HashMap(Map<? extends K, ? extends V> m) {  this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,  DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);  // 将m中的全部元素逐个添加到HashMap中
        putAllForCreate(m);  }  //求hash值的方法，重新计算hash值static int hash(int h) {  h ^= (h >>> 20) ^ (h >>> 12);  return h ^ (h >>> 7) ^ (h >>> 4);  }  // 返回h在数组中的索引值，这里用&代替取模，旨在提升效率 // h & (length-1)保证返回值的小于length  static int indexFor(int h, int length) {  return h & (length-1);  }  public int size() {  return size;  }  public boolean isEmpty() {  return size == 0;  }  // 获取key对应的value  public V get(Object key) {  if (key == null)  return getForNullKey();  // 获取key的hash值  int hash = hash(key.hashCode());  // 在“该hash值对应的链表”上查找“键值等于key”的元素  for (Entry<K,V> e = table[indexFor(hash, table.length)];  e != null;  e = e.next) {  Object k;  //判断key是否相同if (e.hash == hash && ((k = e.key) == key || key.equals(k)))  return e.value;  }//没找到则返回nullreturn null;  }  // 获取“key为null”的元素的值  // HashMap将“key为null”的元素存储在table[0]位置，但不一定是该链表的第一个位置！  private V getForNullKey() {  for (Entry<K,V> e = table[0]; e != null; e = e.next) {  if (e.key == null)  return e.value;  }  return null;  }  // HashMap是否包含key  public boolean containsKey(Object key) {  return getEntry(key) != null;  }  // 返回“键为key”的键值对  final Entry<K,V> getEntry(Object key) {  // 获取哈希值  // HashMap将“key为null”的元素存储在table[0]位置，“key不为null”的则调用hash()计算哈希值  int hash = (key == null) ? 0 : hash(key.hashCode());  // 在“该hash值对应的链表”上查找“键值等于key”的元素  for (Entry<K,V> e = table[indexFor(hash, table.length)];  e != null;  e = e.next) {  Object k;  if (e.hash == hash &&  ((k = e.key) == key || (key != null && key.equals(k))))  return e;  }  return null;  }  // 将“key-value”添加到HashMap中  public V put(K key, V value) {  // 若“key为null”，则将该键值对添加到table[0]中。  if (key == null)  return putForNullKey(value);  // 若“key不为null”，则计算该key的哈希值，然后将其添加到该哈希值对应的链表中。  int hash = hash(key.hashCode());  int i = indexFor(hash, table.length);  for (Entry<K,V> e = table[i]; e != null; e = e.next) {  Object k;  // 若“该key”对应的键值对已经存在，则用新的value取代旧的value。然后退出！  if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {  V oldValue = e.value;  e.value = value;  e.recordAccess(this);  return oldValue;  }  }  // 若“该key”对应的键值对不存在，则将“key-value”添加到table中  modCount++;//将key-value添加到table[i]处
        addEntry(hash, key, value, i);  return null;  }  // putForNullKey()的作用是将“key为null”键值对添加到table[0]位置  private V putForNullKey(V value) {  for (Entry<K,V> e = table[0]; e != null; e = e.next) {  if (e.key == null) {  V oldValue = e.value;  e.value = value;  e.recordAccess(this);  return oldValue;  }  }  // 如果没有存在key为null的键值对，则直接题阿见到table[0]处!  modCount++;  addEntry(0, null, value, 0);  return null;  }  // 创建HashMap对应的“添加方法”，  // 它和put()不同。putForCreate()是内部方法，它被构造函数等调用，用来创建HashMap  // 而put()是对外提供的往HashMap中添加元素的方法。  private void putForCreate(K key, V value) {  int hash = (key == null) ? 0 : hash(key.hashCode());  int i = indexFor(hash, table.length);  // 若该HashMap表中存在“键值等于key”的元素，则替换该元素的value值  for (Entry<K,V> e = table[i]; e != null; e = e.next) {  Object k;  if (e.hash == hash &&  ((k = e.key) == key || (key != null && key.equals(k)))) {  e.value = value;  return;  }  }  // 若该HashMap表中不存在“键值等于key”的元素，则将该key-value添加到HashMap中
        createEntry(hash, key, value, i);  }  // 将“m”中的全部元素都添加到HashMap中。  // 该方法被内部的构造HashMap的方法所调用。  private void putAllForCreate(Map<? extends K, ? extends V> m) {  // 利用迭代器将元素逐个添加到HashMap中  for (Iterator<? extends Map.Entry<? extends K, ? extends V>> i = m.entrySet().iterator(); i.hasNext(); ) {  Map.Entry<? extends K, ? extends V> e = i.next();  putForCreate(e.getKey(), e.getValue());  }  }  // 重新调整HashMap的大小，newCapacity是调整后的容量  void resize(int newCapacity) {  Entry[] oldTable = table;  int oldCapacity = oldTable.length; //如果就容量已经达到了最大值，则不能再扩容，直接返回if (oldCapacity == MAXIMUM_CAPACITY) {  threshold = Integer.MAX_VALUE;  return;  }  // 新建一个HashMap，将“旧HashMap”的全部元素添加到“新HashMap”中，  // 然后，将“新HashMap”赋值给“旧HashMap”。  Entry[] newTable = new Entry[newCapacity];  transfer(newTable);  table = newTable;  threshold = (int)(newCapacity * loadFactor);  }  // 将HashMap中的全部元素都添加到newTable中  void transfer(Entry[] newTable) {  Entry[] src = table;  int newCapacity = newTable.length;  for (int j = 0; j < src.length; j++) {  Entry<K,V> e = src[j];  if (e != null) {  src[j] = null;  do {  Entry<K,V> next = e.next;  int i = indexFor(e.hash, newCapacity);  e.next = newTable[i];  newTable[i] = e;  e = next;  } while (e != null);  }  }  }  // 将"m"的全部元素都添加到HashMap中  public void putAll(Map<? extends K, ? extends V> m) {  // 有效性判断  int numKeysToBeAdded = m.size();  if (numKeysToBeAdded == 0)  return;  // 计算容量是否足够，  // 若“当前阀值容量 < 需要的容量”，则将容量x2。  if (numKeysToBeAdded > threshold) {  int targetCapacity = (int)(numKeysToBeAdded / loadFactor + 1);  if (targetCapacity > MAXIMUM_CAPACITY)  targetCapacity = MAXIMUM_CAPACITY;  int newCapacity = table.length;  while (newCapacity < targetCapacity)  newCapacity <<= 1;  if (newCapacity > table.length)  resize(newCapacity);  }  // 通过迭代器，将“m”中的元素逐个添加到HashMap中。  for (Iterator<? extends Map.Entry<? extends K, ? extends V>> i = m.entrySet().iterator(); i.hasNext(); ) {  Map.Entry<? extends K, ? extends V> e = i.next();  put(e.getKey(), e.getValue());  }  }  // 删除“键为key”元素  public V remove(Object key) {  Entry<K,V> e = removeEntryForKey(key);  return (e == null ? null : e.value);  }  // 删除“键为key”的元素  final Entry<K,V> removeEntryForKey(Object key) {  // 获取哈希值。若key为null，则哈希值为0；否则调用hash()进行计算  int hash = (key == null) ? 0 : hash(key.hashCode());  int i = indexFor(hash, table.length);  Entry<K,V> prev = table[i];  Entry<K,V> e = prev;  // 删除链表中“键为key”的元素  // 本质是“删除单向链表中的节点”  while (e != null) {  Entry<K,V> next = e.next;  Object k;  if (e.hash == hash &&  ((k = e.key) == key || (key != null && key.equals(k)))) {  modCount++;  size--;  if (prev == e)  table[i] = next;  else prev.next = next;  e.recordRemoval(this);  return e;  }  prev = e;  e = next;  }  return e;  }  // 删除“键值对”  final Entry<K,V> removeMapping(Object o) {  if (!(o instanceof Map.Entry))  return null;  Map.Entry<K,V> entry = (Map.Entry<K,V>) o;  Object key = entry.getKey();  int hash = (key == null) ? 0 : hash(key.hashCode());  int i = indexFor(hash, table.length);  Entry<K,V> prev = table[i];  Entry<K,V> e = prev;  // 删除链表中的“键值对e”  // 本质是“删除单向链表中的节点”  while (e != null) {  Entry<K,V> next = e.next;  if (e.hash == hash && e.equals(entry)) {  modCount++;  size--;  if (prev == e)  table[i] = next;  else prev.next = next;  e.recordRemoval(this);  return e;  }  prev = e;  e = next;  }  return e;  }  // 清空HashMap，将所有的元素设为null  public void clear() {  modCount++;  Entry[] tab = table;  for (int i = 0; i < tab.length; i++)  tab[i] = null;  size = 0;  }  // 是否包含“值为value”的元素  public boolean containsValue(Object value) {  // 若“value为null”，则调用containsNullValue()查找  if (value == null)  return containsNullValue();  // 若“value不为null”，则查找HashMap中是否有值为value的节点。  Entry[] tab = table;  for (int i = 0; i < tab.length ; i++)  for (Entry e = tab[i] ; e != null ; e = e.next)  if (value.equals(e.value))  return true;  return false;  }  // 是否包含null值  private boolean containsNullValue() {  Entry[] tab = table;  for (int i = 0; i < tab.length ; i++)  for (Entry e = tab[i] ; e != null ; e = e.next)  if (e.value == null)  return true;  return false;  }  // 克隆一个HashMap，并返回Object对象  public Object clone() {  HashMap<K,V> result = null;  try {  result = (HashMap<K,V>)super.clone();  } catch (CloneNotSupportedException e) {  // assert false;
        }  result.table = new Entry[table.length];  result.entrySet = null;  result.modCount = 0;  result.size = 0;  result.init();  // 调用putAllForCreate()将全部元素添加到HashMap中  result.putAllForCreate(this);  return result;  }  // Entry是单向链表。  // 它是 “HashMap链式存储法”对应的链表。  // 它实现了Map.Entry 接口，即实现getKey(), getValue(), setValue(V value), equals(Object o), hashCode()这些函数  static class Entry<K,V> implements Map.Entry<K,V> {  final K key;  V value;  // 指向下一个节点  Entry<K,V> next;  final int hash;  // 构造函数。  // 输入参数包括"哈希值(h)", "键(k)", "值(v)", "下一节点(n)"  Entry(int h, K k, V v, Entry<K,V> n) {  value = v;  next = n;  key = k;  hash = h;  }  public final K getKey() {  return key;  }  public final V getValue() {  return value;  }  public final V setValue(V newValue) {  V oldValue = value;  value = newValue;  return oldValue;  }  // 判断两个Entry是否相等  // 若两个Entry的“key”和“value”都相等，则返回true。  // 否则，返回false  public final boolean equals(Object o) {  if (!(o instanceof Map.Entry))  return false;  Map.Entry e = (Map.Entry)o;  Object k1 = getKey();  Object k2 = e.getKey();  if (k1 == k2 || (k1 != null && k1.equals(k2))) {  Object v1 = getValue();  Object v2 = e.getValue();  if (v1 == v2 || (v1 != null && v1.equals(v2)))  return true;  }  return false;  }  // 实现hashCode()  public final int hashCode() {  return (key==null   ? 0 : key.hashCode()) ^  (value==null ? 0 : value.hashCode());  }  public final String toString() {  return getKey() + "=" + getValue();  }  // 当向HashMap中添加元素时，绘调用recordAccess()。  // 这里不做任何处理  void recordAccess(HashMap<K,V> m) {  }  // 当从HashMap中删除元素时，绘调用recordRemoval()。  // 这里不做任何处理  void recordRemoval(HashMap<K,V> m) {  }  }  // 新增Entry。将“key-value”插入指定位置，bucketIndex是位置索引。  void addEntry(int hash, K key, V value, int bucketIndex) {  // 保存“bucketIndex”位置的值到“e”中  Entry<K,V> e = table[bucketIndex];  // 设置“bucketIndex”位置的元素为“新Entry”，  // 设置“e”为“新Entry的下一个节点”  table[bucketIndex] = new Entry<K,V>(hash, key, value, e);  // 若HashMap的实际大小 不小于 “阈值”，则调整HashMap的大小  if (size++ >= threshold)  resize(2 * table.length);  }  // 创建Entry。将“key-value”插入指定位置。  void createEntry(int hash, K key, V value, int bucketIndex) {  // 保存“bucketIndex”位置的值到“e”中  Entry<K,V> e = table[bucketIndex];  // 设置“bucketIndex”位置的元素为“新Entry”，  // 设置“e”为“新Entry的下一个节点”  table[bucketIndex] = new Entry<K,V>(hash, key, value, e);  size++;  }  // HashIterator是HashMap迭代器的抽象出来的父类，实现了公共了函数。  // 它包含“key迭代器(KeyIterator)”、“Value迭代器(ValueIterator)”和“Entry迭代器(EntryIterator)”3个子类。  private abstract class HashIterator<E> implements Iterator<E> {  // 下一个元素  Entry<K,V> next;  // expectedModCount用于实现fast-fail机制。  int expectedModCount;  // 当前索引  int index;  // 当前元素  Entry<K,V> current;  HashIterator() {  expectedModCount = modCount;  if (size > 0) { // advance to first entry  Entry[] t = table;  // 将next指向table中第一个不为null的元素。  // 这里利用了index的初始值为0，从0开始依次向后遍历，直到找到不为null的元素就退出循环。  while (index < t.length && (next = t[index++]) == null)  ;  }  }  public final boolean hasNext() {  return next != null;  }  // 获取下一个元素  final Entry<K,V> nextEntry() {  if (modCount != expectedModCount)  throw new ConcurrentModificationException();  Entry<K,V> e = next;  if (e == null)  throw new NoSuchElementException();  // 注意！！！  // 一个Entry就是一个单向链表  // 若该Entry的下一个节点不为空，就将next指向下一个节点;  // 否则，将next指向下一个链表(也是下一个Entry)的不为null的节点。  if ((next = e.next) == null) {  Entry[] t = table;  while (index < t.length && (next = t[index++]) == null)  ;  }  current = e;  return e;  }  // 删除当前元素  public void remove() {  if (current == null)  throw new IllegalStateException();  if (modCount != expectedModCount)  throw new ConcurrentModificationException();  Object k = current.key;  current = null;  HashMap.this.removeEntryForKey(k);  expectedModCount = modCount;  }  }  // value的迭代器  private final class ValueIterator extends HashIterator<V> {  public V next() {  return nextEntry().value;  }  }  // key的迭代器  private final class KeyIterator extends HashIterator<K> {  public K next() {  return nextEntry().getKey();  }  }  // Entry的迭代器  private final class EntryIterator extends HashIterator<Map.Entry<K,V>> {  public Map.Entry<K,V> next() {  return nextEntry();  }  }  // 返回一个“key迭代器”  Iterator<K> newKeyIterator()   {  return new KeyIterator();  }  // 返回一个“value迭代器”  Iterator<V> newValueIterator()   {  return new ValueIterator();  }  // 返回一个“entry迭代器”  Iterator<Map.Entry<K,V>> newEntryIterator()   {  return new EntryIterator();  }  // HashMap的Entry对应的集合  private transient Set<Map.Entry<K,V>> entrySet = null;  // 返回“key的集合”，实际上返回一个“KeySet对象”  public Set<K> keySet() {  Set<K> ks = keySet;  return (ks != null ? ks : (keySet = new KeySet()));  }  // Key对应的集合  // KeySet继承于AbstractSet，说明该集合中没有重复的Key。  private final class KeySet extends AbstractSet<K> {  public Iterator<K> iterator() {  return newKeyIterator();  }  public int size() {  return size;  }  public boolean contains(Object o) {  return containsKey(o);  }  public boolean remove(Object o) {  return HashMap.this.removeEntryForKey(o) != null;  }  public void clear() {  HashMap.this.clear();  }  }  // 返回“value集合”，实际上返回的是一个Values对象  public Collection<V> values() {  Collection<V> vs = values;  return (vs != null ? vs : (values = new Values()));  }  // “value集合”  // Values继承于AbstractCollection，不同于“KeySet继承于AbstractSet”，  // Values中的元素能够重复。因为不同的key可以指向相同的value。  private final class Values extends AbstractCollection<V> {  public Iterator<V> iterator() {  return newValueIterator();  }  public int size() {  return size;  }  public boolean contains(Object o) {  return containsValue(o);  }  public void clear() {  HashMap.this.clear();  }  }  // 返回“HashMap的Entry集合”  public Set<Map.Entry<K,V>> entrySet() {  return entrySet0();  }  // 返回“HashMap的Entry集合”，它实际是返回一个EntrySet对象  private Set<Map.Entry<K,V>> entrySet0() {  Set<Map.Entry<K,V>> es = entrySet;  return es != null ? es : (entrySet = new EntrySet());  }  // EntrySet对应的集合  // EntrySet继承于AbstractSet，说明该集合中没有重复的EntrySet。  private final class EntrySet extends AbstractSet<Map.Entry<K,V>> {  public Iterator<Map.Entry<K,V>> iterator() {  return newEntryIterator();  }  public boolean contains(Object o) {  if (!(o instanceof Map.Entry))  return false;  Map.Entry<K,V> e = (Map.Entry<K,V>) o;  Entry<K,V> candidate = getEntry(e.getKey());  return candidate != null && candidate.equals(e);  }  public boolean remove(Object o) {  return removeMapping(o) != null;  }  public int size() {  return size;  }  public void clear() {  HashMap.this.clear();  }  }  // java.io.Serializable的写入函数  // 将HashMap的“总的容量，实际容量，所有的Entry”都写入到输出流中  private void writeObject(java.io.ObjectOutputStream s)  throws IOException  {  Iterator<Map.Entry<K,V>> i =  (size > 0) ? entrySet0().iterator() : null;  // Write out the threshold, loadfactor, and any hidden stuff
        s.defaultWriteObject();  // Write out number of buckets
        s.writeInt(table.length);  // Write out size (number of Mappings)
        s.writeInt(size);  // Write out keys and values (alternating)  if (i != null) {  while (i.hasNext()) {  Map.Entry<K,V> e = i.next();  s.writeObject(e.getKey());  s.writeObject(e.getValue());  }  }  }  private static final long serialVersionUID = 362498820763181265L;  // java.io.Serializable的读取函数：根据写入方式读出  // 将HashMap的“总的容量，实际容量，所有的Entry”依次读出  private void readObject(java.io.ObjectInputStream s)  throws IOException, ClassNotFoundException  {  // Read in the threshold, loadfactor, and any hidden stuff
        s.defaultReadObject();  // Read in number of buckets and allocate the bucket array;  int numBuckets = s.readInt();  table = new Entry[numBuckets];  init();  // Give subclass a chance to do its thing.  // Read in size (number of Mappings)  int size = s.readInt();  // Read the keys and values, and put the mappings in the HashMap  for (int i=0; i<size; i++) {  K key = (K) s.readObject();  V value = (V) s.readObject();  putForCreate(key, value);  }  }  // 返回“HashMap总的容量”  int   capacity()     { return table.length; }  // 返回“HashMap的加载因子”  float loadFactor()   { return loadFactor;   }
}

参考资料：

http://www.cnblogs.com/ITtangtang/p/3948406.html
http://blog.csdn.net/ns_code/article/details/36034955
http://www.cnblogs.com/xrq730/p/5030920.html
http://blog.csdn.net/chenssy

转载于:https://www.cnblogs.com/pony1223/p/7795882.html

JAVA提高十二：HashMap深入分析相关推荐

【转】java提高篇(二)-----理解java的三大特性之继承
[转]java提高篇(二)-----理解java的三大特性之继承原文地址:http://www.cnblogs.com/chenssy/p/3354884.html 在<Think in ja ...
吃透这JAVA并发十二核心，面试官都得对你刮目相看
1.HashMap 面试第一题必问的 HashMap,挺考验Javaer的基础功底的,别问为啥放在这,因为重要!HashMap具有如下特性: HashMap 的存取是没有顺序的. KV 均允许为 NU ...
JAVA并发十二连招
1.HashMap 面试第一题必问的 HashMap,挺考验Javaer的基础功底的,别问为啥放在这,因为重要!HashMap具有如下特性: HashMap 的存取是没有顺序的. KV 均允许为 NU ...
java list 在头部添加6_【Java提高十六】集合List接口详解
在编写java程序中,我们最常用的除了八种基本数据类型,String对象外还有一个集合类,在我们的的程序中到处充斥着集合类的身影!java中集合大家族的成员实在是太丰富了,有常用的ArrayList. ...
c++二进制文件java读取int_吃透Java基础十二：IO
一.什么是IO流 Java中将输入输出抽象称为流,就好像水管,将两个容器连接起来.流是一组有顺序的,有起点和终点的字节集合,是对数据传输的总称或抽象.即数据在两设备间的传输称为流. 按数据来源(去向) ...
教妹学Java(三十二)：了解 Java 中的返回类型协变
你好呀,我是沉默王二,(目前是)CSDN 周排名前十的博客专家.这是<教妹学 Java>专栏的第二十七篇,今天我们来谈谈 Java 中的返回类型协变--Java 的返回值类型支持协变.换句 ...
java selenium (十二) 操作弹出窗口
selenium 中如何处理弹出窗口阅读目录原理在代码里, 通过 Set<String> allWindowsId = driver.getWindowHandles ...
同步练习(Java SE(十二))
案例一: Lambda表达式练习1 需求: 定义一个接口(Eatable),里面定义一个抽象方法: void eat(); 定义一个测试类(EatableDemo),在测试类中提供两个方法一个方法是 ...
java做一个mud_菜鸟学Java（十二）——搭建一个完整的Java开发环境
作为一个Java程序员,配置一个java开发环境是必备的技能,今天给广大菜鸟初学者补上一课.环境的配置,大概就分三个1,JDK 2,Tomcat(或者其他的)3,eclipse(或者myeclipse ...

JAVA提高十二：HashMap深入分析

JAVA提高十二：HashMap深入分析相关推荐

最新文章

热门文章