blocks|key|321304|text|Map的API不保证任何排序，即使在同一对象上多次调用该方法时也是如此。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|321305|在实践中，如果多次后续调用的迭代顺序发生变化(假设map本身在这两次调用之间没有变化)，我会感到非常惊讶-但您不应该(并且根据API不能)依赖这一点。|321306|编辑-如果你想依赖于迭代顺序是一致的，那么你需要一个能够提供这些保证的SortedMap。|offset|length|321307|entityMap|0|LINK|mutability|MUTABLE|url|http://java.sun.com/javase/6/docs/api/java/util/SortedMap.html^0|0|0|Z|9|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@$F|S|G|T|1|U]]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

The API for Map does not guarantee any ordering whatsoever, even between multiple invocations of the method on the same object.

In practice I would be very surprised if the iteration order changed for multiple subsequent invocations (assuming the map itself did not change in between) - but you should not (and according to the API cannot) rely on this.

EDIT - if you want to rely on the iteration order being consistent, then you want a <a href="http://java.sun.com/javase/6/docs/api/java/util/SortedMap.html" rel="noreferrer">SortedMap</a> which provides exactly these guarantees.

blocks|key|323712|text|从逻辑上讲，如果合同说“没有特定的顺序是有保证的”，并且由于“它一次出现的顺序”是一个特定的顺序，那么答案是否定的，你不能指望它以相同的方式出现两次。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|323713|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Logically, if the contract says "no particular order is guaranteed", and since "the order it came out one time" is a particular order, then the answer is no, you can't depend on it coming out the same way twice.

blocks|key|3288090|text|Hashmap不能保证map的顺序随着时间的推移保持不变。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3288091|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Hashmap does not guarantee that the order of the map will remain constant over time.

blocks|key|3288098|text|这并不是必须的。映射的keySet函数返回一个集合，该集合的迭代器方法在其文档中说明了这一点：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3288099|“返回此集合中元素的迭代器。元素不按特定顺序返回(除非此集合是某个提供保证的类的实例)。”|3288100|因此，除非您正在使用其中一个有保证的类，否则没有任何类。|3288101|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

It doesn't have to be. A map's keySet function returns a Set and the set's iterator method says this in its documentation:

"Returns an iterator over the elements in this set. The elements are returned in no particular order (unless this set is an instance of some class that provides a guarantee)."

So, unless you are using one of those classes with a guarantee, there is none.

blocks|key|323153|text|如果在API文档中没有声明它是有保证的，那么您就不应该依赖它。这种行为甚至可能在JDK的不同版本之间发生变化，甚至在同一供应商的JDK中也是如此。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|323154|您可以轻松地获取集合，然后自己对其进行排序，对吗？|323155|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

If it is not stated to be guaranteed in the API documentation, then you shouldn't depend on it. The behavior might even change from one release of the JDK to the next, even from the same vendor's JDK.

You could easily get the set and then just sort it yourself, right?

blocks|key|321354|text|Map是一个接口，它在文档中没有定义顺序应该是相同的。这意味着你不能依赖顺序。但是如果您控制由getMap()返回的映射实现，那么您可以使用LinkedHashMap或TreeMap，并在遍历它们时始终获得相同的键/值顺序。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|321355|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Map is an interface and it does not define in the documentation that order should be the same. That means that you can't rely on the order. But if you control Map implementation returned by the getMap(), then you can use LinkedHashMap or TreeMap and get the same order of keys/values all the time you iterate through them.

blocks|key|3074813|text|Map只是一个接口(而不是一个类)，这意味着实现它的底层类(有很多)可能会有不同的行为，并且keySet()的约定并不表明需要一致的迭代。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3074814|如果你正在看一个实现映射(HashMap，LinkedHashMap，TreeMap等)的特定类，那么你可以看到它是如何实现keySet()函数的，通过检出源代码来确定行为是什么，你必须真正仔细观察算法，看看你正在寻找的属性是否被保留(即，当映射在迭代之间没有任何插入/删除时，一致的迭代顺序)。例如，HashMap的源代码在这里(打开JDK6)：http://www.docjar.com/html/api/java/util/HashMap.java.html|offset|length|3074815|从一个JDK到另一个JDK，它可能有很大的不同，所以我肯定不会依赖它。|3074816|也就是说，如果一致的迭代顺序是您真正需要的，那么您可能想尝试一下LinkedHashMap。|3074817|entityMap|0|LINK|mutability|MUTABLE|url|http://www.docjar.com/html/api/java/util/HashMap.java.html^0|0|4U|1M|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@$D|T|E|U|1|V]]|A|$]]|$1|F|3|G|5|6|7|W|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|X|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q]]]]

