如何有效地遍历Java Map中的每个条目?


3301

如果我有一个Map用Java 实现该接口的对象,并且希望对其中包含的每一对进行迭代,那么遍历该映射的最有效方法是什么?

元素的顺序是否取决于接口的特定映射实现?


38
在使用Lambda表达式的Java 8中:stackoverflow.com/a/25616206/1503859
Nitin Mahesh,

Answers:


5027
Map<String, String> map = ...
for (Map.Entry<String, String> entry : map.entrySet()) {
    System.out.println(entry.getKey() + "/" + entry.getValue());
}

93
如果这样做,则由于Entry是Map中的嵌套类,因此它将不起作用。java.sun.com/javase/6/docs/api/java/util/Map.html
ScArcher2年

266
您可以将导入写为“ import java.util.Map.Entry;”。它会工作。
jjujuma 2010年

55
@Pureferret您可能要使用迭代器的唯一原因是是否需要调用其remove方法。如果是这种情况,另一个答案将向您展示如何进行。否则,如上面答案中所示的增强循环是可行的方法。
assylias,2012年

102
我相信Map.Entry的形式比将内部类导入当前名称空间更清晰。
JosiahYoder无效,.. 2014年

31
请注意,您可以使用map.values()map.keySet()如果只想遍历值或键。
dguay 16-10-12

1214

总结其他答案并将其与我所知道的结合起来,我找到了10种主要方法(请参见下文)。另外,我编写了一些性能测试(请参见下面的结果)。例如,如果要查找映射的所有键和值的总和,则可以编写:

  1. 使用迭代器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();
    }
    
  2. 使用foreachMap.Entry

    long i = 0;
    for (Map.Entry<Integer, Integer> pair : map.entrySet()) {
        i += pair.getKey() + pair.getValue();
    }
    
  3. 从Java 8 使用forEach

    final long[] i = {0};
    map.forEach((k, v) -> i[0] += k + v);
    
  4. 使用keySetforeach

    long i = 0;
    for (Integer key : map.keySet()) {
        i += key + map.get(key);
    }
    
  5. 使用keySet迭代器

    long i = 0;
    Iterator<Integer> itr2 = map.keySet().iterator();
    while (itr2.hasNext()) {
        Integer key = itr2.next();
        i += key + map.get(key);
    }
    
  6. 使用forMap.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();
    }
    
  7. 使用Java 8 Stream API

    final long[] i = {0};
    map.entrySet().stream().forEach(e -> i[0] += e.getKey() + e.getValue());
    
  8. 并行使用Java 8 Stream API

    final long[] i = {0};
    map.entrySet().stream().parallel().forEach(e -> i[0] += e.getKey() + e.getValue());
    
  9. 使用IterableMapApache Collections

    long i = 0;
    MapIterator<Integer, Integer> it = iterableMap.mapIterator();
    while (it.hasNext()) {
        i += it.next() + it.getValue();
    }
    
  10. 使用Eclipse MutableMap(CS)集合

    final long[] i = {0};
    mutableMap.forEachKeyValue((key, value) -> {
        i[0] += key + value;
    });
    

性能测试(模式=平均时间,系统= Windows 8.1 64位,英特尔i7-4790 3.60 GHz,16 GB)

  1. 对于小地图(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
    
  2. 对于具有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
    
  3. 对于包含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
    

图形(性能测试取决于地图大小)

在此处输入图片说明

表格(性能测试,取决于地图大小)

          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上


9
@Viacheslav:非常好的答案。只是想知道在您的基准测试中如何通过捕获lambda来阻碍Java8 api ...(例如,long sum = 0; map.forEach( /* accumulate in variable sum*/);捕获sumlong,这可能比说的要慢stream.mapToInt(/*whatever*/).sum。当然,您不能总是避免捕获状态,但这可能是一个合理的补充)替补席上。
GPI

17
您的8测试错误。它从不同的线程访问相同的变量而无需同步。改变AtomicInteger以解决问题。
talex

44
@ZhekaKozlov:看看令人难以置信的大错误值。考虑的试验结果x±e暗示存在的区间内是从结果x-ex+e,所以最快结果(1184.767±332.968)的范围是从8521518,而第二慢(1706.676±436.867)之间运行12702144,所以结果仍然重叠显著。现在来看最慢的结果,3289.866±1445.564这意味着在1844和之间会出现分歧,4735并且您知道这些测试结果毫无意义。
Holger

8
比较三个主要实现:HashMap,LinkedHashMap和TreeMap呢?
蒂埃里

9
#1和#6完全相同。使用whilevs. for循环并不是迭代的另一种技术。让我感到惊讶的是,它们在您的测试中会如此变异-这表明测试没有与与您要测试的事物无关的外部因素正确隔离。
ErikE

293

在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));

