为何有时候HashSet输出会有序？浅析HashSet底层是如何“排序”的

问题再现

我们都知道Set集合是无序的。此处的无序体现在，一般情况下，输出顺序和输入顺序不同。并且“毫无规律”（先挖个坑，后面解释）。比如如下代码：

		Set<Integer> s = new HashSet<>();
		s.add(37);
		s.add(16);
		s.add(4);
		s.add(23);
		s.add(1);
		s.add(6);
		s.add(66);
		System.out.println(s);// [16, 1, 66, 4, 37, 6, 23]
	}

可以看到，输出的顺序似乎是“不可预期”的。这似乎和我们所认知的一样。但是看下面代码：

		Set<Integer> s = new HashSet<>();

		s.add(2);
		s.add(1);
		s.add(4);
		s.add(7);
		s.add(6);
		s.add(5);
		s.add(3);
		System.out.println(s);// [1, 2, 3, 4, 5, 6, 7]

输入同样无序，但是输出却是有序的。为什么会这样呢？
我们先来看看HashSet的API文档怎么说的：
This class implements the Set interface, backed by a hash table (actually a HashMap instance). It makes no guarantees as to the iteration order of the set; in particular, it does not guarantee that the order will remain constant over time. This class permits the null element.
注意加粗的两句。翻译过来就是：它不保证集合的迭代顺序。特别是，它不能保证顺序会随着时间的推移保持恒定。
API文档说得很清楚了。不保证迭代顺序。也就是说不保证有序，但是也不保证无序。那HashSet的元素顺序真的是毫无规律和不可预期的么？我们来看看HashSet底层究竟是怎样确定元素顺序的。

源码分析

先看看HashSet类的源码

public class HashSet<E>
    extends AbstractSet<E>
    implements Set<E>, Cloneable, java.io.Serializable
{
    static final long serialVersionUID = -5024744406713321676L;

    private transient HashMap<E,Object> map;

    // Dummy value to associate with an Object in the backing Map
    private static final Object PRESENT = new Object();

    /**
     * Constructs a new, empty set; the backing {@code HashMap} instance has
     * default initial capacity (16) and load factor (0.75).
     */
    public HashSet() {
        map = new HashMap<>();
    }
    
    public boolean add(E e) {
    	//为了保证元素唯一性，元素是作为HashMap的key来保存的
        return map.put(e, PRESENT)==null;
    }
}

可以看到HashSet底层其实是一个HashMap，其default initial capacity (16)即初始大小为16，load factor (0.75)。并且为了保证元素的唯一性，add元素的时候其实是add到了HashMap的key位置。

我们以插入Integer类型正数为例，负数后面再说，继续往下看，进入到put方法：

    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

put方法里。首先根据key（也就是我们需要插入的元素）来获取它的hash值：

    static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

    @Override
    public int hashCode() {
        return Integer.hashCode(value);
    }
    public static int hashCode(int value) {
        return value;
    }

可以看到，Integer类型的数据，其hash值其实就是它本身。所以上面代码中的h=key。所以
(h = key.hashCode()) ^ (h >>> 16)其实就可以看成是key ^ (key >>> 16)。>>>表示无符号右移，^表示异或运算符。举个栗子，假设我们要插入的元素是19

0000 0000 0000 0000 0000 0000 0001 0011 // 二进制19
0000 0000 0000 0000 0000 0000 0000 0000 // 19 >>> 16
0000 0000 0000 0000 0000 0000 0001 0011 // 19 ^ (19 >>> 16)

可以看到。其实key = key ^ (key >>> 16)，也就是说方法hash(key)得到的值就是key本身。
于是我们可以得到：
结论一：当HashSet插入整型元素的时候，元素的hash值就是它本身。
接下来继续看源码。进入putVal方法：

    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        // tab表示节点数组， n表示数组长度。
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        // i 表示tab的下标。
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold) //当长度大于threshold时，扩容
            resize();
        afterNodeInsertion(evict);
        return null;
    }

可以看到我们要插入的数据是存放在一个节点数组tab里。该数组的下标 i = (tab.length - 1) & hash按照我们刚才的结论，i = (tab.length - 1) & key。那tab.length又是多少呢？
我们先看后面这两句代码：

        if (++size > threshold)
            resize();