Map is only an interface (rather than a class), which means that the underlying class that implements it (and there are many) could behave differently, and the contract for keySet() in the API does not indicate that consistent iteration is required. 

If you are looking at a specific class that implements Map (HashMap, LinkedHashMap, TreeMap, etc) then you could see how it implements the keySet() function to determine what the behaviour would be by checking out the source, you'd have to really take a close look at the algorithm to see if the property you are looking for is preserved (that is, consistent iteration order when the map has not had any insertions/removals between iterations). The source for HashMap, for example, is here (open JDK 6): <a href="http://www.docjar.com/html/api/java/util/HashMap.java.html" rel="noreferrer">http://www.docjar.com/html/api/java/util/HashMap.java.html</a>

It could vary widely from one JDK to the next, so i definitely wouldn't rely on it.

That being said, if consistent iteration order is something you really need, you might want to try a LinkedHashMap.

blocks|key|3074939|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3074940|您还可以包装Map+(或Set)，让它们返回RandomeIterator，这样就可以使用for-each循环。|3074941|import+java.util.ArrayList;
import+java.util.Collections;
import+java.util.HashMap;
import+java.util.Iterator;
import+java.util.List;
import+java.util.Map;

public+class+Main
{
++++private+Main()
++++{
++++}

++++public+static+void+main(final+String[]+args)
++++{
++++++++final+Map<String,+String>+items;

++++++++items+=+new+HashMap<String,+String>();
++++++++items.put("A",+"1");
++++++++items.put("B",+"2");
++++++++items.put("C",+"3");
++++++++items.put("D",+"4");
++++++++items.put("E",+"5");
++++++++items.put("F",+"6");
++++++++items.put("G",+"7");

++++++++display(items.keySet().iterator());
++++++++System.out.println("---");

++++++++display(items.keySet().iterator());
++++++++System.out.println("---");

++++++++display(new+RandomIterator<String>(items.keySet().iterator()));
++++++++System.out.println("---");

++++++++display(new+RandomIterator<String>(items.keySet().iterator()));
++++++++System.out.println("---");
++++}

++++private+static+<T>+void+display(final+Iterator<T>+iterator)
++++{
++++++++while(iterator.hasNext())
++++++++{
++++++++++++final+T+item;

++++++++++++item+=+iterator.next();
++++++++++++System.out.println(item);
++++++++}
++++}
}

class+RandomIterator<T>
++++implements+Iterator<T>
{
++++private+final+Iterator<T>+iterator;

++++public+RandomIterator(final+Iterator<T>+i)
++++{
++++++++final+List<T>+items;

++++++++items+=+new+ArrayList<T>();

++++++++while(i.hasNext())
++++++++{
++++++++++++final+T+item;

++++++++++++item+=+i.next();
++++++++++++items.add(item);
++++++++}

++++++++Collections.shuffle(items);
++++++++iterator+=+items.iterator();
++++}

++++public+boolean+hasNext()
++++{
++++++++return+(iterator.hasNext());
++++}

++++public+T+next()
++++{
++++++++return+(iterator.next());
++++}

++++public+void+remove()
++++{
++++++++iterator.remove();
++++}
}|code-block|syntax|javascript|3074942|entityMap^0|0|0|0^^$0|@$1|2|3|-4|4|5|6|J|7|@]|8|@]|9|$]]|$1|A|3|B|4|5|6|K|7|@]|8|@]|9|$]]|$1|C|3|D|4|E|6|L|7|@]|8|@]|9|$F|G]]|$1|H|3|-4|4|5|6|M|7|@]|8|@]|9|$]]]|I|$]]

Just for fun, I decided to write some code that you can use to guarantee a random order each time. This is useful so that you can catch cases where you are depending on the order but you should not be. If you want to depend on the order, than as others have said, you should use a SortedMap. If you just use a Map and happen to rely on the order then using the following RandomIterator will catch that. I'd only use it in testing code since it makes use of more memory then not doing it would. 

You could also wrap the Map (or the Set) to have them return the RandomeIterator which would then let you use the for-each loop.

<pre><code>import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

public class Main
{
 private Main()
 {
 }

