Java HashMap performing put() and get() in same line

I am using a HashMap<String, Integer> to keep track of count of an occurrence of a specific string. I am performing this operation in a single-thread manner in the following way:

   HashMap<String, Integer> count = new HashMap<>();
   // List<String≥ words = ...;
   for (String word : words) {
      if (!count.containsKey(word)) {
          count.put(word, 0);
      }
      count.put(word, count.get(word) + 1);
   }

Is it possible, for the same word, the count increases by more than 1 because I am performing a put and get on the same key at the same time? i.e. Let's say the word = "hello". Initially, count.get(word) => 1. When I perform count.put(word, count.get(word) + 1), if I do count.get(word), instead of getting 2, I get 3.

Map has methods compute and merge that would allow to implement shorter updates of the values for the keys:

1. compute

for (String word : words) {
    count.compute(word, (w, prev) -> prev == null ? 1 : prev + 1);
}

2. merge

for (String word : words) {
    count.merge(word, 1, (prev, one) -> prev + one);
}

Lambda expression (prev, one) -> prev + one is actually a function of two int arguments returning their sum, therefore it may be replaced with a method reference Integer::sum:

for (String word : words) {
    count.merge(word, 1, Integer::sum);
}

To answer your questions directly: no it is not possible for the statement count.put(word, count.get(word) + 1) to increment the value by more than 1. Although the two method calls are in the same statement they are performed sequentially: the get is performed first to find the second argument to pass to the put.

You can combine your missing key test and initialisation into a single statement:

count.putIfAbsent(word, 0);

This conveniently returns the value afterwards, allowing:

count.put(word, 1 + count.putIfAbsent(word, 0));

However there is also a method that already combines those two operations:

count.merge(word, 1, Integer::sum);

It absolutely safe to do it in a single thread.
No, it's not possible that "count increases by more than 1 because I am performing a put and get on the same key at the same time" because two operations never can happen at the same time with single-threaded execution.

Code count.put(word, count.get(word) + 1); will execute commands in following order:

Integer value1 = count.get(word);
int value2 = value1.intValue();
int value3 = value2 + 1;
Integer value4 = new Integer(value3);
count.put(word, value4);

By the way, your code will produce quite a lot of garbage and will be not very effective.

This way is more effective:

private static class CounterHolder{
    int value;
}

Map<String, CounterHolder> count = new HashMap<>();
List<String> words = ...
for (String word : words) {
    CounterHolder holder;
    if (count.containsKey(word)) {
        holder = new CounterHolder();
    } else {
        holder = new CounterHolder();
        count.put(word, holder);
    }
    ++holder.value;
}