HashMap和HashSet解析
------------------------------------------------HashMap------------------------------------------------------
一、---概念---
HashMap继承自AbstractMap，实现了Map接口。下面从定义入手来开始分析：
public class HashMap
extends AbstractMap
implements Map, Cloneable, Serializable （1）AbstractMap类提供Map接口的骨干实现
（2）Map接口定义了键映射到值的规则。
（3）实现了Cloneable接口的类，可以调用Object.clone方法返回该对象的浅拷贝。
二、---属性---
HashMap中有多个属性：包括初始容量、最大容量和装载因子等
//默认的初始容量，必须是2的幂。
static final int DEFAULT_INITIAL_CAPACITY = 16;
//最大容量（必须是2的幂且小于2的30次方，传入容量过大将被这个值替换）
static final int MAXIMUM_CAPACITY = 1 << 30;
//默认装载因子，这个后面会做解释
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//存储数据的Entry数组，长度是2的幂。看到数组的内容了，接着看数组中存的内容就明白为什么博文开头先复习数据结构了
transient Entry[] table;
//map中保存的键值对的数量
transient int size;
//需要调整大小的极限值（容量*装载因子）
int threshold;
//装载因子
final float loadFactor;
//map结构被改变的次数
transient volatile int modCount;三、---构造方法---
HashMap中为我们提供了三个构造方法。
（1）HashMap()：构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。
（2）HashMap(int initialCapacity)：构造一个带指定初始容量和默认加载因子 (0.75) 的空 HashMap。
（3）HashMap(int initialCapacity, float loadFactor)：构造一个带指定初始容量和加载因子的空 HashMap。
在这里提到了两个参数：初始容量，加载因子。其中容量表示哈希表中桶的数量，初始容量是创建哈希表时的容量，加载因子是哈希表在其容量自动增加之前可以达到多满的一种尺度，它衡量的是一个散列表的空间的使用程度，负载因子越大表示散列表的装填程度越高，反之愈小。对于使用链表法的散列表来说，查找一个元素的平均时间是O(1+a)，因此如果负载因子越大，对空间的利用更充分，然而后果是查找效率的降低；如果负载因子太小，那么散列表的数据将过于稀疏，对空间造成严重浪费。系统默认负载因子为0.75，一般情况下我们是无需修改的。
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR;
threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);//计算下次需要调整大小的极限值
table = new Entry[DEFAULT_INITIAL_CAPACITY];//根据默认容量（16）初始化table
init();
}
//根据给定的初始容量的装载因子创建一个空的HashMap
//初始容量小于0或装载因子小于等于0将报异常
public HashMap(int initialCapacity, float loadFactor) {
//初始容量不能<0
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: "
+ initialCapacity);
//初始容量不能 > 最大容量值，HashMap的最大容量值为2^30
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
//负载因子不能 < 0
if (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
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);//调用上面的构造方法，容量为指定的容量，装载因子是默认值
}
//通过传入的map创建一个HashMap，容量为默认容量（16）和(map.zise()/DEFAULT_LOAD_FACTORY)+1的较大者，装载因子为默认值
public HashMap(Map m) {
this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
putAllForCreate(m);
}从源码中可以看出，每次新建一个HashMap时，都会初始化一个table数组。table数组的元素为Entry节点。
四、---Entry类---
初始化table时均使用了Entry，table的数组元素为Entry结点。Entry是HashMap的一个内部类，实现Map接口的内部接口
Entry。下面给出Map.Entry接口及HashMap.Entry类的内容。Map.Entry接口定义的方法如下：
K getKey();//获取Key
V getValue();//获取Value
V setValue();//设置Value，至于具体返回什么要看具体实现
boolean equals(Object o);//定义equals方法用于判断两个Entry是否相同
int hashCode();//定义获取hashCode的方法如下是HashMap.Entry的具体实现：
static class Entry implements Map.Entry {
final K key;
V value;
Entry next;
final int hash;
/**
* Creates new entry.
*/
Entry(int h, K k, V v, Entry n) {
value = v;
next = n;
key = k;
hash = h;
}
.......
} 五、---其他方法---
5.1put(E key, V value)
如下是put( )函数的源代码：
public V put(K key, V value) {
//当key为null，调用putForNullKey方法，保存null与table第一个位置中，这是HashMap允许为null的原因
if (key == null)
return putForNullKey(value);
//计算key的hash值
int hash = hash(key.hashCode()); ------(1)
//计算key hash 值在 table 数组中的位置
int i = indexFor(hash, table.length); ------(2)
//从i出开始迭代 e,找到 key 保存的位置
for (Entry e = table[i]; e != null; e = e.next) {
Object k;
//判断该条链上是否有hash值相同的(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; //返回旧值
}
}
//修改次数增加1
modCount++;
//将key、value添加至i位置处
addEntry(hash, key, value, i);
return null;
}
获得hash值的函数如下：
static int hash(int h) {
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
} static int indexFor(int h, int length) {
return h & (length-1);
} 5.2 get(Object key)
通过key的hash值找到在table数组中的索引处的Entry，然后返回该key对应的value即可。
public V get(Object key) {
// 若为null，调用getForNullKey方法返回相对应的value
if (key == null)
return getForNullKey();
// 根据该 key 的 hashCode 值计算它的 hash 码
int hash = hash(key.hashCode());
// 取出 table 数组中指定索引处的值
for (Entry e = table[indexFor(hash, table.length)]; e != null; e = e.next) {
Object k;
//若搜索的key与查找的key相同，则返回相对应的value
if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
return e.value;
}
return null;
}
该方法分为key为null和不为null两块。先看不为null的情况。先获取key的hash值，之后通过hash值及table.length获取key对
应的table数组的索引，遍历索引的链表，所找到key相同的元素，则返回元素的value，否者返回null。不为null的情况调用了
getForNullKey()方法。
private V getForNullKey() {
for (Entry e = table[0]; e != null; e = e.next) {
if (e.key == null)
return e.value;
}
return null;
} 这是一个私有方法，只在get中被调用。该方法判断table[0]中的链表是否包含key为null的元素，包含则返回value，不包含则
返回null。为什么是遍历table[0]的链表？因为key为null的时候获得的hash值都是0。
以上是对ArrayList中几个典型方法的源代码分析，还有很多就不一一列举了。
-------------------------------------------------HashSet-------------------------------------------------------
一、---概念---
存入Set的每个元素必须是惟一的，因为Set不保存重复元素。加入Set的元素必须定义equals()方法以确保对象的唯一性。Set不
保证维护元素的次序。Set与Collection有完全一样的接口。
在没有其他限制的情况下需要Set时应尽量使用HashSet，因为它对速度进行了优化。
public class HashSet
extends AbstractSet
implements Set, Cloneable, java.io.Serializable
二、---属性---
在HashSet中提供了两个基本的属性，一个是map，一个是PRESENT，其中map代表的是保存的元素，PRESENT代表的是value
//基于HashMap实现，底层使用HashMap保存所有元素
private transient HashMap map;
//定义一个Object对象作为HashMap的value
private static final Object PRESENT = new Object(); 通过一个HashMap存储元素，元素是存放在HashMap的Key中，而Value统一使用一个Object对象。
这样看来HashSet应该很简单，应该只是使用了HashMap的部分内容来实现。
三、---构造方法---
HashSet中提高了5个构造方法，如下：
// 构造方法一：调用默认的HashMap构造方法初始化map
public HashSet() {
map = new HashMap();
}
// 构造方法二：根据给定的Collection参数调用HashMap(int initialCapacity)的构造方法创建一个HashMap（这个构造方法的HashMap的源码分析里已经描述过了）
// 调用addAll方法将c中的元素添加到HashSet对象中
public HashSet(Collection c) {
map = new HashMap(Math.max((int) (c.size()/.75f) + 1, 16));
addAll(c);
}
// 构造方法三：构造一个指定初始化容量和负载因子的HashMap
public HashSet(int initialCapacity, float loadFactor) {
map = new HashMap(initialCapacity, loadFactor);
}
// 构造方法四：构造一个指定初始化容量的HashMap
public HashSet(int initialCapacity) {
map = new HashMap(initialCapacity);
}
// 构造方法五：构造一个指定初始化容量和负载因子的LinkedHashMap
// dummy参数被忽略，只是用于区分其他的，包含一个int、float参数的构造方法
HashSet(int initialCapacity, float loadFactor, boolean dummy) {
map = new LinkedHashMap(initialCapacity, loadFactor);
} 四、---其他方法---
4.1 Iterator()
public Iterator iterator() {
return map.keySet().iterator();
} 4.2 size()
public int size() {
return map.size();
} 4.3add(E e)
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
HashMap的，
put方法也是调用HashMap的put方法）的put方法将e当做Key，PERSENT当做Value加入到map中并根据返回值判
断是否添加成
功。
五、---LinkedHashSet---
LinkedHashSet具有HashSet的查询速度，且内部使用链表维护元素的顺序（插入的次序）。于是在使用迭代器遍历Set时，结
果会按照元素的插入次序显示。
public class LinkedHashSet
extends HashSet
implements Set, Cloneable, java.io.Serializable {
public LinkedHashSet(int initialCapacity, float loadFactor) {
super(initialCapacity, loadFactor, true);
}
public LinkedHashSet(int initialCapacity) {
super(initialCapacity, .75f, true);
}
public LinkedHashSet() {
super(16, .75f, true);
}
public LinkedHashSet(Collection c) {
super(Math.max(2*c.size(), 11), .75f, true);
addAll(c);
}
}
注意这里的构造方法，都调用了父类HashSet的第五个构造方法：HashSet(int initialCapacity, float loadFactor, boolean
dummy)。如果还记得上面的内容应该明白为什么是基于链表，下面再给出这个构造方法的内容。
HashSet(int initialCapacity, float loadFactor, boolean dummy) {
map = new LinkedHashMap(initialCapacity, loadFactor);
}
有一个链表结构用于维护元素顺序，默认情况使用的是插入元素，所以LinkedHashSet既有HashSet的访问速度（因为访问的时候
都是通过HashSet的方法访问的），同时可以维护顺序。
尊重作者，尊重原创，参考文章：
http://blog.csdn.net/jzhf2012/article/details/8540670
http://blog.csdn.net/chenssy/article/details/18323767