Java-итератороподобная конструкция для одновременной модификации карты

Это может показаться спорным, но если вас не волнует одновременная модификация, почему бы вам не использовать LinkedHashMap и не игнорировать ConcurrentModificationException?

В принципе:

try {
   myMap.values().forEach(this::doSomething);
}
catch (ConcurrentModificationException ignored) {
}

Я думаю, что это будет работать с LinkedHashMap, но это явно не по назначению. Однако вы можете реализовать свою собственную версию, предназначенную для такого использования.

«Правильный» способ - сделать копии значений или ключей, которые вы хотите перебрать, а затем проверить, было ли что-то добавлено. Грубо:

final Set<K> processedKeys = new HashSet<>();

do {
   final Set<K> keysToProcess = new HashSet<>(myMap.keySet());
   keysToProcess.removeAll(processedKeys);
   keysToProcess.forEach(key -> doSomething(myMap.get(key)));
} while (!keysToProcess.isEmpty());

Обновление для @doublep и @RealSkeptic — почему я думаю, что простое игнорирование исключения в myMap.values().forEach(this::doSomething); сработает.

См. код для forEach или коллекции, возвращенной values() в LinkedHashMap:

    public final void forEach(Consumer<? super V> action) {
        if (action == null)
            throw new NullPointerException();
        int mc = modCount;
        for (LinkedHashMap.Entry<K,V> e = head; e != null; e = e.after)
            action.accept(e.value);
        if (modCount != mc)
            throw new ConcurrentModificationException();
    }

Итак, forEach выполняет итерацию по связанному списку. Если значения добавляются на карту, они будут добавлены в список, поэтому цикл for будет повторяться, пока не достигнет конца связанного списка. И сначала затем метод проверяет количество модификаций. Таким образом, действие будет эффективно применено ко всем значениям, даже к вновь добавленным.

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

for(int i=myList.size()-1;i>=0;i--) {
        Object item = myList.get(i);
        if(needsToBeRemoved(item)) {
            myList.remove(i);
        }
}

Таким образом, вы можете манипулировать списком во время его повторения. Это справедливо для списков, поскольку вы можете получить доступ к его элементам по индексу, помимо итератора.

Вы также можете применить ту же технику при обработке карт, если она следует какой-то сортировке, которая не изменяется при обработке (упорядоченная карта).

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

Обновление:

Вы также можете использовать вспомогательный итератор (список ключей). Например.:

public static void main(String[] args) {
        Map<Long, String> map = new HashMap<>();
        map.put(1L, "Start");
        map.put(10L, "End");

        // This throws ConcurrentModificationException
        // for (Long value : map.keySet()) {
        // map.put(value + 1, "Other");
        // }
        for (Long value : new ArrayList<Long>(map.keySet())) {
            // This works ok
            map.put(value + 1, "Other");
        }

        System.out.println(map);
        // Prints: {1=Start, 2=Other, 10=End, 11=Other}
    }

Итерация по индексам, а не по фактической коллекции - малоизвестный трюк, который здесь сработает. Вы можете получить n-й элемент с помощью потокового API. Я не уверен, насколько это будет эффективно из-за создания всех промежуточных объектов.

LinkedHashMap<String, String> lhm = new LinkedHashMap();        
// fill lhm
for ( int idx=0; idx < lhm.size(); idx++ ) {
    String val = lhm.values().stream().skip(idx).findFirst().get();
    // process val...
}

Встроенного способа нет, но это не так сложно, если вы используете вариант шаблона производитель/потребитель, где очередь обработки обновляется на каждой итерации:

Map<K, V> map; // assuming
Set<V> processed = new HashSet<>();
while (!map.values().containsAll(processed)) {
    List<V> queue = new ArrayList<>(map.values());
    queue.removeAll(processed);
    V x = queue.get(0);
    processed.add(x);
    doSomething(x);
}