Как обновить значение, учитывая ключ в hashmap?

Предположим, у нас есть HashMap<String, Integer>в Java.

Как обновить (увеличить) целочисленное значение строкового ключа для каждого существования найденной строки?

Можно было бы удалить и повторно ввести пару, но накладные расходы были бы проблемой.
Другим способом было бы просто поставить новую пару и заменить старую.

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

map.put(key, map.get(key) + 1);

все должно быть в порядке. Это обновит значение для существующего сопоставления. Обратите внимание, что это использует автобокс. С помощью map.get(key)мы получаем значение соответствующего ключа, после чего вы можете обновить его по вашему требованию. Здесь я обновляюсь, чтобы увеличить значение на 1.

Java 8 способ:

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

Например,

Map<String, Integer> words = new HashMap<>();
words.put("hello", 3);
words.put("world", 4);
words.computeIfPresent("hello", (k, v) -> v + 1);
System.out.println(words.get("hello"));

В качестве альтернативы вы можете использовать mergeметод, где 1 - это значение по умолчанию, а функция увеличивает существующее значение на 1:

words.merge("hello", 1, Integer::sum);

Кроме того, существует множество других полезных методов, таких , как putIfAbsent, getOrDefault, forEach, и т.д.

hashmap.put(key, hashmap.get(key) + 1);

Метод putбудет заменить значение существующего ключа и создаст его , если не существует.

Упрощенный способ Java 8 :

map.put(key, map.getOrDefault(key, 0) + 1);

При этом используется метод HashMap, который извлекает значение для ключа, но если ключ не может быть получен, он возвращает указанное значение по умолчанию (в данном случае «0»).

Это поддерживается в ядре Java: HashMap <K, V> getOrDefault (ключ объекта, V defaultValue)

Замените Integerна AtomicIntegerи вызовите один из методов incrementAndGet/ getAndIncrement.

Альтернатива заключается в том, чтобы обернуть intв свой собственный MutableIntegerкласс, у которого есть increment()метод, вам остается только решить проблему безопасности потоков.

Одноканальное решение:

map.put(key, map.containsKey(key) ? map.get(key) + 1 : 1);

Решение @ Мэтью является самым простым и в большинстве случаев будет работать достаточно хорошо.

Если вам нужна высокая производительность, AtomicInteger - более подходящее решение, например @BalusC.

Однако более быстрое решение (при условии, что безопасность потоков не является проблемой) заключается в использовании TObjectIntHashMap, который предоставляет метод приращения (ключ) и использует примитивы и меньшее количество объектов, чем при создании AtomicIntegers. например

TObjectIntHashMap<String> map = new TObjectIntHashMap<String>()
map.increment("aaa");

Вы можете увеличивать, как показано ниже, но вам нужно проверить существование, чтобы исключение NullPointerException

if(!map.containsKey(key)) {
 p.put(key,1);
}
else {
 p.put(key, map.getKey()+1);
}

Существует ли хэш (со значением 0) или он «помещен» на карту с первым шагом? Если он «помещен» в первый шаг, код должен выглядеть так:

if (hashmap.containsKey(key)) {
    hashmap.put(key, hashmap.get(key)+1);
} else { 
    hashmap.put(key,1);
}

Может быть немного поздно, но вот мои два цента.

Если вы используете Java 8, вы можете использовать метод computeIfPresent . Если значение для указанного ключа присутствует и не равно нулю, то оно пытается вычислить новое сопоставление, учитывая ключ и его текущее сопоставленное значение.

final Map<String,Integer> map1 = new HashMap<>();
map1.put("A",0);
map1.put("B",0);
map1.computeIfPresent("B",(k,v)->v+1);  //[A=0, B=1]

Мы также можем использовать другой метод putIfAbsent для установки ключа. Если указанный ключ еще не связан со значением (или сопоставлен со значением NULL), этот метод связывает его с данным значением и возвращает значение NULL, иначе возвращается текущее значение.

В случае если карта является общей для всех потоков, мы можем использовать ConcurrentHashMapи AtomicInteger . Из документа:

