How to update a value, given a key in a java hashmap?

laertis Source

Suppose we have a HashMap<String, Integer> in Java.

How do I update (increment) the integer-value of the string-key for each existence of the string I find?

One could remove and reenter the pair, but overhead would be a concern.
Another way would be to just put the new pair and the old one would be replaced.

In the latter case, what happens if there is a hashcode collision with a new key I am trying to insert? The correct behavior for a hashtable would be to assign a different place for it, or make a list out of it in the current bucket.



answered 7 years ago BalusC #1

Replace Integer by AtomicInteger and call one of the incrementAndGet/getAndIncrement methods on it.

An alternative is to wrap an int in your own MutableInteger class which has an increment() method, you only have a threadsafety concern to solve yet.

answered 7 years ago Matthew Flaschen #2

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

should be fine. It will update the value for the existing mapping. Note that this uses auto-boxing.

answered 7 years ago Peter Lawrey #3

@Matthew's solution is the simplest and will perform well enough in most cases.

If you need high performance, AtomicInteger is a better solution ala @BalusC.

However, a faster solution (provided thread safety is not an issue) is to use TObjectIntHashMap which provides a increment(key) method and uses primitives and less objects than creating AtomicIntegers. e.g.

TObjectIntHashMap<String> map = new TObjectIntHashMap<String>()

answered 6 years ago oracleruiz #4

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

The method put will replace the value of an existing key and will create it if doesn't exist.

answered 6 years ago VanHoutte #5

Use a for loop to increment the index:

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 ....


answered 6 years ago NARAYANAN.M #6


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


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

You can change either the key or the value in your hashmap, but you can't change both at the same time.

answered 5 years ago isuru #7

You can increment like below but you need to check for existence so that a NullPointerException is not thrown

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

answered 4 years ago sudoBen #8

Does the hash exist (with 0 as the value) or is it "put" to the map on the first increment? If it is "put" on the first increment, the code should look like:

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

answered 4 years ago user1048218 #9

There are misleading answers to this question here that imply Hashtable put method will replace the existing value if the key exists, this is not true for Hashtable but rather for HashMap. See Javadoc for HashMap,%20V%29

answered 4 years ago damluar #10

Java 8 way:

You can use computeIfPresent method and supply it a mapping function, which will be called to compute a new value based on existing one.

For example,

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

Alternatevely, you could use merge method, where 1 is the default value and function increments existing value by 1:

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

In addition, there is a bunch of other useful methods, such as putIfAbsent, getOrDefault, forEach, etc.

answered 2 years ago i_am_zero #11

It may be little late but here are my two cents.

If you are using Java 8 then you can make use of computeIfPresent method. If the value for the specified key is present and non-null then it attempts to compute a new mapping given the key and its current mapped value.

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

We can also make use of another method putIfAbsent to put a key. If the specified key is not already associated with a value (or is mapped to null) then this method associates it with the given value and returns null, else returns the current value.

In case the map is shared across threads then we can make use of ConcurrentHashMap and AtomicInteger. From the doc:

An AtomicInteger is an int value that may be updated atomically. An AtomicInteger is used in applications such as atomically incremented counters, and cannot be used as a replacement for an Integer. However, this class does extend Number to allow uniform access by tools and utilities that deal with numerically-based classes.

We can use them as shown:

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]

One point to observe is we are invoking get to get the value for key B and then invoking incrementAndGet() on its value which is of course AtomicInteger. We can optimize it as the method putIfAbsent returns the value for the key if already present:

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

On a side note if we plan to use AtomicLong then as per documentation under high contention expected throughput of LongAdder is significantly higher, at the expense of higher space consumption. Also check this question.

answered 2 years ago Christopher Bull #12

The simplified Java 8 way:

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

This uses the method of HashMap that retrieves the value for a key, but if the key can't be retrieved it returns the specified default value (in this case a '0').

This is supported within core Java: HashMap<K,V> getOrDefault(Object key, V defaultValue)

answered 1 year ago Punktum #13

One line solution:

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

answered 8 months ago Kreedz Zhen #14

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

Integer is Primitive data types, so you need to take it out, make some process, then put it back. if you have a value which is not Primitive data types, you only need to take it out, process it, no need to put it back into the hashmap.

answered 5 months ago aayush nigam #15

Since I can't comment to a few answers due to less reputation, I will post a solution which I applied.

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
      hashMap.put(key,value);// make a new entry into the hashmap

answered 2 months ago Sergey Dirin #16

The cleaner solution without NullPointerException is:

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

comments powered by Disqus