Incrementing Integers in Map

Question

I have a HashMap<Token, Integer>, which counts occurrences of Token. Each time Token is found, the value in the map should be incremented.

Map<Token, Integer> occurrences = new HashMap<Token, Integer>();
// ...

public void tokenFound(Token token) {

    Integer numberOfOccurs = occurrences.get(token);
    Integer newNumberOfOccurs = new Integer((numberOfOccurs == null) ? 1 : numberOfOccurs.intValue() + 1);
    occurrences.put(token, newNumberOfOccurs);
}

Is there a more elegant way to do this?

Answer 1

You have several different options for this:

Guava

Google's Guava Library introduces the idea of a Multiset which is capable of counting the occurrences, and also provides a couple of other features.

Java 8

If you are using Java 8 (which I highly recommend if you have the ability to do so), your tokenFound method can simply be this:

occurrences.merge(token, 1, (oldValue, one) -> oldValue + one);

Or this:

occurrences.compute(token, (tokenKey, oldValue) -> oldValue == null ? 1 : oldValue + 1);

Note that as of Java 7, you can initialize the map with the "diamond operator":

Map<Token, Integer> occurrences = new HashMap<>();

Without Java 8, no libraries

If you are unable to use Java 8 and don't want to add Guava as a third party library to your project, there are a small part you can do to simplify your existing code:

Integer previousValue = occurrences.get(token);
occurrences.put(token, previousValue == null ? 1 : previousValue + 1);

More specifically:

• Using the new Integer constructor is not necessary, Java automatically uses boxing to do this. For Integer values close to zero, this will actually save you a little bit because Java keeps some integers cached.
• You don't need the newNumberOfOccurs variable as it's only used once.

Answer 2

Guava's Multiset and its AtomicLongMap are designed for this kind of counting.

See also:

• Guava's new collection types, explained.
• Effective Java, 2nd edition, Item 47: Know and use the libraries (The author mentions only the JDK's built-in libraries but I think the reasoning could be true for other libraries too.)

Answer 3

I feel the non library answers can be improved, so here's my take at those.

For java 7 :

private final Map<Token, AtomicInteger> occurrences = new HashMap<>();

public void tokenFound(Token token) {
    if (!occurrences.containsKey(token)) {
        occurrences.put(token, new AtomicInteger(1));
        return;
    }
    occurrences.get(token).incrementAndGet();
}

You use AtomicInteger as value type, allowing an easy incrementAndGet(), instead of having to overwrite the bucket in the Map.

For Java 8 :

private final Map<Token, LongAdder> occurrences = new HashMap<>();

public void tokenFound(Token token) {
    occurrences.computeIfAbsent(token, (t) -> new LongAdder()).increment();
}

LongAdder is a type specifically made for tallying (especially under heavy concurrency). The added computeIfAbsent() method on Map and the addition of lambdas turn this whole thing into a one-liner.

If you're using java 7, I'd opt for Guava, but if you're on 8 simply use the java.util classes.

Answer 4

Instead of using a Map<Token, Integer>, use Map<Token, int[]>.

This can be used to avoid calling put() whenever you want to modify an existing value.

HashMap<String, int[]> m=new HashMap<>();
m.put("a", new int[]{0});
m.get("a")[0]++;
System.out.println("m="+m.get("a")[0]);

Outputs:

m=1

Answer 5

If you are using Java 8:

Although the merge and compute methods in Map work for this purpose, the Map.getOrDefault(Object key, V defaultValue) show the intention of the code more clearly to me.

Map<Token, Integer> occurrences = new HashMap<Token, Integer>();

// for each token:
occurrences.put(token, occurrences.getOrDefault(token, 0) + 1);