关于HashSet的有序无序问题

Surrin1999 2018-08-23 11:29:06



package hashset.train;



import java.util.HashSet;

//import java.util.Random;

import java.util.Set;





public class HashSetDemo {

	public static void main(String[] args) {

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



//		Random rand=new Random();

		

		hs.add(6);

		hs.add(100);

		hs.add(150);

		hs.add(240);

		hs.add(330);

		hs.add(520);				// 乱序  在table中位置是根据hash算法计算得出的 但只是会影响存储位置 不是一定会使元素变得自然排序(像依次添加那样  估计与table的长度的增加有关) 但是若用随机数添加又符合规律？

		

//		for (int i=0;i<5000;i++){

//			hs.add(rand.nextInt(1000));

//		}

		

//		for (int i=0;i<1000;i++) {

//			System.out.println(i);

//		}



		for (int i : hs) {

			System.out.println(i);

		}

	}

}

当HashSet像如今这样添加的话输出是无序的 但当放在21~23行的随机注释添加元素改为添加1000以内随机数 随机添加就会发现是自然排序的,，25~27行那样直接顺序添加也是一样自然排序的这是为什么呢之前翻阅资料和源码知道tHashMap 的table数组是根据hashcode的数值计算元素在table中的下标的这也就间接导致了数据值会影响其在table中的位置也知道[[0,2^32-1]内返回的都是整型值本身

如https://blog.csdn.net/tzhuwb/article/details/77757754
https://www.cnblogs.com/-jiang/p/5516973.html 所示

但那些资料举的例子都是随机添加或例子数据刚刚好符合的, 当我的例子这样时 本应该自然排序的为什么没有排序呢？

...全文

1140 23 打赏收藏转发到动态举报

写回复

用AI写文章

23 条回复

切换为时间正序

请发表友善的回复…

发表回复

赵4老师 2018-08-28

打赏
举报

理解和讨论之前请先学会如何观察！

梨花剑君 2018-08-28

打赏
举报

是在构造方法里的另一个方法里

啊大1号 2018-08-27

打赏
举报

源码之前，了无秘密

liulilittle 2018-08-27

打赏
举报

HashSet 是无法自动排序的哈，它是由元素之间在插入时，hash 计算的 bucket 只要不具有冲突就直接往这个 map 地址插入其值否则放大关键链插入其值。
在迭代的时候是以当前 HashSet 容器包含可见有效的元素，这是一个无序的 bucket 关链。

这名字可真靓 2018-08-25

打赏
举报

为什么我的显示结果是只有1-15是有序的.大于15虽然相邻的数字大小差不多,但是并不是有序的.也不是真正的随机,同样jdk1.8

Surrin1999 2018-08-25

打赏
举报

好的谢谢各位我已经知道了这个算法其实就是取容量最接近的（向上取）二次幂

licjd 2018-08-25

打赏
举报

引用 16 楼 Surrin1999 的回复:

呃好像是在构造方法里的另一个方法里



static final int tableSizeFor(int cap) {

        int n = cap - 1;

        n |= n >>> 1;

        n |= n >>> 2;

        n |= n >>> 4;

        n |= n >>> 8;

        n |= n >>> 16;

        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;

    }

不过不太看得懂

这个有点麻烦，虽然听过一次，但好像我自己推不出来，晚上试试

...
上面代码最后的结果是2^n
一句结论：如果指定初始容量为X，并且X~（2^(n-1),2^n]，最终容量肯定为2^n

Surrin1999 2018-08-24

打赏
举报

引用 10 楼 nayi_224 的回复:

[quote=引用 9 楼 Surrin1999 的回复:]
[quote=引用 5 楼 nayi_224 的回复:]
跟随机数没关系。

HashSet里面是HashMap，HashMap里面是数组。如果新值的hash值小于数组最大下标，会正好添加到这个下标处。而数字的hash值就是它自己。
如果hash值大于下标最大值，会有别的算法来做添加（记得是取余数）。比如对 new HashSet(4) 添加5，它会加到下标1的位置。这个时候再添加1，它会在下标1处向后添加链表。当继续添加值以致大于0.75时，会触发HashMap的resize()方法。基本就是新生成一个1.5倍长度的新数组，将原来的值重新add一遍。
for-each循环就是把这个数组顺序输出。
也就是说，你这个只是巧合而已。

