这篇文章将为大家详细讲解有关Java中HashMap的实现原理是什么，文章内容质量较高，因此小编分享给大家做个参考，希望大家阅读完这篇文章后对相关知识有一定的了解。
创新互联公司主要从事做网站、成都做网站、网页设计、企业做网站、公司建网站等业务。立足成都服务隆回,10年网站建设经验,价格优惠、服务专业,欢迎来电咨询建站服务:18982081108
一、Java中的HashCode 和equals
1、hashcode的存在主要是用于查找的快捷性，如Hashtable,HashMap等，hashCode是用来在散列存储结构中确定对象的存储地址的。
2、如果两个对象相同，就是适用于equals（java.lang.Object)方法，那么这个两个对象的hashCode一定要相同。
3、如果对象的equals方法被重写，那么对象的hashCode也尽量重写，并且产生hashCode使用的对象，一定要和equals方法中使用的一致，否则就会违反上面提到的第二点
4、两个对象的hashCode相同，并不一定表示两个对象就相同，也就是不一定适用于equals（java.lang.Object)方法，只能够说明这两个对象在散列存储结构中，如Hashtable.他们存放在同一个篮子里
hashCode 用于查找使用的，equals是用于比较两个对象是否相等。
1、equals 和 ==
==用于比较引用和比较基本数据类型时具有不同的功能：
比较基本数据类型，如果两个值相同，则结果为true
而在比较引用时，如果引用指向内存中的同一对象，结果为true；
equals()作为方法，实现对象的比较。由于==运算符不允许我们进行覆盖，也就是说它限制了我们的表达。因此我们复写（重写，子类复写）equals方法，达到比较对象内容是否相同的目的。而这些通过==运算符是做不到的。
2、Object类的equals（）方法的比较规则为：如果两个对象的类型一致，并且内容一致，则返回true，这些类有：
java.io.file,java.util.Date,java.lang.string,包装类（Integer，Double等）
二、HashMap的实现原理
1、HashMap概述
HashMap是基于哈希表的Map接口的非同步实现。此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。
在Java编程语言中，最基本的结构就是两种，一种是数组，另一个是模拟指针（引用），所有的数据结构都可以用这两个基本结构来构造，HashMap也不列外。HashMap也不例外。HashMap实际上是一个链表散列的数据结构，即数组和链表的结合体。
从上图中可以看出，HashMap底层就是一个数组结构，数组中的每一项又是一个链表。当新建一个HashMap的时候，就会初始化一个数组。
/**
* Basic hash bin node, used for most entries. (See below for
* TreeNode subclass, and in LinkedHashMap for its Entry subclass.)
*/
static class Node implements Map.Entry {
final int hash;
final K key;
V value;
Node next;
Node(int hash, K key, V value, Node next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
public final K getKey() { return key; }
public final V getValue() { return value; }
public final String toString() { return key + "=">可以看出，Node就是数组中的元素，每个 Map.Entry 其实就是一个key-value对，它持有一个指向下一个元素的引用，这就构成了链表 2、HashMap实现存储和读取1）存储/**
* Associates the specified value with the specified key in this map.
* If the map previously contained a mapping for the key, the old
* value is replaced.
*
* @param key key with which the specified value is to be associated
* @param value value to be associated with the specified key
* @return the previous value associated with key, or
* null if there was no mapping for key.
* (A null return can also indicate that the map
* previously associated null with key.)
*/
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
/**
* Implements Map.put and related methods
*
* @param hash hash for key
* @param key the key
* @param value the value to put
* @param onlyIfAbsent if true, don't change existing value
* @param evict if false, the table is in creation mode.
* @return previous value, or null if none
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node[] tab; Node p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode)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
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
} 根据hash值得到这个元素在数组中的位置（即下标），如果数组该位置上已经存放有其他元素了，那么在这个位置上的元素将以链表的形式存放，新加入的放在链头，最先加入的放在链尾。如果数组该位置上没有元素，就直接将该元素放到此数组中的该位置上。/**
* Computes key.hashCode() and spreads (XORs) higher bits of hash
* to lower. Because the table uses power-of-two masking, sets of
* hashes that vary only in bits above the current mask will
* always collide. (Among known examples are sets of Float keys
* holding consecutive whole numbers in small tables.) So we
* apply a transform that spreads the impact of higher bits
* downward. There is a tradeoff between speed, utility, and
* quality of bit-spreading. Because many common sets of hashes
* are already reasonably distributed (so don't benefit from
* spreading), and because we use trees to handle large sets of
* collisions in bins, we just XOR some shifted bits in the
* cheapest possible way to reduce systematic lossage, as well as
* to incorporate impact of the highest bits that would otherwise
* never be used in index calculations because of table bounds.
*/
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
} 我们可以看到在hashMap中要找到某个元素，需要根据key的hash值来求得对应数组中的位置。如何计算这个位置就是hash算法。前面的说过HashMap的数据结构是数组和链表的结合，所以我们希望这个HashMap里面的元素位置尽量的分布均匀些。尽量使得每个位置上的元素数量只有一个，那么当我们用hash算法求得这个位置时，马上就可以知道对应位置的元素都是我们要的，而不用再去遍历链表，这就大大优化了查询效率。HashMap 在底层将 key-value 当成一个整体进行处理，这个整体就是一个 Node 对象。HashMap 底层采用一个 Node[] 数组来保存所有的 key-value 对，当需要存储一个 Node 对象时，会根据hash算法来决定其在数组中的存储位置，在根据equals方法决定其在该数组位置上的链表中的存储位置；当需要取出一个Entry时，也会根据hash算法找到其在数组中的存储位置，再根据equals方法从该位置上的链表中取出该Node。3、HashMap的resize 当hashmap的元素越来越多的时候，碰撞的概率就越来越高（因为数组的长度是固定的），所以为了提高查询的效率，就要对hashMap的数组进行扩容，数组扩容这个操作也会出现在ArrayList中，所以这是一个通用的操作，类似均摊。hashmap扩容之后，最消耗性能的点就出现了：原数组中的数据必须重新计算其在新数组中的位置，并放进去，就是resize。 那么hashmap什么时候扩容？当hashmap中的元素个数超过数组大小*loadFactor时，就会进行数组扩容，loadFactor的默认值为0.75，也就是说，默认情况下，数组大小为16，那么当hashmap中元素个数超过16*0.75=12的时候，就把数组的大小扩展为2*16=32，即扩大一倍，然后重新计算每个元素在新数组中的位置，放进去，就是resize。总结：HashMap的实现原理： 1、实现key的hashCode重新hash计算出当前对象的元素在数组中的下标。 2、存储时，如果出现hash值相同的key,此时有两种情况。（1）如果key相同，则覆盖原始值；（2）如果key不同（出现冲突），则将当前的key-value放入链表中 3、获取时，直接找hash值对应的下标，在进一步判断key是否相同，从而找到对应值。 4、理解以上过程就不难明白HashMap是如何解决hash冲突的问题，核心就是使用了数组的存储方式，然后将冲突的key的对象放入链表中，一旦发现冲突就在链表中做进一步的对比。
关于Java中HashMap的实现原理是什么就分享到这里了，希望以上内容可以对大家有一定的帮助，可以学到更多知识。如果觉得文章不错，可以把它分享出去让更多的人看到。
网站名称：Java中HashMap的实现原理是什么
URL分享：
http://njwzjz.com/article/peodch.html