 public static void main(final String[] args)
 {
 final Map&lt;String, String&gt; items;

 items = new HashMap&lt;String, String&gt;();
 items.put("A", "1");
 items.put("B", "2");
 items.put("C", "3");
 items.put("D", "4");
 items.put("E", "5");
 items.put("F", "6");
 items.put("G", "7");

 display(items.keySet().iterator());
 System.out.println("---");

 display(items.keySet().iterator());
 System.out.println("---");

 display(new RandomIterator&lt;String&gt;(items.keySet().iterator()));
 System.out.println("---");

 display(new RandomIterator&lt;String&gt;(items.keySet().iterator()));
 System.out.println("---");
 }

 private static &lt;T&gt; void display(final Iterator&lt;T&gt; iterator)
 {
 while(iterator.hasNext())
 {
 final T item;

 item = iterator.next();
 System.out.println(item);
 }
 }
}

class RandomIterator&lt;T&gt;
 implements Iterator&lt;T&gt;
{
 private final Iterator&lt;T&gt; iterator;

 public RandomIterator(final Iterator&lt;T&gt; i)
 {
 final List&lt;T&gt; items;

 items = new ArrayList&lt;T&gt;();

 while(i.hasNext())
 {
 final T item;

 item = i.next();
 items.add(item);
 }

 Collections.shuffle(items);
 iterator = items.iterator();
 }

 public boolean hasNext()
 {
 return (iterator.hasNext());
 }

 public T next()
 {
 return (iterator.next());
 }

 public void remove()
 {
 iterator.remove();
 }
}
</code></pre>

blocks|key|323877|text|如果您想要一个迭代顺序不变的LinkedHashMap，您可以使用HashMap。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|323878|此外，如果您遍历集合，则应该始终使用它。在HashMap的entrySet或keySet上迭代要比在LinkedHashMap上慢得多。|323879|entityMap|0|LINK|mutability|MUTABLE|url|http://download.oracle.com/javase/6/docs/api/java/util/LinkedHashMap.html^0|E|D|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]]]]

You can use a <a href="http://download.oracle.com/javase/6/docs/api/java/util/LinkedHashMap.html" rel="noreferrer">LinkedHashMap</a> if you want a HashMap whose iteration order does not change.

Moreover you should always use it if you iterate through the collection. Iterating over HashMap's entrySet or keySet is much slower than over LinkedHashMap's.

blocks|key|323303|text|我同意LinkedHashMap的观点。我只是把我的发现和经验放在我试图按键对HashMap排序时遇到的问题上。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|323304|我创建HashMap的代码：|323305|HashMap<Integer,+String>+map;

@Before
public+void+initData()+{
++++map+=+new+HashMap<>();

++++map.put(55,+"John");
++++map.put(22,+"Apple");
++++map.put(66,+"Earl");
++++map.put(77,+"Pearl");
++++map.put(12,+"George");
++++map.put(6,+"Rocky");

}|code-block|syntax|javascript|323306|我有一个打印地图条目的函数showMap：|323307|public+void+showMap+(Map<Integer,+String>+map1)+{
++++for+(Map.Entry<Integer,++String>+entry:+map1.entrySet())+{
++++++++System.out.println("[Key:+"%2Bentry.getKey()%2B+"+,+"%2B"Value:+"%2Bentry.getValue()+%2B"]+");

++++}

}|323308|现在，当我在排序前打印映射时，它打印以下顺序：|323309|Map+before+sorting+:+
[Key:+66+,+Value:+Earl]+
[Key:+22+,+Value:+Apple]+
[Key:+6+,+Value:+Rocky]+
[Key:+55+,+Value:+John]+
[Key:+12+,+Value:+George]+
[Key:+77+,+Value:+Pearl]+|323310|这基本上与放置映射键的顺序不同。|323311|现在，当我使用映射键对其进行排序时：|323312|++++List<Map.Entry<Integer,+String>>+entries+=+new+ArrayList<>(map.entrySet());

++++Collections.sort(entries,+new+Comparator<Entry<Integer,+String>>()+{

++++++++@Override
++++++++public+int+compare(Entry<Integer,+String>+o1,+Entry<Integer,+String>+o2)+{

++++++++++++return+o1.getKey().compareTo(o2.getKey());
++++++++}
++++});

++++HashMap<Integer,+String>+sortedMap+=+new+LinkedHashMap<>();

++++for+(Map.Entry<Integer,+String>+entry+:+entries)+{
++++++++System.out.println("Putting+key:"%2Bentry.getKey());
++++++++sortedMap.put(entry.getKey(),+entry.getValue());
++++}