举个更精辟的例子
		HashSet<Integer> hs = new HashSet<Integer>(4);



		hs.add(3);

		hs.add(5);
无序
		HashSet<Integer> hs = new HashSet<Integer>(4);



		hs.add(3);

		hs.add(5);

		hs.add(1);

		hs.add(2);
有序

您这个解释是根据JDK7的数组+链表来讲的吗以前的还能看懂现在的JDK8写的好复杂以及能说说您当时是怎么学习知道的吗文档英文看的头皮发麻看不下去

[/quote]

1.8依然有数组+链表，红黑树只是一个补充。上面这些个例子正好不会触发红黑树的代码。
也没什么学习经历，我也是今天看了你的问题才第一次打开jdk1.8HashSet的源码。跟了断点之后发现跟老版的套路一样罢了。
全面的了解一套代码真的很令人羡慕，但是时间太有限了，只关注当前用上的代码也不失为一种好方法。[/quote]

您是根据这个来看的吧能给一些关键注释吗我刚开始学习集合框架老版的还行新版的看不懂。。



final V putVal(int hash, K key, V value, boolean onlyIfAbsent,

                   boolean evict) {

        Node<K,V>[] tab; Node<K,V> p; int n, i;

        if ((tab = table) == null || (n = tab.length) == 0)

            n = (tab = resize()).length;

        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)

            resize();

        afterNodeInsertion(evict);

        return null;

    }

Surrin1999 2018-08-24

打赏
举报

呃好像是在构造方法里的另一个方法里



static final int tableSizeFor(int cap) {

        int n = cap - 1;

        n |= n >>> 1;

        n |= n >>> 2;

        n |= n >>> 4;

        n |= n >>> 8;

        n |= n >>> 16;

        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;

    }

不过不太看得懂

Surrin1999 2018-08-24

打赏
举报

引用 10 楼 nayi_224 的回复:

[quote=引用 9 楼 Surrin1999 的回复:]
[quote=引用 5 楼 nayi_224 的回复:]
跟随机数没关系。

HashSet里面是HashMap，HashMap里面是数组。如果新值的hash值小于数组最大下标，会正好添加到这个下标处。而数字的hash值就是它自己。
如果hash值大于下标最大值，会有别的算法来做添加（记得是取余数）。比如对 new HashSet(4) 添加5，它会加到下标1的位置。这个时候再添加1，它会在下标1处向后添加链表。当继续添加值以致大于0.75时，会触发HashMap的resize()方法。基本就是新生成一个1.5倍长度的新数组，将原来的值重新add一遍。
for-each循环就是把这个数组顺序输出。
也就是说，你这个只是巧合而已。

举个更精辟的例子
		HashSet<Integer> hs = new HashSet<Integer>(4);



		hs.add(3);

		hs.add(5);
无序
		HashSet<Integer> hs = new HashSet<Integer>(4);



		hs.add(3);

		hs.add(5);

		hs.add(1);

		hs.add(2);
有序

您这个解释是根据JDK7的数组+链表来讲的吗以前的还能看懂现在的JDK8写的好复杂以及能说说您当时是怎么学习知道的吗文档英文看的头皮发麻看不下去

[/quote]

1.8依然有数组+链表，红黑树只是一个补充。上面这些个例子正好不会触发红黑树的代码。
也没什么学习经历，我也是今天看了你的问题才第一次打开jdk1.8HashSet的源码。跟了断点之后发现跟老版的套路一样罢了。
全面的了解一套代码真的很令人羡慕，但是时间太有限了，只关注当前用上的代码也不失为一种好方法。[/quote]

话说我想问最后一个问题那个当继续添加值以致大于负载因子0.75时重新造个数组是在哪看到的是源码中的



if (++size > threshold)

            resize();

