背景
当我们谈起Java8新特性时（相较于Java7），受关注最多的往往是lambada表达式、方法引用等，但其实对我们一些不易察觉的优化点正切实影响着我们的编程方式。
例如，本文要讲的HashSet元素顺序。
众所周知，
- List保证元素的添加顺序，元素可重复
- Set不保证元素的添加顺序，元素不可重复
但“不保证有序”≠“保证无序”，且此处的“有序”指的是“元素添加顺序”，也就是说不能信任HashSet对元素的排序（所以通常我们使用TreeSet类型保证元素顺序，LinkedHashSet类型保证插入顺序）
不过如果你在"jdk1.8.*"下遍历HashSet<Integer>时，会惊奇的发现，整数元素居然是有序的：
遍历HashSet<Integer> 0-99
甚至是字母：
遍历HashSet<String> a-f
我们来看源码：
// HashSet.java
// 会发现HashSet.add实际调用的是HashMap.put
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
// HashMap.java
// 调用内部final方法putVal
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
/**
* @param hash 计算出来key的hash值
* @param key key的值
* @param value value的值
* @param onlyIfAbsent 当为true的时候，如果key对应有值，则不修改这个值
* @param evict 当为false时，表示这个处于创建模式，现在由于afterNodeInsertion中什么都没有，这里没有实际意
* evict参数用于LinkedHashMap中的尾部操作
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//判断当table为null或者tab的长度为0时，即table尚未初始化，此时通过resize()方法得到初始化的table
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//当p为null时，表明tab[i]上没有任何元素，那么接下来就new第一个Node节点，调用newNode方法返回新节点赋值给tab[i]
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
//HashMap中判断key相同的条件是key的hash相同，并且符合equals方法。这里判断了p.key是否和插入的key相等，如果相等，则将p的引用赋给e
//这里为什么要把p赋值给e，而不是直接覆盖原值呢？答案很简单，现在我们只判断了第一个节点，后面还可能出现key相同，所以需要在最后一并处理
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
//现在开始了第一种情况，p是红黑树节点，那么肯定插入后仍然是红黑树节点，所以我们直接强制转型p后调用TreeNode.putTreeVal方法，返回的引用赋给e
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
//最后一个参数为新节点的next，这里传入null，保证了新节点继续为该链表的末端
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//插入成功后，要判断是否需要转换为红黑树，因为插入后链表长度加1，而binCount并不包含新节点，所以判断时要将临界阈值减1
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//在遍历链表的过程中，我之前提到了，有可能遍历到与插入的key相同的节点，此时只要将这个节点引用赋值给e，最后通过e去把新的value覆盖掉就可以了
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//行注释为jdk自带注释，说的很明白了，针对已经存在key的情况做处理
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
//收尾工作，值得一提的是，对key相同而覆盖oldValue的情况，在前面已经return，不会执行这里，所以那一类情况不算数据结构变化，并不改变modCount值
++modCount;
//当HashMap中存在的node节点大于threshold时，hashmap进行扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
可见，当HashMap中存在的node节点小于等于threshold时，hashMap不会扩容，新增元素时，会根据key的Hash插入到对应位置。
已知HashMap的默认数组长度为16，默认负载因子是0.75，所以只要保证initalCapacity > 实际长度/0.75，即可保证元素顺序。
这一特性在算法设计和实际业务中都有应用
算法设计中：
1-100取10个不同随机数并排序：
以往写法：
// 1. 声明容量为10的整数数组或集合
// 2. 循环或递归装载10个随机数
// 3. 各式排序算法挑选一种
// 4. 遍历打印
而现在只需：
while (nums.size() < 10) {
nums.add((int) Math.floor(Math.random() * 100));
}
由于Set不允许元素重复，相同的会add失败，同时jdk1.8支持元素排序（下面详细讲），只需三行代码即可实现。
实际业务中：
原来的例子不好，待补充。。
总结
念念不忘，必有回响。我是在重写排序算法实现时发现了这一特性，原本100多行的代码缩短到60多行，初始化集合时也不必再依赖递归等方式，专注源于兴趣，继续加油吧。