++++System.out.println("Map+after+sorting:");

++++showMap(sortedMap);|323313|输出结果是：|323314|Sorting+by+keys+:+
Putting+key:6
Putting+key:12
Putting+key:22
Putting+key:55
Putting+key:66
Putting+key:77
Map+after+sorting:
[Key:+66+,+Value:+Earl]+
[Key:+6+,+Value:+Rocky]+
[Key:+22+,+Value:+Apple]+
[Key:+55+,+Value:+John]+
[Key:+12+,+Value:+George]+
[Key:+77+,+Value:+Pearl]+|323315|您可以看到键的顺序的不同。键的排序顺序很好，但复制的map的键的排序顺序与先前map的顺序相同。我不知道这是否有效，但对于具有相同键的两个hashmap，键的顺序是相同的。这意味着不能保证键的顺序，但对于具有相同键的两个映射，由于键插入算法的固有性质，如果这个版本的HashMap实现的话，键的顺序可以是相同的。|323316|现在，当我使用LinkedHashMap将排序的条目复制到HashMap时，我会得到所需的结果(这是很自然的，但这不是重点。重点是关于HashMap的键的顺序)|323317|++++HashMap<Integer,+String>+sortedMap+=+new+LinkedHashMap<>();

++++for+(Map.Entry<Integer,+String>+entry+:+entries)+{
++++++++System.out.println("Putting+key:"%2Bentry.getKey());
++++++++sortedMap.put(entry.getKey(),+entry.getValue());
++++}

++++System.out.println("Map+after+sorting:");

++++showMap(sortedMap);|323318|输出：|323319|Sorting+by+keys+:+
Putting+key:6
Putting+key:12
Putting+key:22
Putting+key:55
Putting+key:66
Putting+key:77
Map+after+sorting:
[Key:+6+,+Value:+Rocky]+
[Key:+12+,+Value:+George]+
[Key:+22+,+Value:+Apple]+
[Key:+55+,+Value:+John]+
[Key:+66+,+Value:+Earl]+
[Key:+77+,+Value:+Pearl]+|323320|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1D|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1E|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|1F|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|1G|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|1H|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|1I|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|1J|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1K|8|@]|9|@]|A|$]]|$1|U|3|V|5|F|7|1L|8|@]|9|@]|A|$G|H]]|$1|W|3|X|5|6|7|1M|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|F|7|1N|8|@]|9|@]|A|$G|H]]|$1|10|3|11|5|6|7|1O|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|1P|8|@]|9|@]|A|$]]|$1|14|3|15|5|F|7|1Q|8|@]|9|@]|A|$G|H]]|$1|16|3|17|5|6|7|1R|8|@]|9|@]|A|$]]|$1|18|3|19|5|F|7|1S|8|@]|9|@]|A|$G|H]]|$1|1A|3|-4|5|6|7|1T|8|@]|9|@]|A|$]]]|1B|$]]

I agree with LinkedHashMap thing. Just putting my findings and experience while I was facing the problem when I was trying to sort HashMap by keys. 

My code to create HashMap: 

<pre><code>HashMap&lt;Integer, String&gt; map;

@Before
public void initData() {
 map = new HashMap&lt;&gt;();

 map.put(55, "John");
 map.put(22, "Apple");
 map.put(66, "Earl");
 map.put(77, "Pearl");
 map.put(12, "George");
 map.put(6, "Rocky");

}
</code></pre>

I have a function showMap which prints entries of map: 

<pre><code>public void showMap (Map&lt;Integer, String&gt; map1) {
 for (Map.Entry&lt;Integer, String&gt; entry: map1.entrySet()) {
 System.out.println("[Key: "+entry.getKey()+ " , "+"Value: "+entry.getValue() +"] ");

 }

}
</code></pre>

Now when I print the map before sorting, it prints following sequence: 

<pre><code>Map before sorting : 
[Key: 66 , Value: Earl] 
[Key: 22 , Value: Apple] 
[Key: 6 , Value: Rocky] 
[Key: 55 , Value: John] 
[Key: 12 , Value: George] 
[Key: 77 , Value: Pearl] 
</code></pre>

Which is basically different than the order in which map keys were put. 

Now When I sort it with map keys: 