是这句吗 threshold貌似没有初始值？我没发现哪里有涉及到负载因子

Surrin1999 2018-08-24

打赏
举报

引用 11 楼 Surrin1999 的回复:

[quote=引用 10 楼 nayi_224 的回复:]
[quote=引用 9 楼 Surrin1999 的回复:]
[quote=引用 5 楼 nayi_224 的回复:]
跟随机数没关系。

HashSet里面是HashMap，HashMap里面是数组。如果新值的hash值小于数组最大下标，会正好添加到这个下标处。而数字的hash值就是它自己。
如果hash值大于下标最大值，会有别的算法来做添加（记得是取余数）。比如对 new HashSet(4) 添加5，它会加到下标1的位置。这个时候再添加1，它会在下标1处向后添加链表。当继续添加值以致大于0.75时，会触发HashMap的resize()方法。基本就是新生成一个1.5倍长度的新数组，将原来的值重新add一遍。
for-each循环就是把这个数组顺序输出。
也就是说，你这个只是巧合而已。

举个更精辟的例子
		HashSet<Integer> hs = new HashSet<Integer>(4);



		hs.add(3);

		hs.add(5);
无序
		HashSet<Integer> hs = new HashSet<Integer>(4);



		hs.add(3);

		hs.add(5);

		hs.add(1);

		hs.add(2);
有序

您这个解释是根据JDK7的数组+链表来讲的吗以前的还能看懂现在的JDK8写的好复杂以及能说说您当时是怎么学习知道的吗文档英文看的头皮发麻看不下去



final V putVal(int hash, K key, V value, boolean onlyIfAbsent,

                   boolean evict) {

        Node<K,V>[] tab; Node<K,V> p; int n, i;

        if ((tab = table) == null || (n = tab.length) == 0)

            n = (tab = resize()).length;

        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)

            resize();

        afterNodeInsertion(evict);

        return null;

    }

[/quote]

话说我想问最后一个问题那个当继续添加值以致大于负载因子0.75时重新造个数组是在哪看到的是源码中的



if (++size > threshold)

            resize();

这句吗 threshold貌似没有初始值？我没发现哪里有涉及到负载因子

verejava 2018-08-24

打赏
举报

Java 集合之 Set

http://www.verejava.com/?id=1699456395143

Surrin1999 2018-08-24

打赏
举报

引用 10 楼 nayi_224 的回复:

[quote=引用 9 楼 Surrin1999 的回复:]
[quote=引用 5 楼 nayi_224 的回复:]
跟随机数没关系。

HashSet里面是HashMap，HashMap里面是数组。如果新值的hash值小于数组最大下标，会正好添加到这个下标处。而数字的hash值就是它自己。
如果hash值大于下标最大值，会有别的算法来做添加（记得是取余数）。比如对 new HashSet(4) 添加5，它会加到下标1的位置。这个时候再添加1，它会在下标1处向后添加链表。当继续添加值以致大于0.75时，会触发HashMap的resize()方法。基本就是新生成一个1.5倍长度的新数组，将原来的值重新add一遍。
for-each循环就是把这个数组顺序输出。
也就是说，你这个只是巧合而已。

举个更精辟的例子
		HashSet<Integer> hs = new HashSet<Integer>(4);



		hs.add(3);

		hs.add(5);
无序
		HashSet<Integer> hs = new HashSet<Integer>(4);



		hs.add(3);

		hs.add(5);

		hs.add(1);

		hs.add(2);
有序

您这个解释是根据JDK7的数组+链表来讲的吗以前的还能看懂现在的JDK8写的好复杂以及能说说您当时是怎么学习知道的吗文档英文看的头皮发麻看不下去

[/quote]

1.8依然有数组+链表，红黑树只是一个补充。上面这些个例子正好不会触发红黑树的代码。
也没什么学习经历，我也是今天看了你的问题才第一次打开jdk1.8HashSet的源码。跟了断点之后发现跟老版的套路一样罢了。
全面的了解一套代码真的很令人羡慕，但是时间太有限了，只关注当前用上的代码也不失为一种好方法。[/quote]

