обновить существующий ключ HashMap

Question

У меня есть HashMap длины 3:

1=>"Value1"
2=>"Value2"
3=>"Value3"

Теперь я хочу уменьшить все ключи на 1 (если ключ> 1): Выход:

1=>"Value2"
2=>"Value3"

Что я пытаюсь

  for (e in hashMap.entries) {
                                val entry = e as Map.Entry<*, *>
                                var keyPos = (entry.key as Int)
                                if (keyPos != -1) {
                                    if (keyPos > 1) {
                                        keyPos = keyPos - 1
                                        if (keyPos != -1) {
                                            hashMap.put(keyPos, entry.value as String?)
                                        }
                                    }
                                }
                            }

Но это не дает требуемого вывода.

Как заставить это работать без исключения Concurrency.

Answer 1

public static void main(String[] args) {
    HashMap<Integer, String> map = new HashMap<>();

    // Populate the HashMap
    map.put(1, "Value1");
    map.put(2, "Value2");
    map.put(3, "Value3");
    System.out.println("Original HashMap: "
            + map); 
    decreaseAllKeysByOne(map);
}

private static void decreaseAllKeysByOne(HashMap<Integer, String> map) {
    // Add your condition (if key>1)
    HashMap<Integer, String> newMap = new HashMap<>();
    map.remove(1);


    Iterator<Map.Entry<Integer, String>> iterator = map.entrySet().iterator();
    int i = 1;
    while (iterator.hasNext()) {
        Map.Entry<Integer, String> entry = iterator.next();
        newMap.put(i, entry.getValue());
        i++;
    }
    System.out.println("Modified HashMap: "
            + newMap);
}

Вывод:

Исходная хэш-карта: {1 = значение1, 2 = значение2, 3 = значение3}

измененная хэш-карта: {1 = значение2, 2 = значение3}

Answer 2

Альтернативой является использование функции расширения mapKeys, которая позволяет переопределить ключ для записи карты:

fun main() {
    val originalMap = mapOf(1 to "value1", 2 to "value2", 3 to "value3")
    val updatedMap = originalMap
        .mapKeys {
            if (it.key > 1) {
                it.key - 1
            } else {
                it.key
            }
        }

    println(updatedMap) // prints: {1=value2, 2=value3}
}

Обратите внимание, что это не приведет к обновлению карты вместо, но оно создаст новое.Также обратите внимание, что:

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

Это означает, что если два ключа конфликтуют, в общем случае вы не можете знать, какой из них "выиграет" (если вы не используете LinkedHashMap, который сохраняет порядок вставки).

Более общийподход будет следующим:

1. уменьшить все ключи
2. отфильтровать все неположительные ключи

Это потребует 2 полных итераций, (есливы используете Sequences, которые лениво оцениваются):

fun main() {
    val originalMap = mapOf(1 to "value1", 2 to "value2", 3 to "value3")
    val updatedMap = originalMap
        .mapKeys {
            it.key - 1
        }.filter {
            it.key > 0
        }

    println(updatedMap)
}

Answer 3

РЕДАКТИРОВАТЬ: здесь то же самое с Java 7-совместимым кодом (без потоков)

HashMap<Integer, String> hashMap = new HashMap<>();
hashMap.put(1, "test1");
hashMap.put(2, "test2");
hashMap.put(3, "test3");

Map<Integer, String> yourNewHashMap = new HashMap<>();
for (final Map.Entry<Integer, String> entry : hashMap.entrySet()) {
    if (entry.getKey() != 1) { // make sure index 1 is omitted
        yourNewHashMap.put(entry.getKey() - 1, entry.getValue()); // decrease the index for each key/value pair and add it to the new map
    }
}

---

---

Старый ответ с потоками:

Поскольку новый объект Map вам подходит, я бы пошел со следующим потоком: комментарии встроены

HashMap<Integer, String> hashMap = new HashMap<>();
hashMap.put(1, "test1");
hashMap.put(2, "test2");
hashMap.put(3, "test3");

// use this
Map<Integer, String> yourNewHashMap = hashMap.entrySet().stream()
                                       .filter(es -> es.getKey() != 1) // make sure index 1 is omitted
                                       .map(es -> new AbstractMap.SimpleEntry<Integer, String>(es.getKey() - 1, es.getValue())) // decrease the index for each key/value pair
                                       .collect(Collectors.toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue)); // create a new map