entry = entries.next( ); }`.通过使用该构造,我们将(条目的)可见性的范围限制为for循环.
@ComFreek哦,我明白了.不知道那么重要.
7> serg10..：
这是一个两部分问题:
如何迭代Map的条目 - @ ScArcher2已经完美地回答了这个问题.
迭代的顺序是什么 - 如果你刚刚使用Map,那么严格来说,没有订购保证.所以你不应该真正依赖任何实现给出的顺序.但是,SortedMap界面扩展Map并提供您正在寻找的内容 - 实现将提供一致的排序顺序.
NavigableMap是另一个有用的扩展 - 这是一个SortedMap额外的方法,用于按键集中的有序位置查找条目.所以可能这个可以去除需要摆在首位迭代-你也许可以找到具体的entry你是使用后higherEntry,lowerEntry,ceilingEntry,或floorEntry方法.该descendingMap方法甚至为您提供了一种反转遍历顺序的显式方法.
8> Darshan Pate..：
迭代地图有几种方法.
这里是通过在地图中存储一百万个键值对来比较它们在地图中存储的公共数据集的性能,并将迭代在地图上.
1)entrySet()在每个循环中使用in
for (Map.Entry entry : testMap.entrySet()) {
entry.getKey();
entry.getValue();
}
50毫秒
2)keySet()为每个循环使用in
for (String key : testMap.keySet()) {
testMap.get(key);
}
76毫秒
3)使用entrySet()和迭代器
Iterator> itr1 = testMap.entrySet().iterator();
while(itr1.hasNext()) {
Map.Entry 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.
9> Chris Dail..：
正确的方法是使用接受的答案,因为它是最有效的.我发现以下代码看起来更清晰.
for (String key: map.keySet()) {
System.out.println(key + "/" + map.get(key));
}
这不是最好的方法,使用entrySet()会更有效.Findbugs将标记此代码(请参阅http://findbugs.sourceforge.net/bugDescriptions.html#WMI_WRONG_MAP_ITERATOR)
@JeffOlson嗯,不是真的.map lookup是O(1),因此两个循环的行为方式相同.不可否认,在微观基准测试中它会稍微慢一点,但我有时也会这样做,因为我讨厌一遍又一遍地写出类型参数.此外,这很可能永远不会成为您的性能瓶颈,所以如果它使代码更具可读性,那就去做吧.
更详细:`O(1)= 2*O(1)`几乎是大O符号的定义.你是对的,因为它运行得有点慢,但就复杂性而言,它们是相同的.
通过碰撞与否,我的意思是,如果你发生一些碰撞并不重要,显然如果你只有碰撞,这是一个不同的故事.所以你很小气,但是,你所说的是真的.
@Jeff Olson:当只有一个常数因素时,"大O"复杂性不会改变的评论是正确的.不过,对我而言,操作是否需要一个小时或两个小时.更重要的是,必须强调的是,因子是**而不是**2,因为迭代`entrySet()`根本没有查找; 它只是所有条目的线性遍历.相反,迭代`keySet()`并执行每个键的查找每个键有*一个*查找,所以我们在这里讨论零查找与*n*查找,*n*是`的大小Map`.所以这个因素远远超过了"2"......
@kornero:值得注意的是,您不需要密钥具有相同的哈希码来进行冲突; 当`hashcode%capacity`相同时,已经发生了冲突.从Java 8开始,具有相同`hashcode%capacity`但不同`hashcode`或`Comparable`的项的复杂性回落到'O(log n)`并且只有具有相同哈希码的键而不是`可比较的`强加'O(n)`复杂性.但是在实践中查找的复杂性可能超过"O(1)"的说法仍然存在.
10> ckpwong..：
仅供参考,您也可以使用map.keySet(),map.values()如果您只对地图的键/值感兴趣,而不是对另一个感兴趣.
11> Donald Raab..：
使用Eclipse Collections(以前称为GS Collections),您将在MapIterable接口上使用forEachKeyValue方法,该方法由MutableMap和ImmutableMap接口及其实现继承.
final MutableBag result = Bags.mutable.empty();
MutableMap map = Maps.mutable.of(1, "One", 2, "Two", 3, "Three");
map.forEachKeyValue(new Procedure2()
{
public void value(Integer key, String value)
{
result.add(key + value);
}
});
Assert.assertEquals(Bags.mutable.of("1One", "2Two", "3Three"), result);
使用Java 8 lambda语法,您可以按如下方式编写代码:
MutableBag result = Bags.mutable.empty();
MutableMap 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的提交者.
12> Nitin Mahesh..：
Lambda Expression Java 8
在Java 1.8(Java 8)中,通过使用类似于来自Iterable Interface的迭代器的聚合操作(流操作)的forEach方法,这变得更加容易.
只需将下面的语句粘贴到您的代码中,然后将HashMap变量从hm重命名为HashMap变量,以打印出键值对.
HashMap hm = new HashMap();
/*
* 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 hm = new HashMap();
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();
UPDATE
包括Oracle Docs的文档链接.有关Lambda的更多信息,请转到此链接,并且必须阅读Aggregate Operations,对于Spliterator,请转到此链接.
13> Leigh Caldwe..：
从理论上讲,最有效的方法将取决于Map的实现.执行此操作的官方方法是调用map.entrySet(),返回一组Map.Entry,每组包含一个键和一个值(entry.getKey()和entry.getValue()).
在一个特质实现,它可能使一些与你是否使用map.keySet(),map.entrySet()或别的东西.但我想不出有人会这样写的原因.很可能它对你的表现没有任何影响.
是的,订单将取决于实施 - 以及(可能)插入顺序和其他难以控制的因素.
[编辑]我valueSet()原本写的,但当然entrySet()实际上是答案.
14> i_am_zero..：
Java 8
我们有forEach接受lambda表达式的方法.我们还有流 API.考虑一张地图:
Map 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().
forEachOrderedVS forEach与流？
在forEach不遵循遭遇订单(如果定义)和固有地非确定性的性质的,其中作为forEachOrdered一样.因此,forEach不保证订单会被保留.另外,请查看此内容.
15> George Siggo..：
Java 8:
您可以使用lambda表达式:
myMap.entrySet().stream().forEach((entry) -> {
Object currentKey = entry.getKey();
Object currentValue = entry.getValue();
});
有关更多信息,请按照此操作.
如果您只想迭代地图,则不需要流.`myMap.forEach((currentKey,currentValue) - >/*action*/);`更简洁.
16> 小智..：
尝试使用Java 1.4:
for( Iterator entries = myMap.entrySet().iterator(); entries.hasNext();){
Entry entry = (Entry) entries.next();
System.out.println(entry.getKey() + "/" + entry.getValue());
//...
}
17> Taras Melnyk..：
使用Java 8
map.forEach((k, v) -> System.out.println((k + ":" + v)));
18> Rupesh Yadav..：
在地图中,一个可以迭代keys和/或values和/或both (e.g., entrySet) 取决于一个人的兴趣_喜欢:
1.)遍历keys -> keySet()地图:
Map 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 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);
}
19> bluehallu..：
最紧凑的Java 8:
map.entrySet().forEach(System.out::println);
20> Fathah Rehma..：
public class abcd{
public static void main(String[] args)
{
Map testMap = new HashMap();
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);
}
}
}
要么
public class abcd {
public static void main(String[] args)
{
Map testMap = new HashMap();
testMap.put(10, "a");
testMap.put(20, "b");
testMap.put(30, "c");
testMap.put(40, "d");
for (Entry entry : testMap.entrySet()) {
Integer key=entry.getKey();
String value=entry.getValue();
}
}
}
21> dmunozfer..：
如果您有一个通用的无类型地图,您可以使用:
Map map = new HashMap();
for (Map.Entry entry : ((Set) map.entrySet())) {
System.out.println(entry.getKey() + "/" + entry.getValue());
}
22> 小智..：
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());
}
23> Pranoti..：
你可以使用泛型来做到这一点:
Map map = new HashMap();
Iterator> entries = map.entrySet().iterator();
while (entries.hasNext()) {
Map.Entry entry = entries.next();
System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
}
24> ABHAY JOHRI..：
使用Java 8:
map.entrySet().forEach(entry -> System.out.println(entry.getValue()));
已经有多个答案有相同的建议.
25> Witold Kaczu..：
排序将始终取决于具体的地图实施.使用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的Integer对象:
map.entrySet()
.stream()
.filter(e-> e.getValue() > 5)
.forEach(System.out::println);
下面的代码显示了LinkedHashMap和普通HashMap的迭代(示例).你会看到顺序的不同:
public class HMIteration {
public static void main(String[] args) {
Map linkedHashMap = new LinkedHashMap<>();
Map 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,
26> Sajad Nasiri..：
//Functional Oprations
Map mapString = new HashMap<>();
mapString.entrySet().stream().map((entry) -> {
String mapKey = entry.getKey();
return entry;
}).forEach((entry) -> {
String mapValue = entry.getValue();
});
//Intrator
Map mapString = new HashMap<>();
for (Iterator> it = mapString.entrySet().iterator(); it.hasNext();) {
Map.Entry entry = it.next();
String mapKey = entry.getKey();
String mapValue = entry.getValue();
}
//Simple for loop
Map mapString = new HashMap<>();
for (Map.Entry entry : mapString.entrySet()) {
String mapKey = entry.getKey();
String mapValue = entry.getValue();
}
27> Suresh Atta..：
是的,因为许多人都认为这是迭代a的最好方法Map.
但是,nullpointerexception如果地图是,则有机会抛出null.别忘了把null.check 放进去.
|
|
- - - -
|
|
for (Map.Entry entry : map.entrySet()) {
String key = entry.getKey();
Object value = entry.getValue();
}
28> anandchaugul..：
在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");
}
});
29> Rupendra Sha..：
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 map = new HashMap();
map.put("ram", "ayodhya");
map.put("krishan", "mathura");
map.put("shiv", "kailash");
System.out.println("********* Keys *********");
Set keys = map.keySet();
for (String key : keys) {
System.out.println(key);
}
System.out.println("********* Values *********");
Collection values = map.values();
for (String value : values) {
System.out.println(value);
}
System.out.println("***** Keys and Values (Using for each loop) *****");
for (Map.Entry entry : map.entrySet()) {
System.out.println("Key: " + entry.getKey() + "\t Value: "
+ entry.getValue());
}
System.out.println("***** Keys and Values (Using while loop) *****");
Iterator> entries = map.entrySet().iterator();
while (entries.hasNext()) {
Map.Entry entry = (Map.Entry) 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));
}
}
30> 小智..：
有很多方法可以做到这一点.以下是几个简单的步骤:
假设您有一个地图,如:
Map m = new HashMap();
然后你可以做类似下面的事情迭代地图元素.
// ********** Using an iterator ****************
Iterator> me = m.entrySet().iterator();
while(me.hasNext()){
Entry pair = me.next();
System.out.println(pair.getKey() + ":" + pair.getValue());
}
// *********** Using foreach ************************
for(Entry 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 me = m.keySet().iterator();
while(me.hasNext()){
String key = me.next();
System.out.println(key + " : " + m.get(key));
}
京公网安备 11010802040832号