blocks|key|3975422|text|顺序由Hash+Map/Set中使用的哈希算法、该Map的确切设置和对象的Hashcode确定。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3975423|如果您的对象在多次运行时具有一致的哈希码(例如字符串)，并且以相同的顺序放入具有相同设置的映射中，那么通常它们每次都会以相同的顺序出现。如果他们不这样做，那么他们就不会这么做。|3975424|在这里可以看到HashMap的源代码：http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/util/HashMap.java|offset|length|3975425|事实上，该来源中的一句有趣的话是：|3975426|3975427|这个类不能保证映射的顺序；特别是，它不能保证顺序随着时间的推移保持不变。|blockquote|3975428|3975429|3975430|因此，不仅您的程序每次运行时顺序可能不同，而且事实上，API本身也不能保证即使在程序的一次运行中，顺序也将保持不变！|3975431|“不确定且有点奇怪”是对HashMap排序的一个很好的描述--实际上文档上也是这么说的。如果您想要排序，请使用LinkedHashMap或TreeMap。如果你不想要排序，那么不用担心，通过有效地随机排序，HashMap可以从它所保证的方法的行为中给你极快的响应！|style|CODE|3975432|entityMap|0|LINK|mutability|MUTABLE|url|http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/util/HashMap.java^0|0|0|J|2R|0|0|0|0|0|0|0|0|C|7|1J|D|1X|7|2V|7|0^^$0|@$1|2|3|4|5|6|7|13|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|14|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|15|8|@]|9|@$F|16|G|17|1|18]]|A|$]]|$1|H|3|I|5|6|7|19|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|K|3|L|5|M|7|1B|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1E|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|1F|8|@$F|1G|G|1H|T|U]|$F|1I|G|1J|T|U]|$F|1K|G|1L|T|U]|$F|1M|G|1N|T|U]]|9|@]|A|$]]|$1|V|3|-4|5|6|7|1O|8|@]|9|@]|A|$]]]|W|$X|$5|Y|Z|10|A|$11|12]]]]

The order is determined by the Hashing algorithm used within the Hash Map/Set, the exact settings of that Map and the Hashcodes of the objects.

If your objects have consistent hashcodes over multiple runs (Strings for example) and are placed in the same order into a map with the same settings then in general they would come out in the same order each time. If they don't then they won't.

The source for HashMap can be seen here: <a href="http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/util/HashMap.java" rel="nofollow">http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/util/HashMap.java</a>

In fact an interesting quote from that source is:

<blockquote>
 This class makes no guarantees as to the order of the map; in particular, it does not guarantee that the order will remain constant over time. 
</blockquote>

So not only may the order be different each time your program runs, but in fact the API itself makes no guarantee that the order will remain constant even inside one run of the program!

"Un-deterministic and a bit weird" is a good description of ordering of a <code>HashMap</code> - and is actually pretty much what the docs say. If you want ordering use either <code>LinkedHashMap</code> or <code>TreeMap</code>. If you don't want ordering then don't worry about it, by having the ordering being effectively random <code>HashMap</code> is giving you extremely fast responses from the methods who's behavior it does guarantee!

blocks|key|2610493|text|只有HashSet保持和garatuees没有顺序，甚至没有任意顺序(Why+can+hashCode()+return+the+same+value+for+different+objects+in+Java?)！不要在那里强行下单！序列化和反序列化它们，原始的顺序将被销毁。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2610494|使用LinkedHashSet而不是HashSet。|2610495|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/4360035/why-hashcode-can-return-the-same-value-for-different-objects-in-java^0|Z|1Z|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

Only HashSet keeps and garatuees no order, even no arbitrary order (<a href="https://stackoverflow.com/questions/4360035/why-hashcode-can-return-the-same-value-for-different-objects-in-java">Why can hashCode() return the same value for different objects in Java?</a>)! Dont force an order there! 
Serialize and Deserialize them and the original order will be destroyed.

Use LinkedHashSet instead of HashSet.

blocks|key|194923|text|原则上有两个因素：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|194924|您的密钥的|194925|哈希码可能是不确定的，当您使用依赖于内存的默认hashCode实现时就是这种情况location|ordered-list-item|194926|HashSet本身可能是不确定的，看看HashMap.initHashSeedAsNeeded+(HashSet使用标准Oracle+SDK中的HashMap作为底层数据结构)，这取决于它可以使用sun.misc.Hashing.randomHashSeed(this)初始化hashSeed字段，然后在计算key|offset|length|style|CODE|194927|的hashCode时使用该字段|194928|随机化对于实现概率性能保证可能很重要。这就是javadoc对hashSeed的描述：|194929|194930|+/**+*与此实例关联的随机化值，应用于|blockquote|194931|194932|*键的散列代码，使散列冲突更难发现。如果为0，则|194933|*禁用备用哈希。*/|194934|entityMap^0|0|0|0|J|S|2Q|11|3U|8|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|12|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|13|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|14|8|@$I|15|J|16|K|L]|$I|17|J|18|K|L]|$I|19|J|1A|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|1B|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1C|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]|$1|R|3|S|5|T|7|1E|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]|$1|V|3|W|5|6|7|1G|8|@]|9|@]|A|$]]|$1|X|3|Y|5|6|7|1H|8|@]|9|@]|A|$]]|$1|Z|3|-4|5|6|7|1I|8|@]|9|@]|A|$]]]|10|$]]

In principle there are two contributing factors: 