<pre><code> List&lt;Map.Entry&lt;Integer, String&gt;&gt; entries = new ArrayList&lt;&gt;(map.entrySet());

 Collections.sort(entries, new Comparator&lt;Entry&lt;Integer, String&gt;&gt;() {

 @Override
 public int compare(Entry&lt;Integer, String&gt; o1, Entry&lt;Integer, String&gt; o2) {

 return o1.getKey().compareTo(o2.getKey());
 }
 });

 HashMap&lt;Integer, String&gt; sortedMap = new LinkedHashMap&lt;&gt;();

 for (Map.Entry&lt;Integer, String&gt; entry : entries) {
 System.out.println("Putting key:"+entry.getKey());
 sortedMap.put(entry.getKey(), entry.getValue());
 }

 System.out.println("Map after sorting:");

 showMap(sortedMap);
</code></pre>

the out put is: 

<pre><code>Sorting by keys : 
Putting key:6
Putting key:12
Putting key:22
Putting key:55
Putting key:66
Putting key:77
Map after sorting:
[Key: 66 , Value: Earl] 
[Key: 6 , Value: Rocky] 
[Key: 22 , Value: Apple] 
[Key: 55 , Value: John] 
[Key: 12 , Value: George] 
[Key: 77 , Value: Pearl] 
</code></pre>

You can see the difference in order of keys. Sorted order of keys is fine but that of keys of copied map is again in the same order of the earlier map. I dont know if this is valid to say, but for two hashmap with same keys, order of keys is same. This implies to the statement that order of keys is not guaranteed but can be same for two maps with same keys because of inherent nature of key insertion algorithm if HashMap implementation of this JVM version. 

Now when I use LinkedHashMap to copy sorted Entries to HashMap, I get desired result (which was natural, but that is not the point. Point is regarding order of keys of HashMap)

<pre><code> HashMap&lt;Integer, String&gt; sortedMap = new LinkedHashMap&lt;&gt;();

 for (Map.Entry&lt;Integer, String&gt; entry : entries) {
 System.out.println("Putting key:"+entry.getKey());
 sortedMap.put(entry.getKey(), entry.getValue());
 }

 System.out.println("Map after sorting:");

 showMap(sortedMap);
</code></pre>

Output: 

<pre><code>Sorting by keys : 
Putting key:6
Putting key:12
Putting key:22
Putting key:55
Putting key:66
Putting key:77
Map after sorting:
[Key: 6 , Value: Rocky] 
[Key: 12 , Value: George] 
[Key: 22 , Value: Apple] 
[Key: 55 , Value: John] 
[Key: 66 , Value: Earl] 
[Key: 77 , Value: Pearl] 
</code></pre>

blocks|key|323936|text|您还可以存储由keySet()方法返回的Set实例，并且可以在需要相同顺序时使用此实例。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|323937|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

You also can store the Set instance returned by the keySet() method and can use this instance whenever you need the same order.