该类型的kv将会由编译器来推断,也没有必要使用Map.Entry了。

十分简单!


12
根据您要对地图执行的操作,还可以在map.entrySet().stream() docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html
Vitalii Fedorenko

1
如果您想从forEach()内部引用在lambda表达式外部声明的非最终变量,则此方法将无效。–
克里斯

7
@克里斯正确。如果您尝试从lambda外部有效地使用非最终变量,则此方法将无效。
协调员

242

是的,顺序取决于特定的Map实现。

@ ScArcher2具有更优雅的Java 1.5语法。在1.4中,我将执行以下操作:

Iterator entries = myMap.entrySet().iterator();
while (entries.hasNext()) {
  Entry thisEntry = (Entry) entries.next();
  Object key = thisEntry.getKey();
  Object value = thisEntry.getValue();
  // ...
}

41
首选for循环,而不是while .. for(迭代器entrys = myMap.entrySet()。iterator(); entry.hasNext();){...}使用此语法,“ entries”范围缩小为仅for循环。
JAI

8
@jpredham是正确的,使用for构造方法as for (Entry e : myMap.entrySet)不允许修改集合,但是@HanuAthena提到的示例应该可以使用,因为它为您提供了Iterator作用域。(除非我错过了某件事...)
嘲笑2012年

1
IntelliJ给我错误Entry thisEntry = (Entry) entries.next();:无法识别Entry。该伪代码是否还包含其他内容?
JohnK 2015年

1
@JohnK尝试导入java.util.Map.Entry
2015年

1
如果您使用整数键和字符串键,则此解决方案将不起作用。

139

遍历地图的典型代码是:

Map<String,Thing> map = ...;
for (Map.Entry<String,Thing> entry : map.entrySet()) {
    String key = entry.getKey();
    Thing thing = entry.getValue();
    ...
}

HashMap是规范的地图实现,并且不做任何保证(或者,如果不执行任何变异操作,则不应该改变顺序)。SortedMap将根据键的自然顺序返回条目Comparator;如果提供,则返回a 。LinkedHashMap会以插入顺序或访问顺序返回条目,具体取决于其构造方式。EnumMap以键的自然顺序返回条目。

(更新:我认为这不再成立。)请注意,IdentityHashMap entrySet迭代器当前具有一个特殊的实现,该实现Map.EntryentrySet!中的每个项目返回相同的实例。但是,每次新的迭代器Map.Entry进行更新时,都会对其进行更新。


6
EnumMap和IdentityHashMap也具有这种特殊的行为
Premraj 2011年

1
“ LinkedHashMap会以访问顺序[...]返回条目。” ...那么您以访问元素的顺序来访问元素?可能是重言式的,也可能是有趣的东西,可能会使用题外话。;-)
jpaugh

5
@jpaugh仅直接访问LinkedHashMap计数。那些通过iteratorspliteratorentrySet,等,不修改订单。
Tom Hawtin-抢险

1
1. 虽然如果?2.最后一段可能会受益于重新整理。
彼得·莫滕森

120

使用迭代器和泛型的示例:

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();
  // ...
}

14
您应该放入Iteratorfor循环以限制其范围。
史蒂夫·郭

@SteveKuo“限制其范围”是什么意思?
StudioWorks

12
@StudioWorks for (Iterator<Map.Entry<K, V>> entries = myMap.entrySet().iterator(); entries.hasNext(); ) { Map.Entry<K, V> entry = entries.next(); }。通过使用该构造,我们将(变量可见性)的范围限制entries为for循环。
ComFreek

3
@ComFreek哦,我知道了。不知道那有多重要。
StudioWorks

101

这是一个两部分的问题:

如何遍历Map的条目 -@ ScArcher2已经完美地回答了这一问题。

迭代的顺序是什么 -如果仅使用Map,那么严格来说,没有排序保证。因此,您不应真正依赖任何实现所给出的顺序。但是,该SortedMap接口可以扩展Map并准确提供您要查找的内容-实现将给出一致的排序顺序。

