java引用hash map需要引入什么？求java里面的Hash<Map>的用法和基本解释,谢谢
大家好,今天小编来为大家解答以下的问题，关于java引用hash map需要引入什么，求java里面的Hash<Map>的用法和基本解释,谢谢这个很多人还不知道，现在让我们一起来看看吧！
Java中的HashMap的工作原理是什么
一，存储方式： Java中的HashMap是以键值对(key-value)的形式存储元素的。
二，调用原理： HashMap需要一个hash函数，它使用hashCode()和equals()方法来向集合/从集合添加和检索元素。当调用put()方法的时候，HashMap会计算key的hash值，然后把键值对存储在集合中合适的索引上。如果key已经存在了，value会被更新成新值。
三，其他热性： HashMap的一些重要的特性是它的容量(capacity)，负载因子(load factor)和扩容极限(threshold resizing)。
java 为什么使用hashmap
首先当我们需要存储数据的时候，动态数组虽然能够自动扩容，但是必须在初始时刻指定初始容量。而对于那些在编译时无法确定具体的数量即动态增长的数据，就需要用到Java集合类了。对于ArrayList和 LinkedList，还有 Vector它们都有一些缺点，要么插入删除速度慢、要么就是遍历速度慢。那么有没有一种插入、删除、遍历都比较不错的集合类呢？于是 HashMap就出现了。HashMap是一个散列表，它存储的是一组键值对(key-value)的集合，并实现快速的查找。
（1）为了实现快速查找，HashMap选择了数组而不是链表。以利用数组的索引实现 O(1)复杂度的查找效率。
（2）为了利用索引查找，HashMap引入 Hash算法,将 key映射成数组下标: key-> Index。
（3）引入 Hash算法又导致了 Hash冲突。为了解决 Hash冲突，HashMap采用链地址法，在冲突位置转为使用链表存储。
（4）链表存储过多的节点又导致了在链表上节点的查找性能的恶化。为了优化查找性能，HashMap在链表长度超过 8之后转而将链表转变成红黑树，以将 O(n)复杂度的查找效率提升至 O(log n)。
【综上】
HashMap存在的意义就是实现一种快速的查找并且插入、删除性能都不错的一种 K/V（key/value）数据结构。
附上一位博主的高见：网页链接
求java里面的Hash<Map>的用法和基本解释,谢谢
HashMap和 HashSet是 Java Collection Framework的两个重要成员，其中 HashMap是 Map接口的常用实现类，HashSet是 Set接口的常用实现类。虽然 HashMap和 HashSet实现的接口规范不同，但它们底层的 Hash存储机制完全一样，甚至 HashSet本身就采用 HashMap来实现的。
通过 HashMap、HashSet的源代码分析其 Hash存储机制
实际上，HashSet和 HashMap之间有很多相似之处，对于 HashSet而言，系统采用 Hash算法决定集合元素的存储位置，这样可以保证能快速存、取集合元素；对于 HashMap而言，系统 key-value当成一个整体进行处理，系统总是根据 Hash算法来计算 key-value的存储位置，这样可以保证能快速存、取 Map的 key-value对。
在介绍集合存储之前需要指出一点：虽然集合号称存储的是 Java对象，但实际上并不会真正将 Java对象放入 Set集合中，只是在 Set集合中保留这些对象的引用而言。也就是说：Java集合实际上是多个引用变量所组成的集合，这些引用变量指向实际的 Java对象。
集合和引用
就像引用类型的数组一样，当我们把 Java对象放入数组之时，并不是真正的把 Java对象放入数组中，只是把对象的引用放入数组中，每个数组元素都是一个引用变量。
HashMap的存储实现
当程序试图将多个 key-value放入 HashMap中时，以如下代码片段为例：
Java代码
HashMap<String, Double> map= new HashMap<String, Double>();
map.put("语文", 80.0);
map.put("数学", 89.0);
map.put("英语", 78.2);
HashMap采用一种所谓的“Hash算法”来决定每个元素的存储位置。
当程序执行 map.put("语文", 80.0);时，系统将调用"语文"的 hashCode()方法得到其 hashCode值——每个 Java对象都有 hashCode()方法，都可通过该方法获得它的 hashCode值。得到这个对象的 hashCode值之后，系统会根据该 hashCode值来决定该元素的存储位置。
我们可以看 HashMap类的 put(K key, V value)方法的源代码：
Java代码
public V put(K key, V value)
{
//如果 key为 null，调用 putForNullKey方法进行处理
if(key== null)
return putForNullKey(value);
//根据 key的 keyCode计算 Hash值
int hash= hash(key.hashCode());
//搜索指定 hash值在对应 table中的索引
int i= indexFor(hash, table.length);
//如果 i索引处的 Entry不为 null，通过循环不断遍历 e元素的下一个元素
for(Entry<K,V> e= table[i]; e!= null; e= e.next)
{
Object k;
//找到指定 key与需要放入的 key相等（hash值相同
//通过 equals比较放回 true）
if(e.hash== hash&&((k= e.key)== key
|| key.equals(k)))
{
V oldValue= e.value;
e.value= value;
e.recordAccess(this);
return oldValue;
}
}
//如果 i索引处的 Entry为 null，表明此处还没有 Entry
modCount++;
//将 key、value添加到 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随之保存在那里即可。
上面方法提供了一个根据 hashCode()返回值来计算 Hash码的方法：hash()，这个方法是一个纯粹的数学计算，其方法如下：
Java代码
static int hash(int h)
{
h ^=(h>>> 20) ^(h>>> 12);
return h ^(h>>> 7) ^(h>>> 4);
}
对于任意给定的对象，只要它的 hashCode()返回值相同，那么程序调用 hash(int h)方法所计算得到的 Hash码值总是相同的。接下来程序会调用 indexFor(int h, int length)方法来计算该对象应该保存在 table数组的哪个索引处。indexFor(int h, int length)方法的代码如下：
Java代码
static int indexFor(int h, int length)
{
return h&(length-1);
}
这个方法非常巧妙，它总是通过 h&(table.length-1)来得到该对象的保存位置——而 HashMap底层数组的长度总是 2的 n次方，这一点可参看后面关于 HashMap构造器的介绍。
当 length总是 2的倍数时，h&(length-1)将是一个非常巧妙的设计：假设 h=5,length=16,那么 h& length- 1将得到 5；如果 h=6,length=16,那么 h& length- 1将得到 6……如果 h=15,length=16,那么 h& length- 1将得到 15；但是当 h=16时, length=16时，那么 h& length- 1将得到 0了；当 h=17时, length=16时，那么 h& length- 1将得到 1了……这样保证计算得到的索引值总是位于 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()方法的说明。
当向 HashMap中添加 key-value对，由其 key的 hashCode()返回值决定该 key-value对（就是 Entry对象）的存储位置。当两个 Entry对象的 key的 hashCode()返回值相同时，将由 key通过 eqauls()比较值决定是采用覆盖行为（返回 true），还是产生 Entry链（返回 false）。
上面程序中还调用了 addEntry(hash, key, value, i);代码，其中 addEntry是 HashMap提供的一个包访问权限的方法，该方法仅用于添加一个 key-value对。下面是该方法的代码：
Java代码
void addEntry(int hash, K key, V value, int bucketIndex)
{
//获取指定 bucketIndex索引处的 Entry
Entry<K,V> e= table[bucketIndex];//①
//将新创建的 Entry放入 bucketIndex索引处，并让新的 Entry指向原来的 Entry
table[bucketIndex]= new Entry<K,V>(hash, key, value, e);
//如果 Map中的 key-value对的数量超过了极限
if(size++>= threshold)
//把 table对象的长度扩充到 2倍。
resize(2* table.length);//②
}
上面方法的代码很简单，但其中包含了一个非常优雅的设计：系统总是将新添加的 Entry对象放入 table数组的 bucketIndex索引处——如果 bucketIndex索引处已经有了一个 Entry对象，那新添加的 Entry对象指向原有的 Entry对象（产生一个 Entry链），如果 bucketIndex索引处没有 Entry对象，也就是上面程序①号代码的 e变量是 null，也就是新放入的 Entry对象指向 null，也就是没有产生 Entry链。
JDK源码
在 JDK安装目录下可以找到一个 src.zip压缩文件，该文件里包含了 Java基础类库的所有源文件。只要读者有学习兴趣，随时可以打开这份压缩文件来阅读 Java类库的源代码，这对提高读者的编程能力是非常有帮助的。需要指出的是：src.zip中包含的源代码并没有包含像上文中的中文注释，这些注释是笔者自己添加进去的。
Hash算法的性能选项
根据上面代码可以看出，在同一个 bucket存储 Entry链的情况下，新放入的 Entry总是位于 bucket中，而最早放入该 bucket中的 Entry则位于这个 Entry链的最末端。
上面程序中还有这样两个变量：
* size：该变量保存了该 HashMap中所包含的 key-value对的数量。
* threshold：该变量包含了 HashMap能容纳的 key-value对的极限，它的值等于 HashMap的容量乘以负载因子（load factor）。
从上面程序中②号代码可以看出，当 size++>= threshold时，HashMap会自动调用 resize方法扩充 HashMap的容量。每扩充一次，HashMap的容量就增大一倍。
上面程序中使用的 table其实就是一个普通数组，每个数组都有一个固定的长度，这个数组的长度就是 HashMap的容量。HashMap包含如下几个构造器：
* HashMap()：构建一个初始容量为 16，负载因子为 0.75的 HashMap。
* HashMap(int initialCapacity)：构建一个初始容量为 initialCapacity，负载因子为 0.75的 HashMap。
* HashMap(int initialCapacity, float loadFactor)：以指定初始容量、指定的负载因子创建一个 HashMap。
当创建一个 HashMap时，系统会自动创建一个 table数组来保存 HashMap中的 Entry，下面是 HashMap中一个构造器的代码：
Java代码
//以指定初始化容量、负载因子创建 HashMap
public HashMap(int initialCapacity, float loadFactor)
{
//初始容量不能为负数
if(initialCapacity< 0)
throw new IllegalArgumentException(
"Illegal initial capacity:"+
initialCapacity);
//如果初始容量大于最大容量，让出示容量
if(initialCapacity> MAXIMUM_CAPACITY)
initialCapacity= MAXIMUM_CAPACITY;
//负载因子必须大于 0的数值
if(loadFactor<= 0|| Float.isNaN(loadFactor))
throw new IllegalArgumentException(
loadFactor);
//计算出大于 initialCapacity的最小的 2的 n次方值。
int capacity= 1;
while(capacity< initialCapacity)
capacity<<= 1;
this.loadFactor= loadFactor;
//设置容量极限等于容量*负载因子
threshold=(int)(capacity* loadFactor);
//初始化 table数组
table= new Entry[capacity];//①
init();
}
上面代码中粗体字代码包含了一个简洁的代码实现：找出大于 initialCapacity的、最小的 2的 n次方值，并将其作为 HashMap的实际容量（由 capacity变量保存）。例如给定 initialCapacity为 10，那么该 HashMap的实际容量就是 16。
程序①号代码处可以看到：table的实质就是一个数组，一个长度为 capacity的数组。
对于 HashMap及其子类而言，它们采用 Hash算法来决定集合中元素的存储位置。当系统开始初始化 HashMap时，系统会创建一个长度为 capacity的 Entry数组，这个数组里可以存储元素的位置被称为“桶（bucket）”，每个 bucket都有其指定索引，系统可以根据其索引快速访问该 bucket里存储的元素。
无论何时，HashMap的每个“桶”只存储一个元素（也就是一个 Entry），由于 Entry对象可以包含一个引用变量（就是 Entry构造器的的最后一个参数）用于指向下一个 Entry，因此可能出现的情况是：HashMap的 bucket中只有一个 Entry，但这个 Entry指向另一个 Entry——这就形成了一个 Entry链。如图 1所示：
图 1. HashMap的存储示意
HashMap的读取实现
当 HashMap的每个 bucket里存储的 Entry只是单个 Entry——也就是没有通过指针产生 Entry链时，此时的 HashMap具有最好的性能：当程序通过 key取出对应 value时，系统只要先计算出该 key的 hashCode()返回值，在根据该 hashCode返回值找出该 key在 table数组中的索引，然后取出该索引处的 Entry，最后返回该 key对应的 value即可。看 HashMap类的 get(K key)方法代码：
Java代码
public V get(Object key)
{
//如果 key是 null，调用 getForNullKey取出对应的 value
if(key== null)
return getForNullKey();
//根据该 key的 hashCode值计算它的 hash码
int hash= hash(key.hashCode());
//直接取出 table数组中指定索引处的值，
for(Entry<K,V> e= table[indexFor(hash, table.length)];
e!= null;
//搜索该 Entry链的下一个 Entr
e= e.next)//①
{
Object k;
//如果该 Entry的 key与被搜索 key相同
if(e.hash== hash&&((k= e.key)== key
|| key.equals(k)))
return e.value;
}
return null;
}
从上面代码中可以看出，如果 HashMap的每个 bucket里只有一个 Entry时，HashMap可以根据索引、快速地取出该 bucket里的 Entry；在发生“Hash冲突”的情况下，单个 bucket里存储的不是一个 Entry，而是一个 Entry链，系统只能必须按顺序遍历每个 Entry，直到找到想搜索的 Entry为止——如果恰好要搜索的 Entry位于该 Entry链的最末端（该 Entry是最早放入该 bucket中），那系统必须循环到最后才能找到该元素。
归纳起来简单地说，HashMap在底层将 key-value当成一个整体进行处理，这个整体就是一个 Entry对象。HashMap底层采用一个 Entry[]数组来保存所有的 key-value对，当需要存储一个 Entry对象时，会根据 Hash算法来决定其存储位置；当需要取出一个 Entry时，也会根据 Hash算法找到其存储位置，直接取出该 Entry。由此可见：HashMap之所以能快速存、取它所包含的 Entry，完全类似于现实生活中母亲从小教我们的：不同的东西要放在不同的位置，需要时才能快速找到它。
当创建 HashMap时，有一个默认的负载因子（load factor），其默认值为 0.75，这是时间和空间成本上一种折衷：增大负载因子可以减少 Hash表（就是那个 Entry数组）所占用的内存空间，但会增加查询数据的时间开销，而查询是最频繁的的操作（HashMap的 get()与 put()方法都要用到查询）；减小负载因子会提高数据查询的性能，但会增加 Hash表所占用的内存空间。
掌握了上面知识之后，我们可以在创建 HashMap时根据实际需要适当地调整 load factor的值；如果程序比较关心空间开销、内存比较紧张，可以适当地增加负载因子；如果程序比较关心时间开销，内存比较宽裕则可以适当的减少负载因子。通常情况下，程序员无需改变负载因子的值。
如果开始就知道 HashMap会保存多个 key-value对，可以在创建时就使用较大的初始化容量，如果 HashMap中 Entry的数量一直不会超过极限容量（capacity* load factor），HashMap就无需调用 resize()方法重新分配 table数组，从而保证较好的性能。当然，开始就将初始容量设置太高可能会浪费空间（系统需要创建一个长度为 capacity的 Entry数组），因此创建 HashMap时初始化容量设置也需要小心对待。
关于java引用hash map需要引入什么和求java里面的Hash<Map>的用法和基本解释,谢谢的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。