blocks|key|3288573|text|tl;dr是。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3288574|3288575|我相信.keySet()和.values()的迭代顺序是一致的(Java8)。|CODE|3288576|证明1：我们用随机密钥和随机值加载HashMap。我们使用.keySet()在这个HashMap上迭代，并将键和它的相应值加载到一个LinkedHashMap中(它将保持插入的键和值的顺序)。然后我们比较两个Map的.keySet()和两个Map的.values()。它总是一样的，永远不会失败。|3288577|public+class+Sample3+{

++++static+final+String+AB+=+"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
++++static+SecureRandom+rnd+=+new+SecureRandom();

++++//+from+here:+https://stackoverflow.com/a/157202/8430155
++++static+String+randomString(int+len){
++++++++StringBuilder+sb+=+new+StringBuilder(len);
++++++++for+(int+i+=+0;+i+<+len;+i%2B%2B)+{
++++++++++++sb.append(AB.charAt(rnd.nextInt(AB.length())));
++++++++}
++++++++return+sb.toString();
++++}

++++public+static+void+main(String[]+args)+throws+Exception+{
++++++++for+(int+j+=+0;+j+<+10;+j%2B%2B)+{
++++++++++++Map<String,+String>+map+=+new+HashMap<>();
++++++++++++Map<String,+String>+linkedMap+=+new+LinkedHashMap<>();

++++++++++++for+(int+i+=+0;+i+<+1000;+i%2B%2B)+{
++++++++++++++++String+key+=+randomString(8);
++++++++++++++++String+value+=+randomString(8);
++++++++++++++++map.put(key,+value);
++++++++++++}

++++++++++++for+(String+k+:+map.keySet())+{
++++++++++++++++linkedMap.put(k,+map.get(k));
++++++++++++}

++++++++++++if+(!(map.keySet().toString().equals(linkedMap.keySet().toString())+&&
++++++++++++++++++map.values().toString().equals(linkedMap.values().toString())))+{
++++++++++++++++//+never+fails
++++++++++++++++System.out.println("Failed");
++++++++++++++++break;
++++++++++++}
++++++++}
++++}
}|code-block|syntax|javascript|3288578|3288579|证明2：来自here的table是Node<K,V>类的数组。我们知道每次迭代数组都会得到相同的结果。|3288580|/**
+*+The+table,+initialized+on+first+use,+and+resized+as
+*+necessary.+When+allocated,+length+is+always+a+power+of+two.
+*+(We+also+tolerate+length+zero+in+some+operations+to+allow
+*+bootstrapping+mechanics+that+are+currently+not+needed.)
+*/
transient+Node<K,V>[]+table;|3288581|负责.values()的类|3288582|final+class+Values+extends+AbstractCollection<V>+{
++++
++++//+more+code+here

++++public+final+void+forEach(Consumer<?+super+V>+action)+{
++++++++Node<K,V>[]+tab;
++++++++if+(action+==+null)
++++++++++++throw+new+NullPointerException();
++++++++if+(size+>+0+&&+(tab+=+table)+!=+null)+{
++++++++++++int+mc+=+modCount;
++++++++++++for+(int+i+=+0;+i+<+tab.length;+%2B%2Bi)+{
++++++++++++++++for+(Node<K,V>+e+=+tab[i];+e+!=+null;+e+=+e.next)
++++++++++++++++++++action.accept(e.value);
++++++++++++}
++++++++++++if+(modCount+!=+mc)
++++++++++++++++throw+new+ConcurrentModificationException();
++++++++}
++++}
}|3288583|负责.keySet()的类|3288584|final+class+KeySet+extends+AbstractSet<K>+{

++++//+more+code+here

++++public+final+void+forEach(Consumer<?+super+K>+action)+{
++++++++Node<K,V>[]+tab;
++++++++if+(action+==+null)
++++++++++++throw+new+NullPointerException();
++++++++if+(size+>+0+&&+(tab+=+table)+!=+null)+{
++++++++++++int+mc+=+modCount;
++++++++++++for+(int+i+=+0;+i+<+tab.length;+%2B%2Bi)+{
++++++++++++++++for+(Node<K,V>+e+=+tab[i];+e+!=+null;+e+=+e.next)
++++++++++++++++++++action.accept(e.key);
++++++++++++}
++++++++++++if+(modCount+!=+mc)
++++++++++++++++throw+new+ConcurrentModificationException();
++++++++}
++++}
}|3288585|仔细查看这两个内部类。它们几乎是相同的，除了：|3288586|if+(size+>+0+&&+(tab+=+table)+!=+null)+{
++++int+mc+=+modCount;
++++for+(int+i+=+0;+i+<+tab.length;+%2B%2Bi)+{
++++++++for+(Node<K,V>+e+=+tab[i];+e+!=+null;+e+=+e.next)
++++++++++++action.accept(e.key);+++++++++++++++<-+from+KeySet+class
++++++++++++//+action.accept(e.value);++++++++++<-+the+only+change+from+Values+class
++++}
++++if+(modCount+!=+mc)
++++++++throw+new+ConcurrentModificationException();
}|3288587|它们在相同的数组table上迭代以支持KeySet类中的.keySet()和Values类中的.values()。|3288588|3288589|证明3：this+answer还明确声明-所以，keySet()、values()和entrySet()以内部链表使用的顺序返回值。|3288590|因此，+.keySet()+和是一致的。|3288591|entityMap|0|LINK|mutability|MUTABLE|url|http://hg.openjdk.java.net/jdk8/jdk8/jdk/file/687fd7c7986d/src/share/classes/java/util/HashMap.java|1|https://stackoverflow.com/questions/2923856/is-the-order-guaranteed-for-the-return-of-keys-and-values-from-a-linkedhashmap-o^0|0|5|0|0|3|9|D|9|0|0|3|3Q|E|H|7|T|9|15|7|1U|D|30|9|3G|9|0|0|0|0|3|B|5|H|9|6|4|0|0|0|2|9|0|0|2|9|0|0|0|0|8|5|J|6|S|9|12|6|1B|9|0|0|4|B|1|0|4|9|E|6|4|9|0^^$0|@$1|2|3|4|5|6|7|1O|8|@$9|1P|A|1Q|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|1R|8|@]|D|@]|E|$]]|$1|G|3|H|5|6|7|1S|8|@$9|1T|A|1U|B|I]|$9|1V|A|1W|B|I]]|D|@]|E|$]]|$1|J|3|K|5|6|7|1X|8|@$9|1Y|A|1Z|B|C]|$9|20|A|21|B|C]|$9|22|A|23|B|I]|$9|24|A|25|B|I]|$9|26|A|27|B|I]|$9|28|A|29|B|I]|$9|2A|A|2B|B|I]|$9|2C|A|2D|B|I]]|D|@]|E|$]]|$1|L|3|M|5|N|7|2E|8|@]|D|@]|E|$O|P]]|$1|Q|3|-4|5|6|7|2F|8|@]|D|@]|E|$]]|$1|R|3|S|5|6|7|2G|8|@$9|2H|A|2I|B|C]|$9|2J|A|2K|B|I]|$9|2L|A|2M|B|I]]|D|@$9|2N|A|2O|1|2P]]|E|$]]|$1|T|3|U|5|N|7|2Q|8|@]|D|@]|E|$O|P]]|$1|V|3|W|5|6|7|2R|8|@$9|2S|A|2T|B|I]]|D|@]|E|$]]|$1|X|3|Y|5|N|7|2U|8|@]|D|@]|E|$O|P]]|$1|Z|3|10|5|6|7|2V|8|@$9|2W|A|2X|B|I]]|D|@]|E|$]]|$1|11|3|12|5|N|7|2Y|8|@]|D|@]|E|$O|P]]|$1|13|3|14|5|6|7|2Z|8|@]|D|@]|E|$]]|$1|15|3|16|5|N|7|30|8|@]|D|@]|E|$O|P]]|$1|17|3|18|5|6|7|31|8|@$9|32|A|33|B|I]|$9|34|A|35|B|I]|$9|36|A|37|B|I]|$9|38|A|39|B|I]|$9|3A|A|3B|B|I]]|D|@]|E|$]]|$1|19|3|-4|5|6|7|3C|8|@]|D|@]|E|$]]|$1|1A|3|1B|5|6|7|3D|8|@]|D|@$9|3E|A|3F|1|3G]]|E|$]]|$1|1C|3|1D|5|6|7|3H|8|@$9|3I|A|3J|B|C]|$9|3K|A|3L|B|C]|$9|3M|A|3N|B|I]]|D|@]|E|$]]|$1|1E|3|-4|5|6|7|3O|8|@]|D|@]|E|$]]]|1F|$1G|$5|1H|1I|1J|E|$1K|1L]]|1M|$5|1H|1I|1J|E|$1K|1N]]]]

