Circumventing the null check while populating a HashMap

user_8477461 0
Viewed 523

While inserting into a hashmap, do I always have to check if there is a null value corresponding to the key being inserted?

For instance, if I want to keep track of the number of times a character occurs in a word, using a hashmap, do i always have to do:

if(hashMap.containsKey(ch)){
    hashMap.replace(ch, 1+hashMap.get(ch));    
}
else{
    hashMap.put(ch, 1);    
}

Or is there a function that can handle this for me?

hashmap java
3 Answers

Use merge.

hashMap.merge(ch, 1, (left, right) -> left + right);

or using a method reference:

 hashMap.merge(ch, 1, Math::addExact);
  • If the specified key (ch in this case) is not already associated with a value or is associated with null, associates it with the given non-null value (1 in this case).
  • if the specified key is associated with a non-null value it then replaces the associated value with the results of the given remapping function (left, right) -> left + right.
user_58620710

You don't have to. Map has a merge method which you can use to update a value:

hashMap.merge(ch, 1, (oldVal, newVal) -> oldVal + newVal);

What that does:

  • If hashMap doesn't already have a ch key, then a new entry is added with ch as key and 1 as value
  • If hashMap already has an entry with ch as key, then the last function is called to compute the update value. In this case, (oldVal, newVal) -> oldVal + newVal simply adds the old value to the new one.

As pointed out in Andy's comment, you can also use Map.compute:

int newValue = hashMap.compute(ch, 
      (key, existingVal) -> (existingVal == null) ? 1 : existingVal + 1);
user_57615580

Just to be clear, you do not have to distinguish between whether the key exists in the map already or not. In other words, instead of using replace in your example, you could use put.

Of course, you do need to deal with whether or not you have a prior value that you need to include in the updated value. As others have noted, you can use the merge or compute methods.

However, if you have reasons to prefer to stick with put here are a couple of ideas for how to structure the code.

In your original code,

if(hashMap.containsKey(ch)){
    hashMap.replace(ch, 1+hashMap.get(ch));    
}
else{
    hashMap.put(ch, 1);    
}

you call containsKey and get, both of which essentially do a lookup. Why do the lookup twice?

Integer count = hashMap.get(ch);
if(count != null){
    hashMap.replace(ch, 1+count);    
}
else{
    hashMap.put(ch, 1);    
}

Instead of using replace for one case and put for the other, you can just as easily use put for both. And you can combine the cases:

Integer count = hashMap.get(ch);
if (count == null) {
    count = 0;
}
hashMap.put(ch, count + 1);

I find this pattern to be very useful and it comes up a lot (at least in the applications that I work on). Here is the way I think about this:

// Get the current value.
Integer count = hashMap.get(ch);
if (count == null) {
    // Business logic for initial value.
    count = 0;
}

// Compute the new value (might be a bunch of business logic).
count++;

// Put the new value back.
hashMap.put(ch, count);
user_19558710
Related