NavigableMap是另一个有用的扩展 -这是一个SortedMap附加方法,可以通过按键在键集中的顺序位置查找条目。所以可能这个可以去除需要摆在首位迭代-你也许可以找到具体的entry你是使用后higherEntrylowerEntryceilingEntry,或floorEntry方法。该descendingMap方法甚至为您提供了一种反转遍历顺序的显式方法。


83

有几种方法可以遍历地图。

这是通过在地图中存储一百万个键值对并在地图上进行迭代来比较存储在地图中的通用数据集的性能。

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


1
运行时间来自本文,该文章未使用Java Microbenchmarking Harness。因此,时间是不可靠的,因为例如JIT编译器可以完全优化代码。
AlexB

58

正确的方法是使用公认的答案,因为它是最有效的。我发现以下代码看起来更干净。

for (String key: map.keySet()) {
   System.out.println(key + "/" + map.get(key));
}

15
这不是最好的方法,使用entrySet()效率更高。FindBugs的将标志代码(见findbugs.sourceforge.net/...
杰夫·奥尔森

6
@JeffOlson嗯,不是真的。映射查找为O(1),因此两个循环的行为均相同。诚然,在微基准测试中它会稍微慢一些,但是我有时也会这样做,因为我讨厌一遍又一遍地写类型参数。同样,这很可能永远不会成为您的性能瓶颈,因此,如果它使代码更具可读性,那就去做吧。
kritzikratzi 2012年

4
更详细:O(1) = 2*O(1)几乎是大O符号的定义。您说得对,因为它的运行速度稍慢,但就复杂性而言,它们是相同的。
kritzikratzi 2012年

2
通过碰撞与否,我的意思是几次碰撞都没有关系,如果只有碰撞,那显然是另外一回事了。所以你很琐碎,但是,是的,你说的是真的。
kritzikratzi

2
@杰夫·奥尔森(Jeff Olson):在只有一个常数因素的情况下,“大O”复杂度不变的评论是正确的。不过,对我而言,手术需要一个小时还是两个小时仍然很重要。更重要的是,必须强调的是,该因素不是 2,因为对进行迭代entrySet()根本不承担任何查找。它只是所有条目的线性遍历。与此相反,遍历keySet()每个键熊执行查找一个每个键查找,所以我们在谈论零个查找与ň查找这里,ñ是的大小Map。所以这个因素远远超出了2……
Holger

56

仅供参考,您也可以使用map.keySet()map.values()如果你在地图的键/值只关心,而不是其他。



40

对于Eclipse Collections,您将forEachKeyValueMapIterable接口上使用方法,该方法由MutableMapImmutableMap接口及其实现继承。

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);

使用匿名内部类,可以编写如下代码:

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);

注意:我是Eclipse Collections的提交者。


36

Lambda Expression Java 8

在Java 1.8(Java 8)中,通过使用看起来类似于Iterable Interface中的迭代器的Aggregate操作(Stream操作)中的forEach方法,这变得更加容易。

只需将下面的语句粘贴粘贴到您的代码中,然后将HashMap变量从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的更多信息,请访问此链接,并且必须阅读“ 聚合操作”;对于Spliterator,请访问此链接


35

从理论上讲,最有效的方法将取决于Map的实现方式。官方的方法是调用map.entrySet(),它返回一组Map.Entry,每个包含一个键和一个值(entry.getKey()entry.getValue())。

在一个特质实现,它可能使一些与你是否使用map.keySet()map.entrySet()或别的东西。但是我想不出有人会这样写的原因。最有可能的是它对您所做的工作没有影响。

是的,顺序将取决于实现方式-以及(可能)插入的顺序和其他难以控制的因素。

[编辑]我valueSet()最初写过,但entrySet()实际上实际上是答案。


35

Java 8

我们有forEach接受lambda表达式的方法。我们也有 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()

forEachOrderedVS forEach与流? 它们forEach不会遵循遇到顺序(如果已定义),并且本质上是不确定的,因为它们forEachOrdered确实如此。因此forEach,不能保证将保留订单。还要检查这个更多。


32

Java 8:

您可以使用lambda表达式:

myMap.entrySet().stream().forEach((entry) -> {
    Object currentKey = entry.getKey();
    Object currentValue = entry.getValue();
});

有关更多信息,请遵循