也就是当size大于长度阈值threshold时，HashSet就会自动扩容。这里的threshold = capacity * load factor。初始情况下，其实就是threshold = 16 * 0.75 = 12。再看resize()方法有这样几句代码：

        int newCap, newThr = 0;
        if (oldCap > 0) {
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold

可以看到新的长度等于原来长度的两倍（oldCap << 1表示oldCap * 2），而新的长度阈值也是等于原来阈值的两倍。
于是我们可以得到：
结论二：当HashSet插入整型元素的数量大于12、24、48…的时候，HashSet会自动扩容，新容量为32、64、128 …

看到这里，相信你已经很清晰了。
所以我们可以分下面这几种情况来讨论i = (tab.length - 1) & key的值到底是多少：

1. 元素数量 <= 12，此时长度=16，插入元素为0~15
   i = (16 - 1) & (0 ~ 15) = (15) & (0 ~ 15) = (0 ~ 15)，也就是说15&任何0 ~ 15的数都是他本身。
2. 元素数量 <= 12，此时长度=16，插入元素为16~31
   i = (16 - 1) & (16 ~ 31) = (15) & (16 ~ 31) = (0 ~ 15)，也就是说15&任何16 ~ 31的数，结果都是0 ~ 15。
3. 元素数量 < 12，此时长度=16，插入元素为32 ~ 47，48 ~ 63等等都可以以此类推

此时可以得出
结论三：当HashSet插入整型元素的数量 <= 12时，此时length=16，HashSet内部元素的下标，根据元素的大小，每隔length-1，从0到15周期性循环。

4. 24 > 元素数量 > 12，按照结论二，此时长度=32，插入元素为0~31
   i = (32 - 1) & (0 ~ 31) = (31) & (0 ~ 31) = (0 ~ 31)，也就是说31&任何0 ~ 31的数都是他本身。
   后面的可以按照上面1 2 3的方法以此类推。

此时，综合上面的几个结论，可以得出：
结论四：当HashSet插入整型元素时，当length=16、32、64等等，元素的下标 i 根据元素的大小，每隔length-1，从0到length-1周期性循环。

下面我们来验证结论是不是正确的。以文章开头的代码作为例子：

		Set<Integer> s = new HashSet<>();
		s.add(37);
		s.add(16);
		s.add(4);
		s.add(23);
		s.add(1);
		s.add(6);
		s.add(66);
		System.out.println(s);// [16, 1, 66, 4, 37, 6, 23]
	}

第一次，插入37，此时length=16，所以 i = 15 & 37 = 5，所以此时在底层应该是这样一种结构：

元素：[null,null,null,null,null, 37,null,null,null,null,null,null,null,null,null,null]
下标：  0    1    2    3    4    5  6    7    8    9    10   11   12   13   14   15

第二次，插入16，此时length=16，所以 i = 15 & 16 = 0，此时：

元素：[16 ,null,null,null,null, 37,null,null,null,null,null,null,null,null,null,null]
下标：  0    1    2    3    4    5  6    7    8    9    10   11   12   13   14   15

以此类推，后面几次的底层结构分别为：

元素：[16 ,null,null,null,  4 , 37,null,null,null,null,null,null,null,null,null,null]
下标：  0    1    2    3    4    5  6    7    8    9    10   11   12   13   14   15

元素：[16 ,null,null,null,  4 , 37,null, 23 ,null,null,null,null,null,null,null,null]
下标：  0    1    2    3    4    5  6    7    8    9    10   11   12   13   14   15

元素：[16 ,  1 ,null,null,  4 , 37,null, 23 ,null,null,null,null,null,null,null,null]
下标：  0    1    2    3    4    5  6    7    8    9    10   11   12   13   14   15

元素：[16 ,  1 ,null,null,  4 , 37, 6  , 23 ,null,null,null,null,null,null,null,null]
下标：  0    1    2    3    4    5  6    7    8    9    10   11   12   13   14   15

元素：[16 ,  1 , 66 ,null,  4 , 37, 6  , 23 ,null,null,null,null,null,null,null,null]
下标：  0    1    2    3    4    5  6    7    8    9    10   11   12   13   14   15

去掉空值，恰好就是[16, 1, 66, 4, 37, 6, 23]，是不是和输出的一样。当数量大于12的时候，验证方法一样，比如倒序插入14，13, 12。。。1，输出肯定是[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]。关键就是看当前元素数量是否超过12、24。。。确定Set容量后就能推算出元素的位置。这里就不详细验证了。
还有一种特殊情况，两个元素的下标相同的时候，比如5 和37，底层下标都是5，这种情况就会按照插入顺序的先后，后插入的往后移动一位存放。源码是这一行：

 p.next = newNode(hash, key, value, null);

p节点存放先插入的元素，p.next指针指向的节点存放后插入的元素。如果p.next节点已经有元素了，那么现有元素按照顺序依次往后移动

负数和其他类型的数据的hash值不同，但是算法都一样，这里就不验证了。

结论

HashSet中，元素的位置其实是固定的，并不是毫无规律和不可预期的。我们所看到的无序是由于底层一系列算法确定的。正是由于有这个算法，所以我们看到的输出顺序往往和输入顺序不同。
正如API文档里说的：
它不保证集合的迭代顺序。特别是，它不能保证顺序会随着时间的推移保持恒定。
由于有定位算法，所以不保证顺序。由于扩容后算法因子不同，所以随着时间推移，Set越来越大，算法确定的位置也会随着长度变化而变化。
不保证有序，但是也不保证无序。
比如：现在有一个HashSet输出为：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]。此时容量<12，长度=16。
我再插入一个元素17。容量=12，还没发生扩容，底层下标 i = 15 & 17 = 1，由于后插入，所以放在现有元素1的后面一位。所以输出为[1, 17, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]。
我再插入一个元素18，此时容量>12，发生扩容，长度=32，算法因子改变。位置也变了。所以输出变成[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 17, 18]。

最后

本人水平有限，如有不足之处，请评论里指出，谢谢！