Java 使用HashMap时，值和键在迭代时是否保证顺序相同？

当我迭代这些值或键时，它们是否会相互关联？第二个键会映射到第二个值吗？

这个问题起初让我很困惑，但@Matt为我澄清了这一点

考虑使用entrySet（）方法，该方法返回一个带有映射上的键值对的集合

Map<Integer, Integer> a = new HashMap<Integer, Integer>(2);
a.put(1, 2);
a.put(2, 3);
for (Map.Entry<Integer, Integer> entry : a.entrySet()) {
    System.out.println(entry.getKey() + " => " + entry.getValue());
}

---

不，不一定。为此，您应该真正使用entrySet（）.iterator（）。使用此迭代器，您将遍历映射中的所有Map.Entry对象，并可以访问每个键和关联的值。

值（）和键集（）都委托给entrySet（）迭代器，因此它们将以相同的顺序返回。但正如Alex所说，直接使用entrySet（）迭代器要好得多。

要使用@Cuchullain提到的entrySet：

Map<String, String> map = new HashMap<String, String>();

// populate hashmap

for (Map.Entry<String, String> entry : map.entrySet()) {
  String key = entry.getKey();
  String value = entry.getValue();
  // your code here
}

Map Map=newhashmap（）；
//填充哈希映射
对于（Map.Entry:Map.entrySet（））{
String key=entry.getKey（）；
字符串值=entry.getValue（）；
//你的代码在这里
}

对于可预测的迭代顺序，您希望使用此选项。当

for (Map.Entry<Integer, Integer> entry : a.entrySet()) 

for（Map.Entry:a.entrySet（））

---

如果可以的话，我发现使用自动完成这项工作的数据结构会更好。现在，您只需迭代“正常”

HashMap的keySet方法返回一个集合，该集合不保证顺序。
HashMap的values（）方法返回一个集合，该集合不保证顺序

---

也就是说，问题是“它们是否会相互关联”，所以从技术上来说答案可能是，但不要依赖它。

我同意pmac72。不要假设您将从无序集合中获得有序值或键。如果它有时起作用，那纯粹是危险。如果要保留订单，请使用LinkedHashMap或TreeMap或commons collections OrderedMap。

公共类测试{
public class Test {
 public static void main(String[] args) {
  HashMap <String,String> hashmap = new HashMap<String,String>();
  hashmap.put("one", "1");
  hashmap.put("two", "2");
  hashmap.put("three", "3");
  hashmap.put("four", "4");
  hashmap.put("five", "5");
  hashmap.put("six", "6");

  Iterator <String> keyIterator   = hashmap.keySet().iterator();
  Iterator <String> valueIterator = hashmap.values().iterator();

  while(keyIterator.hasNext()) {
   System.out.println("key: "+keyIterator.next());
  }

  while(valueIterator.hasNext()) {
   System.out.println("value: "+valueIterator.next());
  }
 }
}

key: two
key: five
key: one
key: three
key: four
key: six
value: 2
value: 5
value: 1
value: 3
value: 4
value: 6

公共静态void main（字符串[]args）{
HashMap HashMap=新的HashMap（）；
hashmap.put（“一”、“1”）；
hashmap.put（“二”，“二”）；
hashmap.put（“三”，“三”）；
hashmap.put（“四”，“四”）；
hashmap.put（“五”、“五”）；
hashmap.put（“六”、“六”）；
迭代器keyIterator=hashmap.keySet（）.Iterator（）；
迭代器valueIterator=hashmap.values（）.Iterator（）；
while（keyIterator.hasNext（））{
System.out.println（“key:+keyinterator.next（））；
}
while（valueIterator.hasNext（））{
System.out.println（“value:+valueIterator.next（））；
}
}
}
关键：两个
键：五
关键：一
关键：三
钥匙：四个
键：六
价值：2
价值：5
价值：1
价值：3
价值：4
价值：6

我一开始也认为这是问题的意思，但听起来他在使用.keys（）和.values（）方法独立地迭代键和值。我不认为LinkedHashMap解决了这种情况下的问题。另一方面，您不应该创建与预期元素数相同大小的HashMap。HashMap的加载因子通常为75%。这意味着，如果映射已满75%，并且您添加了一个元素，它将增加其大小。这是一个实现细节。我不认为有任何保证，这是真的…或LinkedHashSet，如果你需要一个确定性有序集

public class Test {
 public static void main(String[] args) {
  HashMap <String,String> hashmap = new HashMap<String,String>();
  hashmap.put("one", "1");
  hashmap.put("two", "2");
  hashmap.put("three", "3");
  hashmap.put("four", "4");
  hashmap.put("five", "5");
  hashmap.put("six", "6");

  Iterator <String> keyIterator   = hashmap.keySet().iterator();
  Iterator <String> valueIterator = hashmap.values().iterator();

  while(keyIterator.hasNext()) {
   System.out.println("key: "+keyIterator.next());
  }

  while(valueIterator.hasNext()) {
   System.out.println("value: "+valueIterator.next());
  }
 }
}

key: two
key: five
key: one
key: three
key: four
key: six
value: 2
value: 5
value: 1
value: 3
value: 4
value: 6