@injecteer:似乎是lambda表达式的动机
humblerookie 2014年

9
如果您只想遍历地图,则不需要流。myMap.forEach( (currentKey,currentValue) -> /* action */ );更简洁。
Holger

28

使用Java 1.4尝试一下:

for( Iterator entries = myMap.entrySet().iterator(); entries.hasNext();){

  Entry entry = (Entry) entries.next();

  System.out.println(entry.getKey() + "/" + entry.getValue());

  //...
}

25

在Map中,可以通过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...
    }

_此外,有3种不同的方法可以遍历HashMap。它们如下__

//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);
}

24

使用Java 8最紧凑:

map.entrySet().forEach(System.out::println);

21

如果您有通用的无类型Map,则可以使用:

Map map = new HashMap();
for (Map.Entry entry : ((Set<Map.Entry>) map.entrySet())) {
    System.out.println(entry.getKey() + "/" + entry.getValue());
}

20
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);
        }
    }
}

要么

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();
        }
    }
}

17

如果我有一个用Java实现Map接口的对象,并且希望对其中包含的每一对进行迭代,那么遍历该映射的最有效方法是什么?

如果循环密钥的效率是您应用程序的优先事项,那么请选择一种Map将密钥保持在所需顺序的实现。

元素的顺序是否取决于接口的特定映射实现?

是的,一点没错。

  • 一些Map实现承诺一定的迭代顺序,而另一些则没有。
  • Map保持键-值对的不同顺序的不同实现。

请参阅我创建的该表,其中概述了Map与Java 11捆绑在一起的各种实现。特别是,请注意迭代顺序列。单击/点击以缩放。

Java 11中的地图实现表,比较它们的功能

您可以看到有四个Map实现维护顺序

  • TreeMap
  • ConcurrentSkipListMap
  • LinkedHashMap
  • EnumMap

NavigableMap 接口

其中两个实现NavigableMap接口:TreeMapConcurrentSkipListMap

SortedMap界面被新NavigableMap界面有效取代。但是您可能会发现第三方实现仅实现了较旧的接口。

自然秩序

如果您想要一个Map按键的“自然顺序”排列成对的,请使用TreeMapConcurrentSkipListMap。术语“自然顺序”是指按键工具的类别Comparable。该compareTo方法返回的值用于排序比较。

定制订单

如果要为密钥指定自定义排序例程以用于维持排序顺序,请传递Comparator适合于密钥类的实现。使用TreeMapConcurrentSkipListMap,或通过Comparator

原始广告订单

如果您希望将地图对以原始顺序保存(将它们插入地图中的顺序),请使用LinkedHashMap

枚举定义顺序

如果您使用诸如DayOfWeekMonth作为键的枚举,请使用EnumMap该类。该类不仅经过高度优化,以使用很少的内存并运行得非常快,而且还按枚举定义的顺序维护您的配对。例如DayOfWeek,对于,DayOfWeek.MONDAY将在迭代时首先找到的密钥,DayOfWeek.SUNDAY将在最后找到。

其他注意事项

在选择Map实现时,还应考虑:

  • 空值。一些实现禁止/接受NULL作为键和/或值。
  • 并发。如果要跨线程操作映射,则必须使用支持并发的实现。或使用Collections::synchronizedMap(不太推荐)包装地图。

这两个注意事项均在上表中涵盖。


对晚了一个聚会的答案的最新评论(但很有帮助)。我是+1的人EnumMap,因为这是我第一次听说。在许多情况下,这可能会派上用场。
user991710

15

排序将始终取决于特定的地图实现。使用Java 8,您可以使用以下两种方法之一:

map.forEach((k,v) -> { System.out.println(k + ":" + v); });

要么:

map.entrySet().forEach((e) -> {
            System.out.println(e.getKey() + " : " + e.getValue());
        });

结果将是相同的(相同的顺序)。entrySet由地图支持,因此您将获得相同的订单。第二个是方便的,因为它允许您使用lambda,例如,如果您只想仅打印大于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<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,


14
    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());    
    }

14

使用Java 8:

map.entrySet().forEach(entry -> System.out.println(entry.getValue()));

13

您可以使用泛型来实现:

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());
}

12

在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");
    }
});

10
           //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();

            }

10

有很多方法可以做到这一点。以下是一些简单的步骤:

假设您有一张类似的地图:

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));
}

9
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));
    }
}
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.