不用了不用了我自己看懂了那个node就是个链表。。Node [ ]就是这个数组当bigCount等于7也就是链表长度8，将链表转化为红黑树存储。。

Surrin1999 2018-08-23

打赏
举报

另外我用的是JDK8

nayi_224 2018-08-23

打赏
举报

引用 9 楼 Surrin1999 的回复:

[quote=引用 5 楼 nayi_224 的回复:]
跟随机数没关系。

HashSet里面是HashMap，HashMap里面是数组。如果新值的hash值小于数组最大下标，会正好添加到这个下标处。而数字的hash值就是它自己。
如果hash值大于下标最大值，会有别的算法来做添加（记得是取余数）。比如对 new HashSet(4) 添加5，它会加到下标1的位置。这个时候再添加1，它会在下标1处向后添加链表。当继续添加值以致大于0.75时，会触发HashMap的resize()方法。基本就是新生成一个1.5倍长度的新数组，将原来的值重新add一遍。
for-each循环就是把这个数组顺序输出。
也就是说，你这个只是巧合而已。

举个更精辟的例子
		HashSet<Integer> hs = new HashSet<Integer>(4);



		hs.add(3);

		hs.add(5);
无序
		HashSet<Integer> hs = new HashSet<Integer>(4);



		hs.add(3);

		hs.add(5);

		hs.add(1);

		hs.add(2);
有序

您这个解释是根据JDK7的数组+链表来讲的吗以前的还能看懂现在的JDK8写的好复杂以及能说说您当时是怎么学习知道的吗文档英文看的头皮发麻看不下去

Surrin1999 2018-08-23

打赏
举报

引用 5 楼 nayi_224 的回复:

跟随机数没关系。

HashSet里面是HashMap，HashMap里面是数组。如果新值的hash值小于数组最大下标，会正好添加到这个下标处。而数字的hash值就是它自己。
如果hash值大于下标最大值，会有别的算法来做添加（记得是取余数）。比如对 new HashSet(4) 添加5，它会加到下标1的位置。这个时候再添加1，它会在下标1处向后添加链表。当继续添加值以致大于0.75时，会触发HashMap的resize()方法。基本就是新生成一个1.5倍长度的新数组，将原来的值重新add一遍。
for-each循环就是把这个数组顺序输出。
也就是说，你这个只是巧合而已。

举个更精辟的例子
		HashSet<Integer> hs = new HashSet<Integer>(4);



		hs.add(3);

		hs.add(5);
无序
		HashSet<Integer> hs = new HashSet<Integer>(4);



		hs.add(3);

		hs.add(5);

		hs.add(1);

		hs.add(2);
有序

您这个解释是根据JDK7的数组+链表来讲的吗以前的还能看懂现在的JDK8写的好复杂以及能说说您当时是怎么学习知道的吗文档英文看的头皮发麻看不下去

Surrin1999 2018-08-23

打赏
举报

引用 6 楼 nayi_224 的回复:

		HashSet<Integer> hs = new HashSet<Integer>(4);



		hs.add(3);

		

		hs.add(9);

		hs.add(1);

		

		

		hs.add(2);

		HashSet<Integer> hs = new HashSet<Integer>(4);



		hs.add(3);

		

		

		hs.add(1);

		hs.add(9);

		

		hs.add(2);

要是能看懂1和9的顺序为什么会变，估计你也就懂了。

卧槽卧槽卧槽你也太特么猛了兄弟我懂了你咋知道的啊？？？现在JDK8底层数据结构变成了数组+链表+红黑树看得头都晕了

maradona1984 2018-08-23

打赏
举报

引用 4 楼 Surrin1999 的回复:

[quote=引用 3 楼 maradona1984 的回复:]
[quote=引用 2 楼 maradona1984 的回复:]
或许你可以尝试把注释的那段代码的循环次数改成100试试
hashset是基于hashmap的,5000次随机很大概率使得set的size扩容到大于1000,set的size也是影响hash方法的元素之一