An AtomicIntegerявляется значением int, которое может быть обновлено атомарно. AtomicInteger используется в приложениях, таких как счетчики с атомным приращением, и не может использоваться в качестве замены для Integer. Тем не менее, этот класс расширяет Number, чтобы обеспечить единообразный доступ инструментам и утилитам, которые работают с классами на основе чисел.

Мы можем использовать их как показано:

final Map<String,AtomicInteger> map2 = new ConcurrentHashMap<>();
map2.putIfAbsent("A",new AtomicInteger(0));
map2.putIfAbsent("B",new AtomicInteger(0)); //[A=0, B=0]
map2.get("B").incrementAndGet();    //[A=0, B=1]

Следует обратить внимание на то, что мы вызываем getзначение ключа Bи затем вызываем incrementAndGet()его значение, которое, конечно же, является ключом AtomicInteger. Мы можем оптимизировать его, так как метод putIfAbsentвозвращает значение ключа, если оно уже присутствует:

map2.putIfAbsent("B",new AtomicInteger(0)).incrementAndGet();//[A=0, B=2]

Кроме того, если мы планируем использовать AtomicLong, то в соответствии с документацией в условиях высокой конкуренции ожидаемая пропускная способность LongAdder значительно выше за счет более высокого потребления пространства. Также проверьте этот вопрос .

Более чистое решение без NullPointerException:

map.replace(key, map.get(key) + 1);

Поскольку я не могу комментировать несколько ответов из-за меньшей репутации, я опубликую решение, которое я применил.

for(String key : someArray)
{
   if(hashMap.containsKey(key)//will check if a particular key exist or not 
   {
      hashMap.put(hashMap.get(key),value+1);// increment the value by 1 to an already existing key
   }
   else
   {
      hashMap.put(key,value);// make a new entry into the hashmap
   }
}

Используйте forцикл для увеличения индекса:

for (int i =0; i<5; i++){
    HashMap<String, Integer> map = new HashMap<String, Integer>();
    map.put("beer", 100);

    int beer = map.get("beer")+i;
    System.out.println("beer " + beer);
    System.out ....

}

Здесь есть вводящие в заблуждение ответы на этот вопрос, которые подразумевают, что метод put Hashtable заменит существующее значение, если ключ существует, это не верно для Hashtable, а скорее для HashMap. См. Javadoc для HashMap http://docs.oracle.com/javase/7/docs/api/java/util/HashMap.html#put%28K,%20V%29

Integer i = map.get(key);
if(i == null)
   i = (aValue)
map.put(key, i + 1);

или

Integer i = map.get(key);
map.put(key, i == null ? newValue : i + 1);

Целочисленные значения - это примитивные типы данных http://cs.fit.edu/~ryan/java/language/java-data.html , поэтому вам нужно вынуть их, выполнить некоторый процесс, а затем вернуть его обратно. если у вас есть значение, которое не является типом данных Primitive, вам нужно только извлечь его, обработать, не нужно возвращать его обратно в хэш-карту.

Пытаться:

HashMap hm=new HashMap<String ,Double >();

НОТА:

String->give the new value; //THIS IS THE KEY
else
Double->pass new value; //THIS IS THE VALUE

Вы можете изменить либо ключ, либо значение в вашей хэш-карте, но вы не можете изменить оба одновременно.

Используйте Java8 встроенную функцию 'computeIfPresent'

Пример:

public class ExampleToUpdateMapValue {

    public static void main(String[] args) {
        Map<String,String> bookAuthors = new TreeMap<>();
        bookAuthors.put("Genesis","Moses");
        bookAuthors.put("Joshua","Joshua");
        bookAuthors.put("Judges","Samuel");

        System.out.println("---------------------Before----------------------");
        bookAuthors.entrySet().stream().forEach(System.out::println);
        // To update the existing value using Java 8
        bookAuthors.computeIfPresent("Judges", (k,v) -> v = "Samuel/Nathan/Gad");

        System.out.println("---------------------After----------------------");
        bookAuthors.entrySet().stream().forEach(System.out::println);
    }
}