tl;dr Yes.
<hr />
I believe the iteration order for <code>.keySet()</code> and <code>.values()</code> is consistent (Java
8).
Proof 1: We load a <code>HashMap</code> with random keys and random values. We iterate on this <code>HashMap</code> using <code>.keySet()</code> and load the keys and it's corresponding values to a <code>LinkedHashMap</code> (it will preserve the order of the keys and values inserted). Then we compare the <code>.keySet()</code> of both the Maps and <code>.values()</code> of both the Maps. It always comes out to be the same, never fails.
<pre><code>public class Sample3 {

 static final String AB = &quot;0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz&quot;;
 static SecureRandom rnd = new SecureRandom();

 // from here: https://stackoverflow.com/a/157202/8430155
 static String randomString(int len){
 StringBuilder sb = new StringBuilder(len);
 for (int i = 0; i &lt; len; i++) {
 sb.append(AB.charAt(rnd.nextInt(AB.length())));
 }
 return sb.toString();
 }

 public static void main(String[] args) throws Exception {
 for (int j = 0; j &lt; 10; j++) {
 Map&lt;String, String&gt; map = new HashMap&lt;&gt;();
 Map&lt;String, String&gt; linkedMap = new LinkedHashMap&lt;&gt;();

 for (int i = 0; i &lt; 1000; i++) {
 String key = randomString(8);
 String value = randomString(8);
 map.put(key, value);
 }

 for (String k : map.keySet()) {
 linkedMap.put(k, map.get(k));
 }

 if (!(map.keySet().toString().equals(linkedMap.keySet().toString()) &amp;&amp;
 map.values().toString().equals(linkedMap.values().toString()))) {
 // never fails
 System.out.println(&quot;Failed&quot;);
 break;
 }
 }
 }
}
</code></pre>
<hr />
Proof 2: From <a href="http://hg.openjdk.java.net/jdk8/jdk8/jdk/file/687fd7c7986d/src/share/classes/java/util/HashMap.java" rel="nofollow noreferrer">here</a>, the <code>table</code> is an array of <code>Node&lt;K,V&gt;</code> class. We know that iterating an array will give the same result every time.
<pre><code>/**
 * The table, initialized on first use, and resized as
 * necessary. When allocated, length is always a power of two.
 * (We also tolerate length zero in some operations to allow
 * bootstrapping mechanics that are currently not needed.)
 */
