Как эффективно перебрать каждую запись на карте Java?

Если у меня есть объект, реализующий Mapинтерфейс на Java, и я хочу перебирать каждую пару, содержащуюся в нем, каков наиболее эффективный способ прохождения карты?

Будет ли порядок элементов зависеть от конкретной реализации карты, которую я имею для интерфейса?

5.09.2008 21:12:48
В Java 8 используется лямбда-выражение: stackoverflow.com/a/25616206/1503859
Nitin Mahesh 25.07.2015 18:31:49
akhil_mittal 10.10.2018 12:45:28
30 ОТВЕТОВ
РЕШЕНИЕ
Map<String, String> map = ...
for (Map.Entry<String, String> entry : map.entrySet()) {
    System.out.println(entry.getKey() + "/" + entry.getValue());
}
4975
14.03.2019 22:20:24
Если вы сделаете это, то это не сработает, так как Entry - это вложенный класс в Map. java.sun.com/javase/6/docs/api/java/util/Map.html
ScArcher2 22.03.2010 13:30:04
вы можете написать импорт как "import java.util.Map.Entry;" и это будет работать.
jjujuma 30.04.2010 10:34:19
@Pureferret Единственная причина, по которой вы можете использовать итератор, - это необходимость вызывать его removeметод. Если это так, этот другой ответ покажет вам, как это сделать. В противном случае, расширенный цикл, как показано в ответе выше, - это путь.
assylias 8.10.2012 10:34:14
Я считаю, что форма Map.Entry понятнее, чем импорт внутреннего класса в текущее пространство имен.
JosiahYoder-deactive except.. 4.12.2014 20:31:27
Обратите внимание, что вы можете использовать map.values()или, map.keySet()если вы хотите перебирать только значения или ключи.
dguay 12.10.2016 21:03:58

Да, порядок зависит от конкретной реализации карты.

@ 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();
  // ...
}
239
6.02.2018 22:32:29
Предпочитаю цикл for, чем while .. for (Iterator records = myMap.entrySet (). Iterator (); records.hasNext ();) {...} С этим синтаксисом область «records» сводится только к циклу for ,
jai 20.10.2009 13:20:05
@jpredham Вы правы, что использование forконструкции as for (Entry e : myMap.entrySet)не позволит вам изменить коллекцию, но пример, как упомянул @HanuAthena, должен работать, так как он дает вам Iteratorохват. (Если я что-то упустил ...)
pkaeding 10.01.2012 15:42:29
IntelliJ выдает мне ошибки Entry thisEntry = (Entry) entries.next();: не распознает Entry. Это псевдокод для чего-то еще?
JohnK 10.01.2015 00:06:57
@JohnK попробуй импортировать java.util.Map.Entry.
pkaeding 14.01.2015 02:35:45
Это решение не будет работать, если у вас есть целочисленный ключ и строковый ключ.
user5778069 21.01.2017 08:09:19

Теоретически, наиболее эффективный способ будет зависеть от того, какая реализация Map. Официальный способ сделать это - вызвать map.entrySet(), который возвращает набор Map.Entry, каждый из которых содержит ключ и значение ( entry.getKey()и entry.getValue()).

В своеобразной реализации это может иметь какое-то значение, используете ли вы map.keySet(), map.entrySet()или что-то еще. Но я не могу придумать причину, по которой кто-то так написал бы. Скорее всего, это не имеет значения для производительности, что вы делаете.

И да, порядок будет зависеть от реализации - а также (возможно) порядка вставки и других трудно контролируемых факторов.

[править] Я написал valueSet()изначально, но, конечно, entrySet()на самом деле ответ.

34
4.05.2017 22:39:46

Типичный код для итерации по карте:

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обновляется.

136
9.02.2018 01:11:36
EnumMap также имеет это своеобразное поведение вместе с IdentityHashMap
Premraj 10.03.2011 15:41:06
«LinkedHashMap будет либо возвращать записи в [...] порядке доступа [...]» ... так что вы обращаетесь к элементам в том порядке, в котором вы к ним обращаетесь? Либо тавтологический, либо что-то интересное, что может использовать отступление. ;-)
jpaugh 26.01.2016 20:41:34
@jpaugh Только прямой доступ к LinkedHashMapграфу. Те , через iterator, spliterator, entrySetи т.д., не изменяют порядок.
Tom Hawtin - tackline 26.01.2016 21:24:00
1. хотяесли ? 2. Последний абзац может выиграть от зачистки.
Peter Mortensen 6.02.2018 22:36:54

