Java实现1到100得排序,Java8 HashSet让排序更简单

背景

当我们谈起Java8新特性时(相较于Java7)，受关注最多的往往是lambada表达式、方法引用等，但其实对我们一些不易察觉的优化点正切实影响着我们的编程方式。

例如，本文要讲的HashSet元素顺序。

众所周知，

List保证元素的添加顺序，元素可重复

Set不保证元素的添加顺序，元素不可重复

但“不保证有序”≠“保证无序”，且此处的“有序”指的是“元素添加顺序”，也就是说不能信任HashSet对元素的排序(所以通常我们使用TreeSet类型保证元素顺序，LinkedHashSet类型保证插入顺序)

不过如果你在"jdk1.8.*"下遍历HashSet时，会惊奇的发现，整数元素居然是有序的：

遍历HashSet 0-99

甚至是字母：

遍历HashSet 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[] tab; Node 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 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)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多行，初始化集合时也不必再依赖递归等方式，专注源于兴趣，继续加油吧。