set的size应该会影响key落在数组上的位置[/quote]

改为100后确实是无序了 那么从源码的角度有序无序到底是怎么回事呢？ 比如如果你for循环依次添加1到1000 最后结果肯定是自然排序的因为table数组位置是由hashcode计算而hashcode又是数值本身但随意添加无序数如我这个例子最后结果是无序的[/quote]
因为你随机5000次,随机数范围是1000,基本上等同于for循环1000了,虽然put的顺序不一样

但hashset的无序不能这么理解,只能理解为你不能指定元素顺序,treeset能指定元素顺序

nayi_224 2018-08-23

打赏
举报

		HashSet<Integer> hs = new HashSet<Integer>(4);



		hs.add(3);

		

		hs.add(9);

		hs.add(1);

		

		

		hs.add(2);

		HashSet<Integer> hs = new HashSet<Integer>(4);



		hs.add(3);

		

		

		hs.add(1);

		hs.add(9);

		

		hs.add(2);

要是能看懂1和9的顺序为什么会变，估计你也就懂了。

nayi_224 2018-08-23

打赏
举报

跟随机数没关系。

HashSet里面是HashMap，HashMap里面是数组。如果新值的hash值小于数组最大下标，会正好添加到这个下标处。而数字的hash值就是它自己。
如果hash值大于下标最大值，会有别的算法来做添加（记得是取余数）。比如对 new HashSet(4) 添加5，它会加到下标1的位置。这个时候再添加1，它会在下标1处向后添加链表。当继续添加值以致大于0.75时，会触发HashMap的resize()方法。基本就是新生成一个1.5倍长度的新数组，将原来的值重新add一遍。
for-each循环就是把这个数组顺序输出。
也就是说，你这个只是巧合而已。

举个更精辟的例子

		HashSet<Integer> hs = new HashSet<Integer>(4);



		hs.add(3);

		hs.add(5);

无序

		HashSet<Integer> hs = new HashSet<Integer>(4);



		hs.add(3);

		hs.add(5);

		hs.add(1);

		hs.add(2);

有序

Java容器有两种容器：一个是Collection容器，存放对象的集合；另一种是Map容器，存放键值对(Key-value)集合 Collection容器从图上我们可以看到Collection接口下有三个儿子，分别是Set，List，Queue；下面我来逐个介绍。 Set Set集合看重的是独一无二，就是没有重复的值。 HashSet：基于哈希表实现，支持快速查找，但是不支持有序，就是插入的数据遍历出来是无序的。 LinkedHashSet：具有HashSet查找效率，同时前后链维持数据的插入顺序。 TreeSet：基于红黑树实现，支持有序性操作。 List List集合看重的是有序，同

该课程内容包括：Collection集合的继承体系、Map集合的集合体系、部分数据结构知识点、List、Set、ArrayList、Vector、LinkedList、Iterator（迭代器）、TreeSet、HashSet、LinkedHashSet、TreeSet、Map、TreeMap、...

HashSet 是否无序 (一) 问题起因：《Core Java Volume I—Fundamentals》中对HashSet的描述是这样的： HashSet：一种没有重复元素的无序集合解释：我们一般说HashSet是无序的，它既不能保证存储和取出顺序一致，更不能保证自然顺序（a-z）下面是《Thinking in Java》中的使用Integer对象的HashSet的示例 ...

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录HashSet有序还是无序，如何改为顺序输出一、HashSet对于Integer包装类型有序二、对于引用类型，如何进行顺序输出 HashSet有序还是无序，如何改为顺序输出众所周知，HashSet本质就是HashMap的实现，只取用了其中的Key值。根据这点可以分析出： 1、HashSet支持null值 2、HashSet不支持重复key值 3、HashSet的key会通过hashcode()方法的返回值决定存放位置一、Ha

Java SE

62,614

社区成员

307,326

社区内容

发帖

与我相关

我的任务

社区管理员

加入社区

近7日
近30日
至今

加载中

查看更多榜单

社区公告

暂无公告

试试用AI创作助手写篇文章吧

+ 用AI写文章