Это вопрос из двух частей:

Как перебирать записи на карте - @ ScArcher2 ответил на это отлично.

Каков порядок итерации - если вы просто используете Map, то, строго говоря, нет никаких гарантий порядка . Таким образом, вы не должны полагаться на порядок, заданный любой реализацией. Тем не менее, SortedMapинтерфейс расширяется Mapи обеспечивает именно то, что вы ищете - реализации всегда будут давать согласованный порядок сортировки.

NavigableMapЕще одно полезное расширение - это SortedMapс дополнительными методами для поиска записей по их упорядоченной позиции в наборе ключей. Таким образом , потенциально это может устранить необходимость в переборе в первую очередь - Вы могли бы быть в состоянии найти специфические entryвы после использования higherEntry, lowerEntry, ceilingEntryили floorEntryметоды. Этот descendingMapметод даже дает вам явный метод изменения порядка обхода .

98
23.05.2017 11:47:32

К вашему сведению, вы также можете использовать map.keySet()и, map.values()если вас интересуют только ключи / значения карты, а не другие.

55
5.09.2008 22:27:52

Правильный способ сделать это - использовать принятый ответ, так как он наиболее эффективен. Я считаю, что следующий код выглядит немного чище.

for (String key: map.keySet()) {
   System.out.println(key + "/" + map.get(key));
}
56
17.10.2011 00:16:44
Это не лучший подход, гораздо эффективнее использовать entrySet (). Findbugs помечает этот код (см. Findbugs.sourceforge.net/… )
Jeff Olson 6.11.2009 20:46:26
@ДжеффОлсон, не очень. поиск по карте равен O (1), поэтому оба цикла ведут себя одинаково. по общему признанию, это будет немного медленнее в микро тесте, но я иногда делаю это также, потому что я ненавижу писать аргументы типа снова и снова. Кроме того, это, скорее всего, никогда не станет вашим узким местом в производительности, поэтому сделайте это, если это сделает код более читабельным.
kritzikratzi 8.10.2012 13:25:12
более подробно: O(1) = 2*O(1)это в значительной степени определение большой O нотации. вы правы в том, что он работает немного медленнее, но с точки зрения сложности они одинаковы.
kritzikratzi 8.10.2012 23:26:27
под столкновением или нет, я имел в виду, что не имеет значения, если вы несколько столкновений, очевидно, это другая история, если у вас есть только столкновения. так что ты довольно мелок, но да, то, что ты говоришь, правда.
kritzikratzi 23.12.2012 16:17:11
@Джефф Олсон: комментарии о том, что сложность «большого О» не меняется, когда присутствует только постоянный фактор, верны. Тем не менее, для меня важно, займет ли операция один час или два часа. Что еще более важно, следует подчеркнуть, что это не так 2 , поскольку итерирование по an entrySet()вообще не несет поиска; это просто линейный обход всех записей. В отличие от этого, выполнение итерации keySet()и выполнение поиска по ключу требует одного поиска по ключу, поэтому мы говорим о нулевом поиске против n поисков здесь, где n равно размеру Map. Таким образом, фактор далеко за пределами 2...
Holger 9.11.2016 12:22:02

Пример использования итератора и обобщений:

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();
  // ...
}
117
18.08.2009 17:34:51
Вы должны вставить Iteratorцикл for, чтобы ограничить его область действия.
Steve Kuo 17.02.2012 20:32:02
@SteveKuo Что вы подразумеваете под «ограничить область действия»?
StudioWorks 3.02.2015 16:13:23
@StudioWorks for (Iterator<Map.Entry<K, V>> entries = myMap.entrySet().iterator(); entries.hasNext(); ) { Map.Entry<K, V> entry = entries.next(); }. Используя эту конструкцию, мы ограничиваем область действия (видимость переменной) entriesциклом for.
ComFreek 13.03.2015 16:33:37
@ ComFreek О, я вижу. Не знал, что это так важно.
StudioWorks 13.03.2015 16:59:35

