通过分析HashMap和HashSet源码分析其Hash存储机制
对于HashSet而言，系统采用hash算法决定集合元素的存储位置，这样可以保证能快速存、取集合元素；
对于HashMap而言，系统key-value当成一个整体进行处理，系统总是根据Hash算法来计算key-value的存储位置，这样可以保证能快速存、取Map的key-value对。
虽然集合号称存储的是Java对象，但实际上并不会真正将Java对象放入Set集合中，只是在Set集合中保留这些对象的引用。
即，Java集合实际上是多个引用变量所组成的集合，这些引用变量指向实际的Java对象。
HashMap的存储实现
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值来决定该元素的存储位置。
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 中的索引
<strong> int i = indexFor(hash, table.length);</strong>
// 如果 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()，这个方法是一个纯粹的数学计算，其方法如下：
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数组的哪个索引处。
static int indexFor(int h, int length)
{
return h & (length-1);
}
这个方法总是通过h & (table.length-1)来得到该对象的保存位置
而HashMap底层数组的长度总是2的n次方。
当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数组的索引之内。
当程序试图将一个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链的头部。
当向HashMap中添加key-value对，由其key的hashCode()返回值决定该key-value对（就是Entry对象）的存储位置。
当两个Entry对象的key的hashCode()返回值相同时，将由key通过equals()比较值决定是采用覆盖行为（返回true），还是产生Entry链（返回false）。
上面程序中还调用了addEntry(hash, key, value, i);代码，其中addEntry是HashMap提供的一个包访问权限的方法，该方法仅用于添加一个key-value对。
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链。
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中一个构造器的代码：
// 以指定初始化容量、负载因子创建 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变量保存）。
table的实质就是一个数组，一个长度为capacity的数组。
对于HashMap及其子类而言，它们采用Hash算法来决定集合中元素的存储位置。
当系统开始初始化HashMap时，系统会创建一个长度为capacity的Entry数组，这个数组里可以存储元素的位置被称为“桶（bucket）”，每个bucket都有其指定索引，系统可以根据其索引快速访问该bucket里存储的元素。
无论何时，HashMap的每个“桶”只存储一个元素（即一个Entry），由于Entry对象可以包含一个引用变量（就是Entry构造器的最后一个参数）用于指向下一个Entry，
因此可能出现的情况是：HashMap的bucket中只有一个Entry，但这个Entry指向另一个Entry————这就形成了一个Entry链。
HashMap的读取实现
当HashMap的每个bucket里存储的Entry只是单个Entry————也就是没有通过指针产生Entry链时，此时的HashMap具有最好的性能：
当程序通过key取对应value时，系统只要先计算出该key的hashCode（）返回值，在根据该hashCode返回值找出该key在table数组中的索引，然后取出该索引处的Entry，最后返回该key对应的value即可。
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时初始化容量设置也需小心对待。
HashSet的实现
对于HashSet而言，它是基于HashMap实现的，Hashset底层采用HashMap来保存所有元素，
public class HashSet<E>
extends AbstractSet<E>
implements Set<E>, Cloneable, java.io.Serializable
{
// 使用 HashMap 的 key 保存 HashSet 中所有元素
private transient HashMap<E,Object> map;
// 定义一个虚拟的 Object 对象作为 HashMap 的 value
private static final Object PRESENT = new Object();
...
// 初始化 HashSet，底层会初始化一个 HashMap
public HashSet()
{
map = new HashMap<E,Object>();
}
// 以指定的 initialCapacity、loadFactor 创建 HashSet
// 其实就是以相应的参数创建 HashMap
public HashSet(int initialCapacity, float loadFactor)
{
map = new HashMap<E,Object>(initialCapacity, loadFactor);
}
public HashSet(int initialCapacity)
{
map = new HashMap<E,Object>(initialCapacity);
}
HashSet(int initialCapacity, float loadFactor, boolean dummy)
{
map = new LinkedHashMap<E,Object>(initialCapacity
, loadFactor);
}
// 调用 map 的 keySet 来返回所有的 key
public Iterator<E> iterator()
{
return map.keySet().iterator();
}
// 调用 HashMap 的 size() 方法返回 Entry 的数量，就得到该 Set 里元素的个数
public int size()
{
return map.size();
}
// 调用 HashMap 的 isEmpty() 判断该 HashSet 是否为空，
// 当 HashMap 为空时，对应的 HashSet 也为空
public boolean isEmpty()
{
return map.isEmpty();
}
// 调用 HashMap 的 containsKey 判断是否包含指定 key
//HashSet 的所有元素就是通过 HashMap 的 key 来保存的
public boolean contains(Object o)
{
return map.containsKey(o);
}
// 将指定元素放入 HashSet 中，也就是将该元素作为 key 放入 HashMap
public boolean add(E e)
{
return map.put(e, PRESENT) == null;
}
// 调用 HashMap 的 remove 方法删除指定 Entry，也就删除了 HashSet 中对应的元素
public boolean remove(Object o)
{
return map.remove(o)==PRESENT;
}
// 调用 Map 的 clear 方法清空所有 Entry，也就清空了 HashSet 中所有元素
public void clear()
{
map.clear();
}
...
}
由源码可以看出，Hashset的实现只是封装了一个HashMap对象来存储所有的集合元素，
所有放入HashSet中的集合元素实际上有HashMap的key来保存，
而HashMap的value则存储了一个present，它是一个静态的Object对象。
HashSet的绝大部分方法都是通过调用HashMap的方法实现的，因此HashSet和HashMap两个集合在实现本质上是相同的。
HashMap的put与HashSet的add
由于HashSet的add()方法添加集合元素实际上转变为调用HashMap的put（）方法来添加key-value对，
当新放入HashMap的Entry中key与集合中原有Entry的key相同（hashcode（）返回值相等，通过equals比较也返回true），新添加的Entry的value将覆盖原来Entry的value，但key不会有任何改变，
因此如果向HashSet中添加一个已经存在的元素，新添加的集合元素（底层由HashMap的key保存）不会覆盖已有的集合元素。
HashSet判断两个对象相等的标准除了要求通过equals（）方法比较返回true之外，还要求两个对象的hashcode（）返回值相等。
所以如果类只重写equals()方法没有重写hashCode()方法，两个所有属性都相同的同类对象的hashCode()返回值并不同，所以HashSet会把它们当成2个对象。
当我们试图把某个类的对象当成HashMap的key，或试图将这个类的对象放入HashSet中保存时，重写该类 的equals（Object obj）方法和hashCode()方法很重要，
而且这两个方法的返回值必须保持一致：当该类的两个对象的hashCode（）返回值相同时，他们通过equals（）方法比较也应该返回true。
通常来说，所有参与计算hashcode（）返回值的关键属性，都应该用于作为equals()比较的标准。