如何有效地迭代Java Map中的每个条目？
如果我有一个在Java中实现Map接口的对象，并希望迭代其中包含的每一对，那么通过地图的最有效方法是什么？
元素的排序是否取决于我对界面的具体地图实现？
46 个答案:
答案 0 :(得分：4598)
Map<String, String> map = ...
for (Map.Entry<String, String> entry : map.entrySet()) {
System.out.println(entry.getKey() + "/" + entry.getValue());
}
答案 1 :(得分：959)
总结其他答案并将它们与我所知道的结合起来，我找到了10种主要方法（见下文）。另外，我写了一些性能测试（见下面的结果）。例如，如果我们想要找到地图的所有键和值的总和，我们可以写：
-
使用迭代器和 Map.Entry
long i = 0; Iterator<Map.Entry<Integer, Integer>> it = map.entrySet().iterator(); while (it.hasNext()) { Map.Entry<Integer, Integer> pair = it.next(); i += pair.getKey() + pair.getValue(); } -
使用 foreach 和 Map.Entry
long i = 0; for (Map.Entry<Integer, Integer> pair : map.entrySet()) { i += pair.getKey() + pair.getValue(); } -
在Java 8中使用 forEach
final long[] i = {0}; map.forEach((k, v) -> i[0] += k + v); -
使用 keySet 和 foreach
long i = 0; for (Integer key : map.keySet()) { i += key + map.get(key); } -
使用 keySet 和迭代器
long i = 0; Iterator<Integer> itr2 = map.keySet().iterator(); while (itr2.hasNext()) { Integer key = itr2.next(); i += key + map.get(key); } -
使用代替和 Map.Entry
long i = 0; for (Iterator<Map.Entry<Integer, Integer>> entries = map.entrySet().iterator(); entries.hasNext(); ) { Map.Entry<Integer, Integer> entry = entries.next(); i += entry.getKey() + entry.getValue(); } -
使用Java 8 Stream API
final long[] i = {0}; map.entrySet().stream().forEach(e -> i[0] += e.getKey() + e.getValue()); -
使用Java 8 流API并行
final long[] i = {0}; map.entrySet().stream().parallel().forEach(e -> i[0] += e.getKey() + e.getValue()); -
使用
的 IterableMapApache Collectionslong i = 0; MapIterator<Integer, Integer> it = iterableMap.mapIterator(); while (it.hasNext()) { i += it.next() + it.getValue(); } -
使用Eclipse（CS）集合的 MutableMap
final long[] i = {0}; mutableMap.forEachKeyValue((key, value) -> { i[0] += key + value; }); -
对于小地图（100个元素），得分0.308是最好的
Benchmark Mode Cnt Score Error Units test3_UsingForEachAndJava8 avgt 10 0.308 ± 0.021 µs/op test10_UsingEclipseMap avgt 10 0.309 ± 0.009 µs/op test1_UsingWhileAndMapEntry avgt 10 0.380 ± 0.014 µs/op test6_UsingForAndIterator avgt 10 0.387 ± 0.016 µs/op test2_UsingForEachAndMapEntry avgt 10 0.391 ± 0.023 µs/op test7_UsingJava8StreamApi avgt 10 0.510 ± 0.014 µs/op test9_UsingApacheIterableMap avgt 10 0.524 ± 0.008 µs/op test4_UsingKeySetAndForEach avgt 10 0.816 ± 0.026 µs/op test5_UsingKeySetAndIterator avgt 10 0.863 ± 0.025 µs/op test8_UsingJava8StreamApiParallel avgt 10 5.552 ± 0.185 µs/op -
对于10000个元素的地图，得分37.606是最好的
Benchmark Mode Cnt Score Error Units test10_UsingEclipseMap avgt 10 37.606 ± 0.790 µs/op test3_UsingForEachAndJava8 avgt 10 50.368 ± 0.887 µs/op test6_UsingForAndIterator avgt 10 50.332 ± 0.507 µs/op test2_UsingForEachAndMapEntry avgt 10 51.406 ± 1.032 µs/op test1_UsingWhileAndMapEntry avgt 10 52.538 ± 2.431 µs/op test7_UsingJava8StreamApi avgt 10 54.464 ± 0.712 µs/op test4_UsingKeySetAndForEach avgt 10 79.016 ± 25.345 µs/op test5_UsingKeySetAndIterator avgt 10 91.105 ± 10.220 µs/op test8_UsingJava8StreamApiParallel avgt 10 112.511 ± 0.365 µs/op test9_UsingApacheIterableMap avgt 10 125.714 ± 1.935 µs/op -
对于包含100000个元素的地图，得分1184.767是最佳
Benchmark Mode Cnt Score Error Units test1_UsingWhileAndMapEntry avgt 10 1184.767 ± 332.968 µs/op test10_UsingEclipseMap avgt 10 1191.735 ± 304.273 µs/op test2_UsingForEachAndMapEntry avgt 10 1205.815 ± 366.043 µs/op test6_UsingForAndIterator avgt 10 1206.873 ± 367.272 µs/op test8_UsingJava8StreamApiParallel avgt 10 1485.895 ± 233.143 µs/op test5_UsingKeySetAndIterator avgt 10 1540.281 ± 357.497 µs/op test4_UsingKeySetAndForEach avgt 10 1593.342 ± 294.417 µs/op test3_UsingForEachAndJava8 avgt 10 1666.296 ± 126.443 µs/op test7_UsingJava8StreamApi avgt 10 1706.676 ± 436.867 µs/op test9_UsingApacheIterableMap avgt 10 3289.866 ± 1445.564 µs/op
性能测试（模式= AverageTime，system = Windows 8.1 64位，Intel i7-4790 3.60 GHz，16 GB）
图表（性能测试取决于地图大小）
表格（性能测试取决于地图大小）
100 600 1100 1600 2100
test10 0.333 1.631 2.752 5.937 8.024
test3 0.309 1.971 4.147 8.147 10.473
test6 0.372 2.190 4.470 8.322 10.531
test1 0.405 2.237 4.616 8.645 10.707
test2 0.376 2.267 4.809 8.403 10.910
test7 0.473 2.448 5.668 9.790 12.125
test9 0.565 2.830 5.952 13.220 16.965
test4 0.808 5.012 8.813 13.939 17.407
test5 0.810 5.104 8.533 14.064 17.422
test8 5.173 12.499 17.351 24.671 30.403
所有测试都在GitHub。
答案 2 :(得分：257)
在Java 8中，您可以使用新的lambdas功能清洁和快速地执行此操作：
Map<String,String> map = new HashMap<>();
map.put("SomeKey", "SomeValue");
map.forEach( (k,v) -> [do something with key and value] );
// such as
map.forEach( (k,v) -> System.out.println("Key: " + k + ": Value: " + v));
编译器会推断k和v的类型，不再需要使用Map.Entry。
易peasy！
答案 3 :(得分：218)
是的，订单取决于具体的Map实施。
@ScArcher2 has the more elegant Java 1.5 syntax。在1.4中，我会做这样的事情：
Iterator entries = myMap.entrySet().iterator();
while (entries.hasNext()) {
Entry thisEntry = (Entry) entries.next();
Object key = thisEntry.getKey();
Object value = thisEntry.getValue();
// ...
}
答案 4 :(得分：119)
迭代地图的典型代码是：
Map<String,Thing> map = ...;
for (Map.Entry<String,Thing> entry : map.entrySet()) {
String key = entry.getKey();
Thing thing = entry.getValue();
...
}
HashMap是规范地图实现，不提供保证（或者如果不对其执行变异操作则不应更改顺序）。 SortedMap将根据键的自然顺序返回条目，如果提供，则返回Comparator。 LinkedHashMap将以插入顺序或访问顺序返回条目，具体取决于它的构造方式。 EnumMap按键的自然顺序返回条目。
（更新：我认为这不再是真的。）注意，IdentityHashMap entrySet迭代器当前有一个特殊的实现，返回相同的Map.Entry实例对于entrySet中的每个项目！但是，每当新的迭代器前进时，Map.Entry都会更新。
答案 5 :(得分：106)
使用迭代器和泛型的示例：
Iterator<Map.Entry<String, String>> entries = myMap.entrySet().iterator();
while (entries.hasNext()) {
Map.Entry<String, String> entry = entries.next();
String key = entry.getKey();
String value = entry.getValue();
// ...
}
答案 6 :(得分：90)
这是一个两部分问题：
如何迭代地图的条目 - @ ScArcher2完美地拥有answered。
迭代的顺序是什么 - 如果您只是使用Map，那么严格来说，没有订购保证。所以你不应该真正依赖任何实现给出的顺序。但是，SortedMap接口扩展了Map并提供了您正在寻找的内容 - 实现将提供一致的排序顺序。
NavigableMap是另一个有用的扩展程序 - 这是一个SortedMap，其中包含按键集中的有序位置查找条目的其他方法。因此，这可能会首先消除迭代的需要 - 您可能能够在使用entry，higherEntry，lowerEntry之后找到您所需的特定ceilingEntry，或floorEntry方法。 descendingMap方法甚至为您提供了撤消遍历顺序的明确方法。
答案 7 :(得分：73)
有几种方法可以迭代地图。
这是通过在地图中存储一百万个键值对来比较它们在地图中存储的公共数据集的性能，并将迭代在地图上。
1）在每个循环中使用entrySet()
for (Map.Entry<String,Integer> entry : testMap.entrySet()) {
entry.getKey();
entry.getValue();
}
50毫秒
2）在每个循环中使用keySet()
for (String key : testMap.keySet()) {
testMap.get(key);
}
76毫秒
3）使用entrySet()和迭代器
Iterator<Map.Entry<String,Integer>> itr1 = testMap.entrySet().iterator();
while(itr1.hasNext()) {
Map.Entry<String,Integer> entry = itr1.next();
entry.getKey();
entry.getValue();
}
50毫秒
4）使用keySet()和迭代器
Iterator itr2 = testMap.keySet().iterator();
while(itr2.hasNext()) {
String key = itr2.next();
testMap.get(key);
}
75毫秒
我已提到this link。
答案 8 :(得分：52)
正确的方法是使用接受的答案，因为它是最有效的。我发现以下代码看起来更清晰。
for (String key: map.keySet()) {
System.out.println(key + "/" + map.get(key));
}
答案 9 :(得分：51)
仅供参考，如果您只对地图的键/值感兴趣而不感兴趣，则还可以使用map.keySet()和map.values()。
答案 10 :(得分：32)
使用Eclipse Collections（以前称为GS Collections），您将在MapIterable接口上使用forEachKeyValue方法，该方法由MutableMap和ImmutableMap接口及其实现继承。
final MutableBag<String> result = Bags.mutable.empty();
MutableMap<Integer, String> map = Maps.mutable.of(1, "One", 2, "Two", 3, "Three");
map.forEachKeyValue(new Procedure2<Integer, String>()
{
public void value(Integer key, String value)
{
result.add(key + value);
}
});
Assert.assertEquals(Bags.mutable.of("1One", "2Two", "3Three"), result);
使用Java 8 lambda语法，您可以按如下方式编写代码：
MutableBag<String> result = Bags.mutable.empty();
MutableMap<Integer, String> map = Maps.mutable.of(1, "One", 2, "Two", 3, "Three");
map.forEachKeyValue((key, value) -> result.add(key + value));
Assert.assertEquals(Bags.mutable.of("1One", "2Two", "3Three"), result);
注意：我是Eclipse Collections的提交者。
答案 11 :(得分：28)
理论上，最有效的方法取决于Map的实现。这样做的正式方法是拨打map.entrySet()，其中会返回一组Map.Entry，其中每个entry.getKey()都包含一个键和一个值（entry.getValue()和map.keySet()）。< / p>
在特殊实现中，无论您使用map.entrySet()，valueSet()还是其他内容，都可能会有所不同。但我想不出有人会这样写的原因。很可能它对你的表现没有任何影响。
是的，订单将取决于实施 - 以及（可能）插入顺序和其他难以控制的因素。
[edit]我最初写了entrySet()，但当然{{1}}实际上就是答案。
答案 12 :(得分：27)
Java 8：
您可以使用lambda表达式：
myMap.entrySet().stream().forEach((entry) -> {
Object currentKey = entry.getKey();
Object currentValue = entry.getValue();
});
有关详情，请按this。
答案 13 :(得分：26)
使用 Java 8
map.forEach((k, v) -> System.out.println((k + ":" + v)));
答案 14 :(得分：26)
尝试使用Java 1.4：
for( Iterator entries = myMap.entrySet().iterator(); entries.hasNext();){
Entry entry = (Entry) entries.next();
System.out.println(entry.getKey() + "/" + entry.getValue());
//...
}
答案 15 :(得分：26)
Java 8
我们有forEach方法接受lambda expression。我们还有stream个API。考虑一张地图：
Map<String,String> sample = new HashMap<>();
sample.put("A","Apple");
sample.put("B", "Ball");
迭代键：
sample.keySet().forEach((k) -> System.out.println(k));
迭代值：
sample.values().forEach((v) -> System.out.println(v));
迭代条目（使用forEach和Streams）：
sample.forEach((k,v) -> System.out.println(k + ":" + v));
sample.entrySet().stream().forEach((entry) -> {
Object currentKey = entry.getKey();
Object currentValue = entry.getValue();
System.out.println(currentKey + ":" + currentValue);
});
流的优点是它们可以在我们想要的情况下轻松并行化。我们只需使用parallelStream()代替上面的stream()。
forEachOrdered vs forEach
forEach不遵循遭遇顺序（如果已定义），并且本质上与forEachOrdered一样具有非确定性。所以forEach并不保证订单会被保留。另请查看this了解更多信息。
答案 16 :(得分：25)
Lambda Expression Java 8
在Java 1.8（Java 8）中，使用来自 Iterable的迭代器的聚合操作（流操作）中的 forEach 方法变得更加容易界面。
只需将以下语句粘贴复制到您的代码中，然后将 hm 变量从 hm 重命名为HashMap变量，即可打印出键值对。
HashMap<Integer,Integer> hm = new HashMap<Integer, Integer>();
/*
* Logic to put the Key,Value pair in your HashMap hm
*/
// Print the key value pair in one line.
hm.forEach((k, v) -> System.out.println("key: " + k + " value:" + v));
// Just copy and paste above line to your code.
以下是我尝试使用 Lambda Expression 尝试的示例代码。这东西太酷了。一定要试试。
HashMap<Integer, Integer> hm = new HashMap<Integer, Integer>();
Random rand = new Random(47);
int i = 0;
while(i < 5) {
i++;
int key = rand.nextInt(20);
int value = rand.nextInt(50);
System.out.println("Inserting key: " + key + " Value: " + value);
Integer imap = hm.put(key, value);
if( imap == null) {
System.out.println("Inserted");
} else {
System.out.println("Replaced with " + imap);
}
}
hm.forEach((k, v) -> System.out.println("key: " + k + " value:" + v));
Output:
Inserting key: 18 Value: 5
Inserted
Inserting key: 13 Value: 11
Inserted
Inserting key: 1 Value: 29
Inserted
Inserting key: 8 Value: 0
Inserted
Inserting key: 2 Value: 7
Inserted
key: 1 value:29
key: 18 value:5
key: 2 value:7
key: 8 value:0
key: 13 value:11
同样可以使用 Spliterator 。
Spliterator sit = hm.entrySet().spliterator();
<强>更新
包括Oracle Docs的文档链接。 有关 Lambda 的更多信息，请转到此link，并且必须阅读Aggregate Operations，对于Spliterator，请转到此link。
答案 17 :(得分：23)
在地图中，可以对keys和/或values和/或both (e.g., entrySet)进行迭代取决于您对此感兴趣的内容_赞：
1。）迭代地图的keys -> keySet()：
Map<String, Object> map = ...;
for (String key : map.keySet()) {
//your Business logic...
}
2。）迭代地图的values -> values()：
for (Object value : map.values()) {
//your Business logic...
}
3。）迭代地图的both -> entrySet()：
for (Map.Entry<String, Object> entry : map.entrySet()) {
String key = entry.getKey();
Object value = entry.getValue();
//your Business logic...
}
此外，通过HashMap迭代有3种不同的方法。它们如下所示 _
//1.
for (Map.Entry entry : hm.entrySet()) {
System.out.print("key,val: ");
System.out.println(entry.getKey() + "," + entry.getValue());
}
//2.
Iterator iter = hm.keySet().iterator();
while(iter.hasNext()) {
Integer key = (Integer)iter.next();
String val = (String)hm.get(key);
System.out.println("key,val: " + key + "," + val);
}
//3.
Iterator it = hm.entrySet().iterator();
while (it.hasNext()) {
Map.Entry entry = (Map.Entry) it.next();
Integer key = (Integer)entry.getKey();
String val = (String)entry.getValue();
System.out.println("key,val: " + key + "," + val);
}
答案 18 :(得分：18)
如果你有一个通用的无类型地图，你可以使用：
Map map = new HashMap();
for (Map.Entry entry : ((Set<Map.Entry>) map.entrySet())) {
System.out.println(entry.getKey() + "/" + entry.getValue());
}
答案 19 :(得分：18)
最紧凑的Java 8：
map.entrySet().forEach(System.out::println);
答案 20 :(得分：18)
public class abcd{
public static void main(String[] args)
{
Map<Integer, String> testMap = new HashMap<Integer, String>();
testMap.put(10, "a");
testMap.put(20, "b");
testMap.put(30, "c");
testMap.put(40, "d");
for (Integer key:testMap.keySet()) {
String value=testMap.get(key);
System.out.println(value);
}
}
}
OR
public class abcd {
public static void main(String[] args)
{
Map<Integer, String> testMap = new HashMap<Integer, String>();
testMap.put(10, "a");
testMap.put(20, "b");
testMap.put(30, "c");
testMap.put(40, "d");
for (Entry<Integer, String> entry : testMap.entrySet()) {
Integer key=entry.getKey();
String value=entry.getValue();
}
}
}
答案 21 :(得分：12)
Iterator iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry element = (Map.Entry)it.next();
LOGGER.debug("Key: " + element.getKey());
LOGGER.debug("value: " + element.getValue());
}
答案 22 :(得分：11)
您可以使用泛型来完成：
Map<Integer, Integer> map = new HashMap<Integer, Integer>();
Iterator<Map.Entry<Integer, Integer>> entries = map.entrySet().iterator();
while (entries.hasNext()) {
Map.Entry<Integer, Integer> entry = entries.next();
System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
}
答案 23 :(得分：11)
使用Java 8：
map.entrySet().forEach(entry -> System.out.println(entry.getValue()));
答案 24 :(得分：9)
排序将始终取决于具体的地图实施。 使用Java 8，您可以使用以下任一方法：
map.forEach((k,v) -> { System.out.println(k + ":" + v); });
或者：
map.entrySet().forEach((e) -> {
System.out.println(e.getKey() + " : " + e.getValue());
});
结果将是相同的（相同的顺序）。由映射支持的entrySet，以便您获得相同的顺序。第二个是方便的，因为它允许你使用lambdas，例如如果您只想打印大于5的整数对象：
map.entrySet()
.stream()
.filter(e-> e.getValue() > 5)
.forEach(System.out::println);
下面的代码显示了LinkedHashMap和普通HashMap的迭代（示例）。您将看到顺序不同：
public class HMIteration {
public static void main(String[] args) {
Map<Object, Object> linkedHashMap = new LinkedHashMap<>();
Map<Object, Object> hashMap = new HashMap<>();
for (int i=10; i>=0; i--) {
linkedHashMap.put(i, i);
hashMap.put(i, i);
}
System.out.println("LinkedHashMap (1): ");
linkedHashMap.forEach((k,v) -> { System.out.print(k + " (#="+k.hashCode() + "):" + v + ", "); });
System.out.println("\nLinkedHashMap (2): ");
linkedHashMap.entrySet().forEach((e) -> {
System.out.print(e.getKey() + " : " + e.getValue() + ", ");
});
System.out.println("\n\nHashMap (1): ");
hashMap.forEach((k,v) -> { System.out.print(k + " (#:"+k.hashCode() + "):" + v + ", "); });
System.out.println("\nHashMap (2): ");
hashMap.entrySet().forEach((e) -> {
System.out.print(e.getKey() + " : " + e.getValue() + ", ");
});
}
}
LinkedHashMap（1）：
10（＃= 10）：10,9（＃= 9）：9,8（＃= 8）：8,7（＃= 7）：7,6（＃= 6）：6,5（ ＃= 5）：5,4（＃= 4）：4,3（＃= 3）：3,2（＃= 2）：2,1（＃= 1）：1,0（＃= 0）： 0，
LinkedHashMap（2）：
10：10,9：9,8：8,7：7,6：6,5：5,4：4,3：3,2：2,1：1,0：0，
HashMap（1）：
0（＃：0）：0,1（＃：1）：1,2（＃：2）：2,3（＃：3）：3,4（＃：4）：4,5（ ＃：5）：5,6（＃：6）：6,7（＃：7）：7,8（＃：8）：8,9（＃：9）：9,10（＃：10）： 10，
HashMap（2）：
0：0,1：1,2：2,3：3,4：4,5：5,6：6,7：7,8：8,9：9,10：10，
答案 25 :(得分：9)
//Functional Oprations
Map<String, String> mapString = new HashMap<>();
mapString.entrySet().stream().map((entry) -> {
String mapKey = entry.getKey();
return entry;
}).forEach((entry) -> {
String mapValue = entry.getValue();
});
//Intrator
Map<String, String> mapString = new HashMap<>();
for (Iterator<Map.Entry<String, String>> it = mapString.entrySet().iterator(); it.hasNext();) {
Map.Entry<String, String> entry = it.next();
String mapKey = entry.getKey();
String mapValue = entry.getValue();
}
//Simple for loop
Map<String, String> mapString = new HashMap<>();
for (Map.Entry<String, String> entry : mapString.entrySet()) {
String mapKey = entry.getKey();
String mapValue = entry.getValue();
}
答案 26 :(得分：8)
在Map上有效的迭代解决方案是从Java 5到Java 7的“ for each”循环。这里是：
for (String key : phnMap.keySet()) {
System.out.println("Key: " + key + " Value: " + phnMap.get(key));
}
在Java 8中，您可以使用lambda表达式来迭代Map。它是增强的“ forEach”
phnMap.forEach((k,v) -> System.out.println("Key: " + k + " Value: " + v));
如果要编写lambda的条件，则可以这样编写：
phnMap.forEach((k,v)->{
System.out.println("Key: " + k + " Value: " + v);
if("abc".equals(k)){
System.out.println("Hello abc");
}
});
答案 27 :(得分：8)
是的，因为很多人都认为这是迭代Map的最好方法。
但如果地图为nullpointerexception，则有可能抛出null。不要忘记将null .check放入。
|
|
- - - -
|
|
for (Map.Entry<String, Object> entry : map.entrySet()) {
String key = entry.getKey();
Object value = entry.getValue();
}
答案 28 :(得分：7)
package com.test;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
public class Test {
public static void main(String[] args) {
Map<String, String> map = new HashMap<String, String>();
map.put("ram", "ayodhya");
map.put("krishan", "mathura");
map.put("shiv", "kailash");
System.out.println("********* Keys *********");
Set<String> keys = map.keySet();
for (String key : keys) {
System.out.println(key);
}
System.out.println("********* Values *********");
Collection<String> values = map.values();
for (String value : values) {
System.out.println(value);
}
System.out.println("***** Keys and Values (Using for each loop) *****");
for (Map.Entry<String, String> entry : map.entrySet()) {
System.out.println("Key: " + entry.getKey() + "\t Value: "
+ entry.getValue());
}
System.out.println("***** Keys and Values (Using while loop) *****");
Iterator<Entry<String, String>> entries = map.entrySet().iterator();
while (entries.hasNext()) {
Map.Entry<String, String> entry = (Map.Entry<String, String>) entries
.next();
System.out.println("Key: " + entry.getKey() + "\t Value: "
+ entry.getValue());
}
System.out
.println("** Keys and Values (Using java 8 using lambdas )***");
map.forEach((k, v) -> System.out
.println("Key: " + k + "\t value: " + v));
}
}
答案 29 :(得分：7)
有很多方法可以做到这一点。以下是几个简单的步骤：
假设您有一个地图，如：
Map<String, Integer> m = new HashMap<String, Integer>();
然后你可以做类似下面的事情迭代地图元素。
// ********** Using an iterator ****************
Iterator<Entry<String, Integer>> me = m.entrySet().iterator();
while(me.hasNext()){
Entry<String, Integer> pair = me.next();
System.out.println(pair.getKey() + ":" + pair.getValue());
}
// *********** Using foreach ************************
for(Entry<String, Integer> me : m.entrySet()){
System.out.println(me.getKey() + " : " + me.getValue());
}
// *********** Using keySet *****************************
for(String s : m.keySet()){
System.out.println(s + " : " + m.get(s));
}
// *********** Using keySet and iterator *****************
Iterator<String> me = m.keySet().iterator();
while(me.hasNext()){
String key = me.next();
System.out.println(key + " : " + m.get(key));
}
答案 30 :(得分：5)
Map.forEach
简单地使用将密钥和值都传递到您的Map::forEach的BiConsumer怎么办？
map.forEach((k,v)->{
System.out.println(k+"->"+v);
});
答案 31 :(得分：5)
如果我有一个用Java实现Map接口的对象，并且希望遍历其中包含的所有对，那么遍历该映射的最有效方法是什么？
如果应用程序优先考虑循环键的效率，请选择一种Map实现，以所需的顺序维护键。
元素的顺序是否取决于我对接口的特定映射实现？
是的，绝对如此。
- 某些
Map实现承诺一定的迭代顺序，而其他的则没有。 -
Map的不同实现保留键值对的不同顺序。
请参阅我创建的这张表，其中总结了与Java 11捆绑在一起的各种Map实现。具体来说，请注意迭代顺序列。点击/点击进行缩放。
您可以看到有四个维护交互顺序。其中两个实现了NavigableMap接口。
较旧的SortedMap界面实际上被较新的NavigableMap界面所取代。但是您可能会发现第三方实现仅实现了较旧的界面。
自然顺序
如果您想让Map保持键对的“自然顺序”排列，请使用TreeMap或ConcurrentSkipListMap。术语“自然顺序”是指键的类别实现Comparable。 compareTo方法返回的值用于排序比较。
自定义订单
如果您想为密钥指定自定义排序例程，以用于维护排序顺序，请传递适合于密钥类的Comparator实现。使用TreeMap或ConcurrentSkipListMap，传递您的Comparator。
原始广告订单
如果您希望将成对的地图按其插入地图时的原始顺序保存，请使用LinkedHashMap。
枚举定义顺序
如果您使用诸如DayOfWeek或Month之类的枚举作为键，请使用EnumMap类。不仅 highly 此类已优化为使用很少的内存并且运行非常快，而且还按枚举定义的顺序维护您的配对。例如，对于DayOfWeek，迭代时将首先找到DayOfWeek.MONDAY的密钥，而DayOfWeek.SUNDAY的密钥将是最后一个。
答案 32 :(得分：5)
从Java 10开始，您可以使用局部变量推断（也称为“ var”）使许多已经可用的答案变得不那么blo肿。例如：
for (var entry : map.entrySet()) {
System.out.println(entry.getKey() + " : " + entry.getValue());
}
答案 33 :(得分：4)
如果您通过Map进行迭代的原因是对值进行操作并写入结果Map。我建议您使用Google Guava transform类中的Maps - 方法。
import com.google.common.collect.Maps;
将Maps添加到导入后，您可以在地图上使用Maps.transformValues和Maps.transformEntries，如下所示：
public void transformMap(){
Map<String, Integer> map = new HashMap<>();
map.put("a", 2);
map.put("b", 4);
Map<String, Integer> result = Maps.transformValues(map, num -> num * 2);
result.forEach((key, val) -> print(key, Integer.toString(val)));
// key=a,value=4
// key=b,value=8
Map<String, String> result2 = Maps.transformEntries(map, (key, value) -> value + "[" + key + "]");
result2.forEach(this::print);
// key=a,value=2[a]
// key=b,value=4[b]
}
private void print(String key, String val){
System.out.println("key=" + key + ",value=" + val);
}
答案 34 :(得分：4)
这是一个通用的类型安全方法，可以调用它来转储任何给定的public Config getConfigSingle(string CID, string name)
{
var raw = db.ap_GetInfo(CID, name);
foreach (var item in raw.ToList())
{
return new Config
{
Name = item.Name.ToString(),
Value = item.Value.ToString(),
};
}
return null;
}
。
Map实施例
以下是其使用示例。请注意，import java.util.Iterator;
import java.util.Map;
public class MapUtils {
static interface ItemCallback<K, V> {
void handler(K key, V value, Map<K, V> map);
}
public static <K, V> void forEach(Map<K, V> map, ItemCallback<K, V> callback) {
Iterator<Map.Entry<K, V>> it = map.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<K, V> entry = it.next();
callback.handler(entry.getKey(), entry.getValue(), map);
}
}
public static <K, V> void printMap(Map<K, V> map) {
forEach(map, new ItemCallback<K, V>() {
@Override
public void handler(K key, V value, Map<K, V> map) {
System.out.println(key + " = " + value);
}
});
}
}
的类型是由方法推断的。
Map输出
import java.util.*;
public class MapPrinter {
public static void main(String[] args) {
List<Map<?, ?>> maps = new ArrayList<Map<?, ?>>() {
private static final long serialVersionUID = 1L;
{
add(new LinkedHashMap<String, Integer>() {
private static final long serialVersionUID = 1L;
{
put("One", 0);
put("Two", 1);
put("Three", 3);
}
});
add(new LinkedHashMap<String, Object>() {
private static final long serialVersionUID = 1L;
{
put("Object", new Object());
put("Integer", new Integer(0));
put("Double", new Double(0.0));
}
});
}
};
for (Map<?, ?> map : maps) {
MapUtils.printMap(map);
System.out.println();
}
}
}
答案 35 :(得分：2)
以下是迭代HashMaps的方法
Java 8 方法：
hashMap.forEach((key, value) -> {
System.out.println("Value of " + key + " is " + value);
});
Java 7 方法：
for (Map.Entry entry : hashMap.entrySet()) {
System.out.println(entry.getKey() + " Value is " + entry.getValue());
}
有关 hashmap 的更多参考，请参阅以下链接
https://beginnersbug.com/get-key-and-value-from-hashmap-in-java/
https://docs.oracle.com/javase/8/docs/api/java/util/Map.html
答案 36 :(得分：2)
Map<String, String> map =
for (Map.Entry<String, String> entry : map.entrySet()) {
MapKey = entry.getKey()
MapValue = entry.getValue();
}
答案 37 :(得分：2)
您可以搜索键，并在键的帮助下找到映射的关联值，因为映射具有唯一键，看看键重复时会发生什么here或here。
演示地图：
Map<String, String> map = new HashMap();
map.put("name", "Name");
map.put("age", "23");
map.put("address", "NP");
map.put("faculty", "BE");
map.put("major", "CS");
map.put("head", "MDK");
要仅获取密钥，您可以像这样使用 map.keySet(); :
for(String key : map.keySet()) {
System.out.println(key);
}
要仅获取价值，您可以像这样使用 map.values();：
for(String value : map.values()) {
System.out.println(value);
}
要同时获取键及其值，您仍然可以使用 map.keySet(); 并获取其对应的值，如下所示：
//this prints the key value pair
for (String k : map.keySet()) {
System.out.println(k + " " + map.get(k) + " ");
}
map.get(key) 给出该键指向的值。
答案 38 :(得分：2)
它并没有完全回答OP的问题，但对于找到此页面的其他人可能会有用：
如果您只需要值而不是键，则可以执行以下操作：
Map<Ktype, Vtype> myMap = [...];
for (Vtype v: myMap.values()) {
System.out.println("value: " + v);
}
Ktype，Vtype是伪代码。
答案 39 :(得分：2)
有几种方法可以迭代地图。请参阅以下代码。
使用迭代器接口迭代地图时，必须使用Entry＆lt; K，V＆gt;或entrySet（）
看起来像这样：
import java.util.*;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
public class IteratMapDemo{
public static void main(String arg[]){
Map<String, String> mapOne = new HashMap<String, String>();
mapOne.put("1", "January");
mapOne.put("2", "February");
mapOne.put("3", "March");
mapOne.put("4", "April");
mapOne.put("5", "May");
mapOne.put("6", "June");
mapOne.put("7", "July");
mapOne.put("8", "August");
mapOne.put("9", "September");
mapOne.put("10", "Octomber");
mapOne.put("11", "November");
mapOne.put("12", "December");
Iterator it = mapOne.entrySet().iterator();
while(it.hasNext())
{
Map.Entry me = (Map.Entry) it.next();
//System.out.println("Get Key through While loop = " + me.getKey());
}
for(Map.Entry<String, String> entry:mapOne.entrySet()){
//System.out.println(entry.getKey() + "=" + entry.getValue());
}
for (Object key : mapOne.keySet()) {
System.out.println("Key: " + key.toString() + " Value: " +
mapOne.get(key));
}
}
}
答案 40 :(得分：1)
使用Java 7
Map<String,String> sampleMap = new HashMap<>();
for (sampleMap.Entry<String,String> entry : sampleMap.entrySet()) {
String key = entry.getKey();
String value = entry.getValue();
/* your Code as per the Business Justification */
}
使用Java 8
Map<String,String> sampleMap = new HashMap<>();
sampleMap.forEach((k, v) -> System.out.println("Key is : " + k + " Value is : " + v));
答案 41 :(得分：1)
这是最简单的方法，我相信......
/* For example, this could be a map object */
Map<String, Integer> MAP = new Map<>();
// Do something like put keys/value pairs into the map, etc...
MAP.put("Denver", 35);
MAP.put("Patriots", 14);
/* Then, simply use a for each loop like this to iterate */
for (Object o : MAP.entrySet()) {
Map.Entry pair = (Map.Entry) o;
// Do whatever with the pair here (i.e. pair.getKey(), or pair.getValue();
}
答案 42 :(得分：1)
我使用以下代码将地图数据复制到另一个地图：
HashMap product =(HashMap)shopping_truck.get(i);
HashMap tmp = new HashMap();
for (Iterator it = product.entrySet().iterator(); it.hasNext();) {
Map.Entry thisEntry = (Map.Entry) it.next();
tmp.put(thisEntry.getKey(), thisEntry.getValue());
}
答案 43 :(得分：0)
我想连接一个计数器，然后保存计数器的最终值；
#include<iostream>
#include<list>
#include<algorithm>
using namespace std;
class Person {
public:
int kontostand;
string email;
int alter;
Person(int kontostand_, string email_, int alter_)
{
kontostand = kontostand_;
email = email_;
alter = alter_;
}
};
int main()
{
list<Person> myPerson;
Person Kunde(2, "test", 1);
Person Kunde2(3, "test2", 2);
myPerson.push_back(Kunde);
myPerson.push_back(Kunde2);
list<Person>::iterator x;
//troouble at this line
x = find(myPerson.begin(), myPerson.end(), Kunde);
return 0;
}
然后在您要检索时：
int counter = 0;
HashMap<String, String> m = new HashMap<String, String>();
for(int i = 0;i<items.length;i++)
{
m.put("firstname"+i, items.get(i).getFirstName());
counter = i;
}
m.put("recordCount",String.valueOf(counter));
答案 44 :(得分：0)
迭代地图非常简单。
for(Object key: map.keySet()){
Object value= map.get(key);
//Do your stuff
}
例如，您有Map<String, int> data;
for(Object key: data.keySet()){
int value= data.get(key);
}
快乐编码......
答案 45 :(得分：0)
如果您想按照添加元素的顺序遍历地图，请使用LinkedHashMap而不是Map。
这种方法过去对我有用：
LinkedHashMap<String,Integer> test=new LinkedHashMap();
test.put("foo",69);
test.put("bar",1337);
for(int i=0;i<test.size();i++){
System.out.println(test.get(test.keySet().toArray()[i]));
}
输出：
69
1337
- 我写了这段代码，但我无法理解我的错误
- 我无法从一个代码实例的列表中删除 None 值，但我可以在另一个实例中。为什么它适用于一个细分市场而不适用于另一个细分市场？
- 是否有可能使 loadstring 不可能等于打印？卢阿
- java中的random.expovariate()
- Appscript 通过会议在 Google 日历中发送电子邮件和创建活动
- 为什么我的 Onclick 箭头功能在 React 中不起作用？
- 在此代码中是否有使用“this”的替代方法？
- 在 SQL Server 和 PostgreSQL 上查询，我如何从第一个表获得第二个表的可视化
- 每千个数字得到
- 更新了城市边界 KML 文件的来源？