Попробуйте это с Java 1.4:

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

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

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

  //...
}
27
7.06.2013 14:34:44
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();
        }
    }
}
20
7.06.2013 14:34:13

С Eclipse , коллекцией , вы должны использовать forEachKeyValueметод на MapIterableинтерфейсе, который наследуется MutableMapи ImmutableMapинтерфейсами и их реализации.

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.

39
13.04.2020 19:49:46

Да, как многие люди согласились, что это лучший способ перебрать Map.

Но есть шансы бросить, nullpointerexceptionесли карта есть null. Не забудьте вставить null.check.

                                                 |
                                                 |
                                         - - - -
                                       |
                                       |
for (Map.Entry<String, Object> entry : map.entrySet()) {
    String key = entry.getKey();
    Object value = entry.getValue();
}
9
6.02.2018 22:40:17

Вы можете сделать это, используя дженерики:

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());
}
13
16.03.2016 15:54:24

В Java 8 вы можете сделать это чисто и быстро, используя новые функции лямбда-выражений:

 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.

Очень просто!

288
7.09.2016 08:33:17
В зависимости от того, что вы хотите сделать с картой, вы также можете использовать потоковый API для записей, возвращаемых map.entrySet().stream() docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html
Vitalii Fedorenko 28.06.2014 12:46:14
Это не сработает, если вы хотите ссылаться на не финальные переменные, объявленные вне лямбда-выражения изнутри forEach () ...
Chris 20.04.2017 20:29:31
@ Крис Правильно. Это не сработает, если вы попытаетесь эффективно использовать не конечные переменные извне лямбды.
The Coordinator 21.04.2017 21:44:16

Если у вас есть общая нетипизированная карта, вы можете использовать:

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

Есть несколько способов перебора карты. Пожалуйста, обратитесь к следующему коду.

Когда вы выполняете итерацию карты, используя интерфейс итератора, вы должны использовать Entry <K, V> или 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));
        }
    }
}
5
26.11.2018 22:28:24
keySet () медленный
edin-m 29.11.2019 03:38:38

В 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
29.01.2014 12:35:03

Есть несколько способов перебора карты.

Вот сравнение их характеристик для общего набора данных, хранящегося в карте, путем сохранения миллиона пар ключ-значение в карте и будет повторяться по карте.

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.

80
18.07.2015 15:58:26
Время выполнения взято из статьи, в которой не используется Java Microbenchmarking Harness. Поэтому времена ненадежны, так как, например, код мог быть полностью оптимизирован компилятором JIT.
AlexB 14.01.2019 13:44:28
    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
14.01.2016 20:58:30

Java 8:

Вы можете использовать лямбда-выражения:

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

Для получения дополнительной информации, следуйте этому .

31
6.02.2018 03:37:46
@injecteer: кажется мотив лямбда-выражений
humblerookie 21.08.2014 19:49:06
Вам не нужен поток, если вы просто хотите перебрать карту. myMap.forEach( (currentKey,currentValue) -> /* action */ );гораздо более кратким.
Holger 9.11.2016 12:37:24

Я скопировал данные карты в другую с помощью этого кода:

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());
}
1
21.08.2014 22:15:17

Это не совсем отвечает на вопрос ОП, но может быть полезно для других, кто находит эту страницу:

Если вам нужны только значения, а не ключи, вы можете сделать это:

Map<Ktype, Vtype> myMap = [...];
for (Vtype v: myMap.values()) {
  System.out.println("value: " + v);
}

Ktype, VtypeЯвляются псевдокод.

2
10.01.2015 00:22:38

Вот общий типобезопасный метод, который может быть вызван для дампа любого заданного 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();
        }
    }
}

Вывод

One = 0
Two = 1
Three = 3

Object = java.lang.Object@15db9742
Integer = 0
Double = 0.0
6
6.02.2018 22:52:46

Я считаю, что это самый простой способ сделать это ...