<ol>
<li>Hashcode of your keys might be non-deterministic, this will be the case when you use default hashCode implementation, which relies on memory location</li>
<li>HashSet itself can be non deterministic, take a look at <code>HashMap.initHashSeedAsNeeded</code> (HashSet uses HashMap in standard Oracle SDK as underlying datastructure), depending on some factors it can use <code>sun.misc.Hashing.randomHashSeed(this)</code> to initialize <code>hashSeed</code> field which is then used when computing hashCode of a key</li>
</ol>

Randomization can be important to achieve probabilistic performance guaranties.
This is what javadoc says for hashSeed:

<blockquote>
 /**
 * A randomizing value associated with this instance that is applied to 
 * hash code of keys to make hash collisions harder to find. If 0 then 
 * alternative hashing is disabled.
 */
</blockquote>

blocks|key|698783|text|除非您在HashSet中添加/删除某些内容，否则顺序不会更改(实际上)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|698784|该顺序基于内部hashtable存储桶。这取决于对象的hashCode()和哈希表的大小。|698785|简化示例：|698786|A的哈希码为10，B的hashcode为11。哈希表的大小为2。哈希码到哈希表中的位置的映射将纯粹基于最后一位，即偶数哈希码进入表，奇数哈希码进入table1。|698787|table[0]+=+{+A+}
table[1]+=+{+B+}|code-block|syntax|javascript|698788|迭代这些值现在很可能是A，B。只要表的大小保持不变，每次结果都应该是可重现的。|698789|使用hashCode+12添加第三个元素C(当不调整表大小时)也会将其添加到bucket+#0中。|698790|table[0]+=+{+A,+C+}
table[1]+=+{+B+}|698791|因此，您的迭代将是A，C，B，或者取决于您是否在C之前插入A:+C，A，B|698792|添加元素实际上会调整表的大小，并使用调整后的映射重新散列。例如，表的大小将加倍，并且最后2位可用于确定桶|698793|table[0]+=+{+C+}
table[1]+=+{+++}
table[2]+=+{+A+}
table[3]+=+{+B+}|698794|而且只需添加一个元素，顺序就会完全改变。|698795|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Hash_table^0|4|7|0|R|A|7|9|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1C|8|@$9|1D|A|1E|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1F|8|@$9|1G|A|1H|B|C]]|D|@$9|1I|A|1J|1|1K]]|E|$]]|$1|H|3|I|5|6|7|1L|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|1M|8|@]|D|@]|E|$]]|$1|L|3|M|5|N|7|1N|8|@]|D|@]|E|$O|P]]|$1|Q|3|R|5|6|7|1O|8|@]|D|@]|E|$]]|$1|S|3|T|5|6|7|1P|8|@]|D|@]|E|$]]|$1|U|3|V|5|N|7|1Q|8|@]|D|@]|E|$O|P]]|$1|W|3|X|5|6|7|1R|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|6|7|1S|8|@]|D|@]|E|$]]|$1|10|3|11|5|N|7|1T|8|@]|D|@]|E|$O|P]]|$1|12|3|13|5|6|7|1U|8|@]|D|@]|E|$]]|$1|14|3|-4|5|6|7|1V|8|@]|D|@]|E|$]]]|15|$16|$5|17|18|19|E|$1A|1B]]]]

The order will not change (in practice) unless you add / remove something to your <code>HashSet</code>.

The order is based on the internal <a href="http://en.wikipedia.org/wiki/Hash_table" rel="nofollow">hashtable</a> buckets. And that depends on both the <code>hashCode()</code> of an object and the size of the hashtable.

Simplified example:

A's hashcode is 10, B's hashCode is 11. The hastable has size 2.
The mapping from hash code to position in hashtable would be purely based on the last bit, i.e. even hashcodes go into table[0], odd ones into table[1].

<pre><code>table[0] = { A }
table[1] = { B }
</code></pre>

Iterating over those values would most likely be A, B now. And that result should be reproducible each time as long as table size stays the same.

Adding a third element C with hashCode 12 would (when not resizing the table) add it to bucket #0 as well.

<pre><code>table[0] = { A, C }
table[1] = { B }
</code></pre>

So your iteration would be A, C, B. Or depending in whether you inserted A before C: C, A, B

Adding elements will in practice resize the table and re-hash using an adjusted mapping. E.g. table size would be doubled and the last 2 bits could be used to determine the bucket

<pre><code>table[0] = { C }
table[1] = { }
table[2] = { A }
table[3] = { B }
</code></pre>

And the order would have changed completely by adding just 1 element.

I understand that the order of elements in a HashSet is supposed to be arbitrary. But out of curiosity, could anyone tell me exactly how the order is determined?

I noticed that when I insert two elements (say A and B), the order would come out <code>A, B</code>, then re-executing the same code again would give me <code>B, A</code>, then re-excecuting it the third time would give me <code>A, B</code>. 

I mean, that's kind of un-deterministic, and a bit weird.

How does the order of elements in a HashSet work?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我知道HashSet中元素的顺序应该是任意的。但出于好奇，有人能告诉我顺序是如何确定的吗？我注意到，当我插入两个元素(例如A和B)时，顺序将为A, B，然后再次重新执行相同的代码将得到B, A，然后第三次重新执行它将得到A, B。我的意思是，这有点不确定，而且有点奇怪。

问HashSet中元素的顺序是如何工作的？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问HashSet中元素的顺序是如何工作的？EN