transient Node&lt;K,V&gt;[] table;
</code></pre>
The class responsible for <code>.values()</code>:
<pre><code>final class Values extends AbstractCollection&lt;V&gt; {
 
 // more code here

 public final void forEach(Consumer&lt;? super V&gt; action) {
 Node&lt;K,V&gt;[] tab;
 if (action == null)
 throw new NullPointerException();
 if (size &gt; 0 &amp;&amp; (tab = table) != null) {
 int mc = modCount;
 for (int i = 0; i &lt; tab.length; ++i) {
 for (Node&lt;K,V&gt; e = tab[i]; e != null; e = e.next)
 action.accept(e.value);
 }
 if (modCount != mc)
 throw new ConcurrentModificationException();
 }
 }
}
</code></pre>
The class responsible for <code>.keySet()</code>:
<pre><code>final class KeySet extends AbstractSet&lt;K&gt; {

 // more code here

 public final void forEach(Consumer&lt;? super K&gt; action) {
 Node&lt;K,V&gt;[] tab;
 if (action == null)
 throw new NullPointerException();
 if (size &gt; 0 &amp;&amp; (tab = table) != null) {
 int mc = modCount;
 for (int i = 0; i &lt; tab.length; ++i) {
 for (Node&lt;K,V&gt; e = tab[i]; e != null; e = e.next)
 action.accept(e.key);
 }
 if (modCount != mc)
 throw new ConcurrentModificationException();
 }
 }
}
</code></pre>
Carefully look at both the inner classes. They are pretty much the same except:
<pre><code>if (size &gt; 0 &amp;&amp; (tab = table) != null) {
 int mc = modCount;
 for (int i = 0; i &lt; tab.length; ++i) {
 for (Node&lt;K,V&gt; e = tab[i]; e != null; e = e.next)
 action.accept(e.key); &lt;- from KeySet class
 // action.accept(e.value); &lt;- the only change from Values class
 }
 if (modCount != mc)
 throw new ConcurrentModificationException();
}
</code></pre>
They iterate on the same array <code>table</code> to support <code>.keySet()</code> in <code>KeySet</code> class and <code>.values()</code> in <code>Values</code> class.
<hr />
Proof 3: <a href="https://stackoverflow.com/questions/2923856/is-the-order-guaranteed-for-the-return-of-keys-and-values-from-a-linkedhashmap-o">this answer</a> also explicitly states - So, yes, keySet(), values(), and entrySet() return values in the order the internal linked list uses.
Therefore, the <code>.keySet()</code> and <code>.values()</code> are consistent.

I understand that the Set returned from a Map's keySet() method does not guarantee any particular order.

My question is, does it guarantee the same order over multiple iterations. For example

<pre><code>Map&lt;K,V&gt; map = getMap();

for( K k : map.keySet() )
{
}

...

for( K k : map.keySet() )
{
}
</code></pre>

In the above code, assuming that the map is not modified, will the iteration over the keySets be in the same order. Using Sun's jdk15 it does iterate in the same order, but before I depend on this behavior, I'd like to know if all JDKs will do the same.

EDIT

I see from the answers that I cannot depend on it. Too bad. I was hoping to get away with not having to build some new Collection to guarantee my ordering. My code needed to iterate through, do some logic, and then iterate through again with the same ordering. I'll just create a new ArrayList from the keySet which will guarantee order.

is the Java HashMap keySet() iteration order consistent?

我知道从Map的keySet()方法返回的Set并不保证任何特定的顺序。我的问题是，它能保证在多次迭代中保持相同的顺序吗？例如Map<K,V> map = getMap();for( K k : map.keySet() ){}...for( K k : map.keySet() ){}在上面的代码中，假设映射是而不是...

问Java HashMap keySet()迭代顺序是否一致？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java HashMap keySet()迭代顺序是否一致？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java HashMap keySet()迭代顺序是否一致？
EN