/* 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();
}
1
31.05.2015 02:05:27

Если ваша причина для итерации через Map, состоит в том , чтобы выполнить операцию над значением и записать результат Map. Я рекомендую использовать transform-методы в классе Google Guava 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);
}
4
29.08.2015 17:11:44

Java 8

У нас есть forEachметод, который принимает лямбда-выражения . У нас также есть потоковые 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против forEachпотоков? Они forEachне следуют порядку встреч (если они определены) и по своей природе недетерминированы по своей природе forEachOrdered. Так forEachчто не гарантирует, что заказ будет сохранен. Также проверьте это для большего.

34
29.04.2019 05:52:35

Лямбда- выражение Java 8

В Java 1.8 (Java 8) это стало намного проще благодаря использованию метода forEach из Aggregate операций ( потоковых операций ), который похож на итераторы из Iterable Interface.

Просто скопируйте оператор вставки ниже в свой код и переименуйте переменную 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.

Ниже приведен пример кода, который я пытался использовать с помощью лямбда-выражения . Это так круто. Должен попробовать.

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, перейдите по этой ссылке и прочитайте Aggregate Operations, а для Spliterator перейдите по этой ссылке .

35
30.04.2019 13:05:59

Если вы хотите перебрать карту в порядке добавления элементов, используйте LinkedHashMapвместо just 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
2
27.10.2015 18:09:34

Чтобы суммировать другие ответы и объединить их с тем, что я знаю, я нашел 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. Использование foreach и Map.Entry

    long i = 0;
    for (Map.Entry<Integer, Integer> pair : map.entrySet()) {
        i += pair.getKey() + pair.getValue();
    }
  3. Использование forEach из Java 8

    final long[] i = {0};
    map.forEach((k, v) -> i[0] += k + v);
  4. Использование keySet и foreach

    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. Использование для и 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();
    }
  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. Используя IterableMap изApache Collections

    long i = 0;
    MapIterator<Integer, Integer> it = iterableMap.mapIterator();
    while (it.hasNext()) {
        i += it.next() + it.getValue();
    }
  10. Использование MutableMap коллекций Eclipse (CS)

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

Тесты производительности (режим = Среднее время, система = 64-битная Windows 8.1, Intel i7-4790 3,60 ГГц, 16 ГБ)

  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 .

1191
5.08.2019 20:12:22
@Viacheslav: очень хороший ответ. Просто интересно, как в вашем тесте API Java8 мешают захватывать лямбды ... (например, long sum = 0; map.forEach( /* accumulate in variable sum*/);захватывает sumдлинный, который может быть медленнее, чем, stream.mapToInt(/*whatever*/).sumнапример, скажем. Конечно, вы не всегда можете избежать захвата состояния, но это может быть разумным дополнением). на скамейку запасных
GPI 12.05.2016 11:53:34
Ваш 8 тест неверен. он обращается к одной и той же переменной из разных потоков без синхронизации. Перейдите для AtomicIntegerрешения проблемы.
talex 13.09.2016 15:20:53
@ZhekaKozlov: посмотрите на невероятно большие значения ошибок. Предположим, что результат теста x±eподразумевает наличие результата в интервале от x-eдо x+e, поэтому самый быстрый результат ( 1184.767±332.968) варьируется от 852до 1518, тогда как второй самый медленный ( 1706.676±436.867) выполняется между 1270и 2144, поэтому результаты по-прежнему существенно перекрываются. Теперь посмотрим на самый медленный результат, 3289.866±1445.564который подразумевает расхождение между 1844и, 4735и вы знаете, что эти результаты теста не имеют смысла.
Holger 17.03.2017 18:28:28
А как насчет сравнения 3 основных реализаций: HashMap, LinkedHashMap и TreeMap?
Thierry 7.11.2017 23:37:57
№ 1 и № 6 абсолютно одинаковы. Использование whileпротив forцикла не является другой техникой для итерации. И я удивлен, что в ваших тестах между ними существует такая разница - это говорит о том, что тесты не изолированы должным образом от внешних факторов, не связанных с тем, что вы собираетесь тестировать.
ErikE 14.07.2018 19:04:12
           //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
13.04.2016 07:47:46