Most efficient way to increment a Map value in Java

Question

I hope this question is not considered too basic for this forum  but we ll see  I m wondering how to refactor some code for better performance that is getting run a bunch of times   Say I m creating a word frequency list  using a Map  probably a HashMap   where each key is a String with the word that s being counted and the value is an Integer that s incremented each time a token of the word is found   In Perl  incrementing such a value would be trivially easy    map  word       But in Java  it s much more complicated  Here the way I m currently doing it   int count   map containsKey word    map get word    0  map put word  count   1     Which of course relies on the autoboxing feature in the newer Java versions  I wonder if you can suggest a more efficient way of incrementing such a value  Are there even good performance reasons for eschewing the Collections framework and using a something else instead   Update  I ve done a test of several of the answers  See below

User · Answer

Quite simple  just use the built-in function in Map java as followed  map put key  map getOrDefault key  0    1

User · Answer

It s always a good idea to look at the Google Collections Library for this kind of thing  In this case a Multiset will do the trick   Multiset bag   Multisets newHashMultiset    String word    foo   bag add word   bag add word   System out println bag count word       Prints 2   There are Map-like methods for iterating over keys entries  etc  Internally the implementation currently uses a HashMap lt E  AtomicInteger gt   so you will not incur boxing costs

User · Answer

Memory rotation may be an issue here  since every boxing of an int larger than or equal to 128 causes an object allocation  see Integer valueOf int    Although the garbage collector very efficiently deals with short-lived objects  performance will suffer to some degree   If you know that the number of increments made will largely outnumber the number of keys   words in this case   consider using an int holder instead  Phax already presented code for this  Here it is again  with two changes  holder class made static and initial value set to 1    static class MutableInt     int value   1    void inc       value      int get     return value          Map lt String MutableInt gt  map   new HashMap lt String MutableInt gt     MutableInt value   map get key   if  value    null      value   new MutableInt      map put key  value     else     value inc        If you need extreme performance  look for a Map implementation which is directly tailored towards primitive value types  jrudolph mentioned GNU Trove   By the way  a good search term for this subject is  histogram

User · Answer

put  need  get   to ensure no duplicate key   So directly do a  put   and if there was a previous value  then do an addition   Map map   new HashMap      MutableInt newValue   new MutableInt  1      default   inc MutableInt oldValue   map put  key  newValue   if  oldValue    null      newValue add oldValue      old   inc     If count starts at 0  then add 1   or any others values      Map map   new HashMap      MutableInt newValue   new MutableInt  0      default MutableInt oldValue   map put  key  newValue   if  oldValue    null      newValue setValue oldValue   1      old   inc     Notice   This code is not thread safe  Use it to build then use the map  not to concurrently update it    Optimization   In a loop  keep old value to become the new value of next loop   Map map   new HashMap     final int defaut   0  final int inc   1   MutableInt oldValue   new MutableInt  default   while true      MutableInt newValue   oldValue     oldValue   map put  key  newValue      insert or      if  oldValue    null        newValue setValue oldValue   inc         update      oldValue setValue default      reuse     else     oldValue   new MutableInt  default      renew

User · Answer

It s always a good idea to look at the Google Collections Library for this kind of thing  In this case a Multiset will do the trick   Multiset bag   Multisets newHashMultiset    String word    foo   bag add word   bag add word   System out println bag count word       Prints 2   There are Map-like methods for iterating over keys entries  etc  Internally the implementation currently uses a HashMap lt E  AtomicInteger gt   so you will not incur boxing costs

User · Answer

I don t know how efficient it is but the below code works as well You need to define a BiFunction at the beginning  Plus  you can make more than just increment with this method   public static Map lt String  Integer gt  strInt   new HashMap lt String  Integer gt      public static void main String   args        BiFunction lt Integer  Integer  Integer gt  bi    x y  - gt            if x    null              return y          return x y             strInt put  abc   0         strInt merge  abc   1  bi       strInt merge  abc   1  bi       strInt merge  abc   1  bi       strInt merge  abcd   1  bi        System out println strInt get  abc         System out println strInt get  abcd         output is  3 1

User · Answer

Map lt String  Integer gt  map   new HashMap lt  gt     String key    a random key   int count   map getOrDefault key  0      ensure count will be one of 0 1 2 3     map put key  count   1     And that s how you increment a value with simple code   Benefit    No need to add a new class or use another concept of mutable int Not relying on any library Easy to understand what s going on exactly  Not too much abstraction    Downside    The hash map will be searched twice for get   and put    So it will not be the most performant code     Theoretically  once you call get    you already know where to put    so you should not have to search again  But searching in hash map usually takes a very minimal time that you can kind of ignore this performance issue   But if you are very serious about the issue  you are a perfectionist  another way is to use merge method  this is  probably  more efficient than the previous code snippet as you will be  theoretically  searching the map only once   though this code is not obvious from first sight  it s short and performant   map merge key  1   a b  - gt  a b     Suggestion  you should care about code readability more than little performance gain in most of the time  If the first code snippet is easier for you to understand then use it  But if you are able to understand the 2nd one fine then you can also go for it

User · Answer

Are you sure that this is a bottleneck  Have you done any performance analysis   Try using the NetBeans profiler  its free and built into NB 6 1  to look at hotspots   Finally  a JVM upgrade  say from 1 5- 1 6  is often a cheap performance booster  Even an upgrade in build number can provide good performance boosts  If you are running on Windows and this is a server class application  use -server on the command line to use the Server Hotspot JVM  On Linux and Solaris machines this is autodetected

User · Answer

Google Guava is your friend        at least in some cases  They have this nice AtomicLongMap  Especially nice because you are dealing with long as value in your map   E g     AtomicLongMap lt String gt  map   AtomicLongMap create          map getAndIncrement word     Also possible to add more then 1 to the value   map getAndAdd word  112L

User · Answer

A little research in 2016  https   github com leventov java-word-count  benchmark source code  Best results per method  smaller is better                     time  ms kolobokeCompile  18 8 koloboke         19 8 trove            20 8 fastutil         22 7 mutableInt       24 3 atomicInteger    25 3 eclipse          26 9 hashMap          28 0 hppc             33 6 hppcRt           36 5   Time space results

User · Answer

A variation on the MutableInt approach that might be even faster  if a bit of a hack  is to use a single-element int array    Map lt String int   gt  map   new HashMap lt String int   gt         int   value   map get key   if  value    null     map put key  new int   1     else     value 0     It would be interesting if you could rerun your performance tests with this variation   It might be the fastest     Edit  The above pattern worked fine for me  but eventually I changed to use Trove s collections to reduce memory size in some very large maps I was creating -- and as a bonus it was also faster   One really nice feature is that the TObjectIntHashMap class has a single adjustOrPutValue call that  depending on whether there is already a value at that key  will either put an initial value or increment the existing value   This is perfect for incrementing   TObjectIntHashMap lt String gt  map   new TObjectIntHashMap lt String gt         map adjustOrPutValue key  1  1

User · Answer

Google Collections HashMultiset    - quite elegant to use  - but consume CPU and memory  Best would be to have a method like   Entry lt K V gt  getOrPut K     elegant  and low cost   Such a method will compute hash and index only once  and then we could do what we want with the entry  either replace or update the value    More elegant   - take a HashSet lt Entry gt   - extend it so that get K  put a new Entry if needed  - Entry could be your own object  --   new MyHashSet    get k  increment

User · Answer

Some test results  I ve gotten a lot of good answers to this question--thanks folks--so I decided to run some tests and figure out which method is actually fastest  The five methods I tested are these    the  ContainsKey  method that I presented in the question the  TestForNull  method suggested by Aleksandar Dimitrov the  AtomicLong  method suggested by Hank Gay the  Trove  method suggested by jrudolph the  MutableInt  method suggested by phax myopenid com   Method  Here s what I did      created five classes that were identical except for the differences shown below  Each class had to perform an operation typical of the scenario I presented  opening a 10MB file and reading it in  then performing a frequency count of all the word tokens in the file  Since this took an average of only 3 seconds  I had it perform the frequency count  not the I O  10 times  timed the loop of 10 iterations but not the I O operation and recorded the total time taken  in clock seconds  essentially using Ian Darwin s method in the Java Cookbook  performed all five tests in series  and then did this another three times  averaged the four results for each method    Results  I ll present the results first and the code below for those who are interested   The ContainsKey method was  as expected  the slowest  so I ll give the speed of each method in comparison to the speed of that method    ContainsKey  30 654 seconds  baseline  AtomicLong  29 780 seconds  1 03 times as fast  TestForNull  28 804 seconds  1 06 times as fast  Trove  26 313 seconds  1 16 times as fast  MutableInt  25 747 seconds  1 19 times as fast    Conclusions  It would appear that only the MutableInt method and the Trove method are significantly faster  in that only they give a performance boost of more than 10   However  if threading is an issue  AtomicLong might be more attractive than the others  I m not really sure   I also ran TestForNull with final variables  but the difference was negligible   Note that I haven t profiled memory usage in the different scenarios  I d be happy to hear from anybody who has good insights into how the MutableInt and Trove methods would be likely to affect memory usage   Personally  I find the MutableInt method the most attractive  since it doesn t require loading any third-party classes  So unless I discover problems with it  that s the way I m most likely to go   The code  Here is the crucial code from each method   ContainsKey  import java util HashMap  import java util Map      Map lt String  Integer gt  freq   new HashMap lt String  Integer gt         int count   freq containsKey word    freq get word    0  freq put word  count   1     TestForNull  import java util HashMap  import java util Map      Map lt String  Integer gt  freq   new HashMap lt String  Integer gt         Integer count   freq get word   if  count    null        freq put word  1     else       freq put word  count   1       AtomicLong  import java util concurrent ConcurrentHashMap  import java util concurrent ConcurrentMap  import java util concurrent atomic AtomicLong      final ConcurrentMap lt String  AtomicLong gt  map        new ConcurrentHashMap lt String  AtomicLong gt         map putIfAbsent word  new AtomicLong 0    map get word  incrementAndGet      Trove  import gnu trove TObjectIntHashMap      TObjectIntHashMap lt String gt  freq   new TObjectIntHashMap lt String gt         freq adjustOrPutValue word  1  1     MutableInt  import java util HashMap  import java util Map      class MutableInt     int value   1     note that we start at 1 since we re counting   public void increment        value           public int  get            return value          Map lt String  MutableInt gt  freq   new HashMap lt String  MutableInt gt         MutableInt count   freq get word   if  count    null        freq put word  new MutableInt       else       count increment

User · Answer

Are you sure that this is a bottleneck  Have you done any performance analysis   Try using the NetBeans profiler  its free and built into NB 6 1  to look at hotspots   Finally  a JVM upgrade  say from 1 5- 1 6  is often a cheap performance booster  Even an upgrade in build number can provide good performance boosts  If you are running on Windows and this is a server class application  use -server on the command line to use the Server Hotspot JVM  On Linux and Solaris machines this is autodetected

User · Answer

There are a couple of approaches    Use a Bag alorithm like the sets contained in Google Collections  Create mutable container which you can use in the Map          class My          String word          int count           And use put  word   new My  Word      Then you can check if it exists and increment when adding   Avoid rolling your own solution using lists  because if you get innerloop searching and sorting  your performance will stink  The first HashMap solution is actually quite fast  but a proper like that found in Google Collections is probably better   Counting words using Google Collections  looks something like this          HashMultiset s   new HashMultiset        s add  word        s add  word        System out println    s count  word          Using the HashMultiset is quite elegent  because a bag-algorithm is just what you need when counting words

User · Answer

Another way would be creating a mutable integer   class MutableInt     int value   0    public void inc        value      public int get      return value          Map lt String MutableInt gt  map   new HashMap lt String MutableInt gt      MutableInt value   map get  key   if  value    null      value   new MutableInt       map put  key  value     else     value inc         of course this implies creating an additional object but the overhead in comparison to creating an Integer  even with Integer valueOf  should not be so much

User · Answer

The simple and easy way in java 8 is the following   final ConcurrentMap lt String  AtomicLong gt  map   new ConcurrentHashMap lt String  AtomicLong gt         map computeIfAbsent  foo   key - gt  new AtomicLong 0   incrementAndGet

User · Answer

You should be aware of the fact that your original attempt   int count   map containsKey word    map get word    0   contains two potentially expensive operations on a map  namely containsKey and get  The former performs an operation potentially pretty similar to the latter  so you re doing the same work twice   If you look at the API for Map  get operations usually return null when the map does not contain the requested element   Note that this will make a solution like  map put  key  map get key    1     dangerous  since it might yield NullPointerExceptions  You should check for a null first   Also note  and this is very important  that HashMaps can contain nulls by definition  So not every returned null says  there is no such element   In this respect  containsKey behaves differently from get in actually telling you whether there is such an element  Refer to the API for details   For your case  however  you might not want to distinguish between a stored null and  noSuchElement   If you don t want to permit nulls you might prefer a Hashtable  Using a wrapper library as was already proposed in other answers might be a better solution to manual treatment  depending on the complexity of your application   To complete the answer  and I forgot to put that in at first  thanks to the edit function    the best way of doing it natively  is to get into a final variable  check for null and put it back in with a 1  The variable should be final because it s immutable anyway  The compiler might not need this hint  but its clearer that way    final HashMap map   generateRandomHashMap    final Object key   fetchSomeKey    final Integer i   map get key   if  i    null        map put i   1     else          do something     If you do not want to rely on autoboxing  you should say something like map put new Integer 1   i getValue      instead

User · Answer

Memory rotation may be an issue here  since every boxing of an int larger than or equal to 128 causes an object allocation  see Integer valueOf int    Although the garbage collector very efficiently deals with short-lived objects  performance will suffer to some degree   If you know that the number of increments made will largely outnumber the number of keys   words in this case   consider using an int holder instead  Phax already presented code for this  Here it is again  with two changes  holder class made static and initial value set to 1    static class MutableInt     int value   1    void inc       value      int get     return value          Map lt String MutableInt gt  map   new HashMap lt String MutableInt gt     MutableInt value   map get key   if  value    null      value   new MutableInt      map put key  value     else     value inc        If you need extreme performance  look for a Map implementation which is directly tailored towards primitive value types  jrudolph mentioned GNU Trove   By the way  a good search term for this subject is  histogram

User · Answer

Now there is a shorter way with Java 8 using Map  merge    myMap merge key  1  Integer  sum    What it does    if key do not exists  put 1 as value otherwise sum 1 to the value linked to key   More information here

User · Answer

A little research in 2016  https   github com leventov java-word-count  benchmark source code  Best results per method  smaller is better                     time  ms kolobokeCompile  18 8 koloboke         19 8 trove            20 8 fastutil         22 7 mutableInt       24 3 atomicInteger    25 3 eclipse          26 9 hashMap          28 0 hppc             33 6 hppcRt           36 5   Time space results

User · Answer

Instead of calling containsKey   it is faster just to call map get and check if the returned value is null or not       Integer count   map get word       if count    null           count   0            map put word  count   1

User · Answer

It s always a good idea to look at the Google Collections Library for this kind of thing  In this case a Multiset will do the trick   Multiset bag   Multisets newHashMultiset    String word    foo   bag add word   bag add word   System out println bag count word       Prints 2   There are Map-like methods for iterating over keys entries  etc  Internally the implementation currently uses a HashMap lt E  AtomicInteger gt   so you will not incur boxing costs

User · Answer

There are a couple of approaches    Use a Bag alorithm like the sets contained in Google Collections  Create mutable container which you can use in the Map          class My          String word          int count           And use put  word   new My  Word      Then you can check if it exists and increment when adding   Avoid rolling your own solution using lists  because if you get innerloop searching and sorting  your performance will stink  The first HashMap solution is actually quite fast  but a proper like that found in Google Collections is probably better   Counting words using Google Collections  looks something like this          HashMultiset s   new HashMultiset        s add  word        s add  word        System out println    s count  word          Using the HashMultiset is quite elegent  because a bag-algorithm is just what you need when counting words

User · Answer

Memory rotation may be an issue here  since every boxing of an int larger than or equal to 128 causes an object allocation  see Integer valueOf int    Although the garbage collector very efficiently deals with short-lived objects  performance will suffer to some degree   If you know that the number of increments made will largely outnumber the number of keys   words in this case   consider using an int holder instead  Phax already presented code for this  Here it is again  with two changes  holder class made static and initial value set to 1    static class MutableInt     int value   1    void inc       value      int get     return value          Map lt String MutableInt gt  map   new HashMap lt String MutableInt gt     MutableInt value   map get key   if  value    null      value   new MutableInt      map put key  value     else     value inc        If you need extreme performance  look for a Map implementation which is directly tailored towards primitive value types  jrudolph mentioned GNU Trove   By the way  a good search term for this subject is  histogram

User · Answer

A variation on the MutableInt approach that might be even faster  if a bit of a hack  is to use a single-element int array    Map lt String int   gt  map   new HashMap lt String int   gt         int   value   map get key   if  value    null     map put key  new int   1     else     value 0     It would be interesting if you could rerun your performance tests with this variation   It might be the fastest     Edit  The above pattern worked fine for me  but eventually I changed to use Trove s collections to reduce memory size in some very large maps I was creating -- and as a bonus it was also faster   One really nice feature is that the TObjectIntHashMap class has a single adjustOrPutValue call that  depending on whether there is already a value at that key  will either put an initial value or increment the existing value   This is perfect for incrementing   TObjectIntHashMap lt String gt  map   new TObjectIntHashMap lt String gt         map adjustOrPutValue key  1  1

User · Answer

It s always a good idea to look at the Google Collections Library for this kind of thing  In this case a Multiset will do the trick   Multiset bag   Multisets newHashMultiset    String word    foo   bag add word   bag add word   System out println bag count word       Prints 2   There are Map-like methods for iterating over keys entries  etc  Internally the implementation currently uses a HashMap lt E  AtomicInteger gt   so you will not incur boxing costs

User · Answer

The simple and easy way in java 8 is the following   final ConcurrentMap lt String  AtomicLong gt  map   new ConcurrentHashMap lt String  AtomicLong gt         map computeIfAbsent  foo   key - gt  new AtomicLong 0   incrementAndGet

User · Answer

As a follow-up to my own comment  Trove looks like the way to go  If  for whatever reason  you wanted to stick with the standard JDK  ConcurrentMap and AtomicLong can make the code a tiny bit nicer  though YMMV      final ConcurrentMap lt String  AtomicLong gt  map   new ConcurrentHashMap lt String  AtomicLong gt         map putIfAbsent  quot foo quot   new AtomicLong 0        map get  quot foo quot   incrementAndGet     will leave 1 as the value in the map for foo  Realistically  increased friendliness to threading is all that this approach has to recommend it

User · Answer

You should be aware of the fact that your original attempt   int count   map containsKey word    map get word    0   contains two potentially expensive operations on a map  namely containsKey and get  The former performs an operation potentially pretty similar to the latter  so you re doing the same work twice   If you look at the API for Map  get operations usually return null when the map does not contain the requested element   Note that this will make a solution like  map put  key  map get key    1     dangerous  since it might yield NullPointerExceptions  You should check for a null first   Also note  and this is very important  that HashMaps can contain nulls by definition  So not every returned null says  there is no such element   In this respect  containsKey behaves differently from get in actually telling you whether there is such an element  Refer to the API for details   For your case  however  you might not want to distinguish between a stored null and  noSuchElement   If you don t want to permit nulls you might prefer a Hashtable  Using a wrapper library as was already proposed in other answers might be a better solution to manual treatment  depending on the complexity of your application   To complete the answer  and I forgot to put that in at first  thanks to the edit function    the best way of doing it natively  is to get into a final variable  check for null and put it back in with a 1  The variable should be final because it s immutable anyway  The compiler might not need this hint  but its clearer that way    final HashMap map   generateRandomHashMap    final Object key   fetchSomeKey    final Integer i   map get key   if  i    null        map put i   1     else          do something     If you do not want to rely on autoboxing  you should say something like map put new Integer 1   i getValue      instead

User · Answer

I don t know how efficient it is but the below code works as well You need to define a BiFunction at the beginning  Plus  you can make more than just increment with this method   public static Map lt String  Integer gt  strInt   new HashMap lt String  Integer gt      public static void main String   args        BiFunction lt Integer  Integer  Integer gt  bi    x y  - gt            if x    null              return y          return x y             strInt put  abc   0         strInt merge  abc   1  bi       strInt merge  abc   1  bi       strInt merge  abc   1  bi       strInt merge  abcd   1  bi        System out println strInt get  abc         System out println strInt get  abcd         output is  3 1

User · Answer

Since a lot of people search Java topics for Groovy answers  here s how you can do it in Groovy   dev map   new HashMap lt String  Integer gt    map put  key1   3   map merge  key1   1   a  b - gt  a   b  map merge  key2   1   a  b - gt  a   b

User · Answer

Are you sure that this is a bottleneck  Have you done any performance analysis   Try using the NetBeans profiler  its free and built into NB 6 1  to look at hotspots   Finally  a JVM upgrade  say from 1 5- 1 6  is often a cheap performance booster  Even an upgrade in build number can provide good performance boosts  If you are running on Windows and this is a server class application  use -server on the command line to use the Server Hotspot JVM  On Linux and Solaris machines this is autodetected

User · Answer

Vilmantas Baranauskas  Regarding this answer  I would comment if I had the rep points  but I don t   I wanted to note that the Counter class defined there is NOT thread-safe as it is not sufficient to just synchronize inc   without synchronizing value     Other threads calling value   are not guaranteed to see the the value unless a happens-before relationship has been established with the update

User · Answer

Map lt String  Integer gt  map   new HashMap lt  gt     String key    a random key   int count   map getOrDefault key  0      ensure count will be one of 0 1 2 3     map put key  count   1     And that s how you increment a value with simple code   Benefit    No need to add a new class or use another concept of mutable int Not relying on any library Easy to understand what s going on exactly  Not too much abstraction    Downside    The hash map will be searched twice for get   and put    So it will not be the most performant code     Theoretically  once you call get    you already know where to put    so you should not have to search again  But searching in hash map usually takes a very minimal time that you can kind of ignore this performance issue   But if you are very serious about the issue  you are a perfectionist  another way is to use merge method  this is  probably  more efficient than the previous code snippet as you will be  theoretically  searching the map only once   though this code is not obvious from first sight  it s short and performant   map merge key  1   a b  - gt  a b     Suggestion  you should care about code readability more than little performance gain in most of the time  If the first code snippet is easier for you to understand then use it  But if you are able to understand the 2nd one fine then you can also go for it

User · Answer

Google Guava is your friend        at least in some cases  They have this nice AtomicLongMap  Especially nice because you are dealing with long as value in your map   E g     AtomicLongMap lt String gt  map   AtomicLongMap create          map getAndIncrement word     Also possible to add more then 1 to the value   map getAndAdd word  112L

User · Answer

I think your solution would be the standard way  but - as you noted yourself - it is probably not the fastest way possible   You may look at GNU Trove  That is a library which contains all sorts of fast primitive Collections  Your example would use a TObjectIntHashMap which has a method adjustOrPutValue which does exactly what you want

User · Answer

Instead of calling containsKey   it is faster just to call map get and check if the returned value is null or not       Integer count   map get word       if count    null           count   0            map put word  count   1

User · Answer

You should be aware of the fact that your original attempt   int count   map containsKey word    map get word    0   contains two potentially expensive operations on a map  namely containsKey and get  The former performs an operation potentially pretty similar to the latter  so you re doing the same work twice   If you look at the API for Map  get operations usually return null when the map does not contain the requested element   Note that this will make a solution like  map put  key  map get key    1     dangerous  since it might yield NullPointerExceptions  You should check for a null first   Also note  and this is very important  that HashMaps can contain nulls by definition  So not every returned null says  there is no such element   In this respect  containsKey behaves differently from get in actually telling you whether there is such an element  Refer to the API for details   For your case  however  you might not want to distinguish between a stored null and  noSuchElement   If you don t want to permit nulls you might prefer a Hashtable  Using a wrapper library as was already proposed in other answers might be a better solution to manual treatment  depending on the complexity of your application   To complete the answer  and I forgot to put that in at first  thanks to the edit function    the best way of doing it natively  is to get into a final variable  check for null and put it back in with a 1  The variable should be final because it s immutable anyway  The compiler might not need this hint  but its clearer that way    final HashMap map   generateRandomHashMap    final Object key   fetchSomeKey    final Integer i   map get key   if  i    null        map put i   1     else          do something     If you do not want to rely on autoboxing  you should say something like map put new Integer 1   i getValue      instead

User · Answer

The various primitive wrappers  e g   Integer are immutable so there s really not a more concise way to do what you re asking unless you can do it with something like AtomicLong  I can give that a go in a minute and update  BTW  Hashtable is a part of the Collections Framework

User · Answer

Vilmantas Baranauskas  Regarding this answer  I would comment if I had the rep points  but I don t   I wanted to note that the Counter class defined there is NOT thread-safe as it is not sufficient to just synchronize inc   without synchronizing value     Other threads calling value   are not guaranteed to see the the value unless a happens-before relationship has been established with the update

User · Answer

You should be aware of the fact that your original attempt   int count   map containsKey word    map get word    0   contains two potentially expensive operations on a map  namely containsKey and get  The former performs an operation potentially pretty similar to the latter  so you re doing the same work twice   If you look at the API for Map  get operations usually return null when the map does not contain the requested element   Note that this will make a solution like  map put  key  map get key    1     dangerous  since it might yield NullPointerExceptions  You should check for a null first   Also note  and this is very important  that HashMaps can contain nulls by definition  So not every returned null says  there is no such element   In this respect  containsKey behaves differently from get in actually telling you whether there is such an element  Refer to the API for details   For your case  however  you might not want to distinguish between a stored null and  noSuchElement   If you don t want to permit nulls you might prefer a Hashtable  Using a wrapper library as was already proposed in other answers might be a better solution to manual treatment  depending on the complexity of your application   To complete the answer  and I forgot to put that in at first  thanks to the edit function    the best way of doing it natively  is to get into a final variable  check for null and put it back in with a 1  The variable should be final because it s immutable anyway  The compiler might not need this hint  but its clearer that way    final HashMap map   generateRandomHashMap    final Object key   fetchSomeKey    final Integer i   map get key   if  i    null        map put i   1     else          do something     If you do not want to rely on autoboxing  you should say something like map put new Integer 1   i getValue      instead

User · Answer

Memory rotation may be an issue here  since every boxing of an int larger than or equal to 128 causes an object allocation  see Integer valueOf int    Although the garbage collector very efficiently deals with short-lived objects  performance will suffer to some degree   If you know that the number of increments made will largely outnumber the number of keys   words in this case   consider using an int holder instead  Phax already presented code for this  Here it is again  with two changes  holder class made static and initial value set to 1    static class MutableInt     int value   1    void inc       value      int get     return value          Map lt String MutableInt gt  map   new HashMap lt String MutableInt gt     MutableInt value   map get key   if  value    null      value   new MutableInt      map put key  value     else     value inc        If you need extreme performance  look for a Map implementation which is directly tailored towards primitive value types  jrudolph mentioned GNU Trove   By the way  a good search term for this subject is  histogram

User · Answer

The various primitive wrappers  e g   Integer are immutable so there s really not a more concise way to do what you re asking unless you can do it with something like AtomicLong  I can give that a go in a minute and update  BTW  Hashtable is a part of the Collections Framework

User · Answer

I don t know how efficient it is but the below code works as well You need to define a BiFunction at the beginning  Plus  you can make more than just increment with this method   public static Map lt String  Integer gt  strInt   new HashMap lt String  Integer gt      public static void main String   args        BiFunction lt Integer  Integer  Integer gt  bi    x y  - gt            if x    null              return y          return x y             strInt put  abc   0         strInt merge  abc   1  bi       strInt merge  abc   1  bi       strInt merge  abc   1  bi       strInt merge  abcd   1  bi        System out println strInt get  abc         System out println strInt get  abcd         output is  3 1

User · Answer

There are a couple of approaches    Use a Bag alorithm like the sets contained in Google Collections  Create mutable container which you can use in the Map          class My          String word          int count           And use put  word   new My  Word      Then you can check if it exists and increment when adding   Avoid rolling your own solution using lists  because if you get innerloop searching and sorting  your performance will stink  The first HashMap solution is actually quite fast  but a proper like that found in Google Collections is probably better   Counting words using Google Collections  looks something like this          HashMultiset s   new HashMultiset        s add  word        s add  word        System out println    s count  word          Using the HashMultiset is quite elegent  because a bag-algorithm is just what you need when counting words

User · Answer

The various primitive wrappers  e g   Integer are immutable so there s really not a more concise way to do what you re asking unless you can do it with something like AtomicLong  I can give that a go in a minute and update  BTW  Hashtable is a part of the Collections Framework

User · Answer

The various primitive wrappers  e g   Integer are immutable so there s really not a more concise way to do what you re asking unless you can do it with something like AtomicLong  I can give that a go in a minute and update  BTW  Hashtable is a part of the Collections Framework

User · Answer

You can make use of computeIfAbsent method in Map interface provided in Java 8    final Map lt String AtomicLong gt  map   new ConcurrentHashMap lt  gt     map computeIfAbsent  A   k- gt new AtomicLong 0   incrementAndGet    map computeIfAbsent  B   k- gt new AtomicLong 0   incrementAndGet    map computeIfAbsent  A   k- gt new AtomicLong 0   incrementAndGet       A 2  B 1    The method computeIfAbsent checks if the specified key is already associated with a value or not  If no associated value then it attempts to compute its value using the given mapping function  In any case it returns the current  existing or computed  value associated with the specified key  or null if the computed value is null   On a side note if you have a situation where multiple threads update a common sum you can have a look at LongAdder class Under high contention  expected throughput of this class is significantly higher than AtomicLong  at the expense of higher space consumption

User · Answer

Vilmantas Baranauskas  Regarding this answer  I would comment if I had the rep points  but I don t   I wanted to note that the Counter class defined there is NOT thread-safe as it is not sufficient to just synchronize inc   without synchronizing value     Other threads calling value   are not guaranteed to see the the value unless a happens-before relationship has been established with the update

User · Answer

You can make use of computeIfAbsent method in Map interface provided in Java 8    final Map lt String AtomicLong gt  map   new ConcurrentHashMap lt  gt     map computeIfAbsent  A   k- gt new AtomicLong 0   incrementAndGet    map computeIfAbsent  B   k- gt new AtomicLong 0   incrementAndGet    map computeIfAbsent  A   k- gt new AtomicLong 0   incrementAndGet       A 2  B 1    The method computeIfAbsent checks if the specified key is already associated with a value or not  If no associated value then it attempts to compute its value using the given mapping function  In any case it returns the current  existing or computed  value associated with the specified key  or null if the computed value is null   On a side note if you have a situation where multiple threads update a common sum you can have a look at LongAdder class Under high contention  expected throughput of this class is significantly higher than AtomicLong  at the expense of higher space consumption

User · Answer

Instead of calling containsKey   it is faster just to call map get and check if the returned value is null or not       Integer count   map get word       if count    null           count   0            map put word  count   1

User · Answer

If you re using Eclipse Collections  you can use a HashBag  It will be the most efficient approach in terms of memory usage and it will also perform well in terms of execution speed   HashBag is backed by a MutableObjectIntMap which stores primitive ints instead of Counter objects  This reduces memory overhead and improves execution speed   HashBag provides the API you d need since it s a Collection that also allows you to query for the number of occurrences of an item   Here s an example from the Eclipse Collections Kata   MutableBag lt String gt  bag     HashBag newBagWith  one    two    two    three    three    three     Assert assertEquals 3  bag occurrencesOf  three      bag add  one    Assert assertEquals 2  bag occurrencesOf  one      bag addOccurrences  one   4   Assert assertEquals 6  bag occurrencesOf  one       Note  I am a committer for Eclipse Collections

User · Answer

There are a couple of approaches    Use a Bag alorithm like the sets contained in Google Collections  Create mutable container which you can use in the Map          class My          String word          int count           And use put  word   new My  Word      Then you can check if it exists and increment when adding   Avoid rolling your own solution using lists  because if you get innerloop searching and sorting  your performance will stink  The first HashMap solution is actually quite fast  but a proper like that found in Google Collections is probably better   Counting words using Google Collections  looks something like this          HashMultiset s   new HashMultiset        s add  word        s add  word        System out println    s count  word          Using the HashMultiset is quite elegent  because a bag-algorithm is just what you need when counting words

User · Answer

You should be aware of the fact that your original attempt   int count   map containsKey word    map get word    0   contains two potentially expensive operations on a map  namely containsKey and get  The former performs an operation potentially pretty similar to the latter  so you re doing the same work twice   If you look at the API for Map  get operations usually return null when the map does not contain the requested element   Note that this will make a solution like  map put  key  map get key    1     dangerous  since it might yield NullPointerExceptions  You should check for a null first   Also note  and this is very important  that HashMaps can contain nulls by definition  So not every returned null says  there is no such element   In this respect  containsKey behaves differently from get in actually telling you whether there is such an element  Refer to the API for details   For your case  however  you might not want to distinguish between a stored null and  noSuchElement   If you don t want to permit nulls you might prefer a Hashtable  Using a wrapper library as was already proposed in other answers might be a better solution to manual treatment  depending on the complexity of your application   To complete the answer  and I forgot to put that in at first  thanks to the edit function    the best way of doing it natively  is to get into a final variable  check for null and put it back in with a 1  The variable should be final because it s immutable anyway  The compiler might not need this hint  but its clearer that way    final HashMap map   generateRandomHashMap    final Object key   fetchSomeKey    final Integer i   map get key   if  i    null        map put i   1     else          do something     If you do not want to rely on autoboxing  you should say something like map put new Integer 1   i getValue      instead

User · Answer

Another way would be creating a mutable integer   class MutableInt     int value   0    public void inc        value      public int get      return value          Map lt String MutableInt gt  map   new HashMap lt String MutableInt gt      MutableInt value   map get  key   if  value    null      value   new MutableInt       map put  key  value     else     value inc         of course this implies creating an additional object but the overhead in comparison to creating an Integer  even with Integer valueOf  should not be so much

User · Answer

I d use Apache Collections Lazy Map  to initialize values to 0  and use MutableIntegers from Apache Lang as values in that map    Biggest cost is having to serach the map twice in your method  In mine you have to do it just once  Just get the value  it will get initialized if absent  and increment it

User · Answer

A little research in 2016  https   github com leventov java-word-count  benchmark source code  Best results per method  smaller is better                     time  ms kolobokeCompile  18 8 koloboke         19 8 trove            20 8 fastutil         22 7 mutableInt       24 3 atomicInteger    25 3 eclipse          26 9 hashMap          28 0 hppc             33 6 hppcRt           36 5   Time space results

User · Answer

Another way would be creating a mutable integer   class MutableInt     int value   0    public void inc        value      public int get      return value          Map lt String MutableInt gt  map   new HashMap lt String MutableInt gt      MutableInt value   map get  key   if  value    null      value   new MutableInt       map put  key  value     else     value inc         of course this implies creating an additional object but the overhead in comparison to creating an Integer  even with Integer valueOf  should not be so much

User · Answer

Instead of calling containsKey   it is faster just to call map get and check if the returned value is null or not       Integer count   map get word       if count    null           count   0            map put word  count   1

User · Answer

Now there is a shorter way with Java 8 using Map  merge    myMap merge key  1  Integer  sum    What it does    if key do not exists  put 1 as value otherwise sum 1 to the value linked to key   More information here

User · Answer

Some test results  I ve gotten a lot of good answers to this question--thanks folks--so I decided to run some tests and figure out which method is actually fastest  The five methods I tested are these    the  ContainsKey  method that I presented in the question the  TestForNull  method suggested by Aleksandar Dimitrov the  AtomicLong  method suggested by Hank Gay the  Trove  method suggested by jrudolph the  MutableInt  method suggested by phax myopenid com   Method  Here s what I did      created five classes that were identical except for the differences shown below  Each class had to perform an operation typical of the scenario I presented  opening a 10MB file and reading it in  then performing a frequency count of all the word tokens in the file  Since this took an average of only 3 seconds  I had it perform the frequency count  not the I O  10 times  timed the loop of 10 iterations but not the I O operation and recorded the total time taken  in clock seconds  essentially using Ian Darwin s method in the Java Cookbook  performed all five tests in series  and then did this another three times  averaged the four results for each method    Results  I ll present the results first and the code below for those who are interested   The ContainsKey method was  as expected  the slowest  so I ll give the speed of each method in comparison to the speed of that method    ContainsKey  30 654 seconds  baseline  AtomicLong  29 780 seconds  1 03 times as fast  TestForNull  28 804 seconds  1 06 times as fast  Trove  26 313 seconds  1 16 times as fast  MutableInt  25 747 seconds  1 19 times as fast    Conclusions  It would appear that only the MutableInt method and the Trove method are significantly faster  in that only they give a performance boost of more than 10   However  if threading is an issue  AtomicLong might be more attractive than the others  I m not really sure   I also ran TestForNull with final variables  but the difference was negligible   Note that I haven t profiled memory usage in the different scenarios  I d be happy to hear from anybody who has good insights into how the MutableInt and Trove methods would be likely to affect memory usage   Personally  I find the MutableInt method the most attractive  since it doesn t require loading any third-party classes  So unless I discover problems with it  that s the way I m most likely to go   The code  Here is the crucial code from each method   ContainsKey  import java util HashMap  import java util Map      Map lt String  Integer gt  freq   new HashMap lt String  Integer gt         int count   freq containsKey word    freq get word    0  freq put word  count   1     TestForNull  import java util HashMap  import java util Map      Map lt String  Integer gt  freq   new HashMap lt String  Integer gt         Integer count   freq get word   if  count    null        freq put word  1     else       freq put word  count   1       AtomicLong  import java util concurrent ConcurrentHashMap  import java util concurrent ConcurrentMap  import java util concurrent atomic AtomicLong      final ConcurrentMap lt String  AtomicLong gt  map        new ConcurrentHashMap lt String  AtomicLong gt         map putIfAbsent word  new AtomicLong 0    map get word  incrementAndGet      Trove  import gnu trove TObjectIntHashMap      TObjectIntHashMap lt String gt  freq   new TObjectIntHashMap lt String gt         freq adjustOrPutValue word  1  1     MutableInt  import java util HashMap  import java util Map      class MutableInt     int value   1     note that we start at 1 since we re counting   public void increment        value           public int  get            return value          Map lt String  MutableInt gt  freq   new HashMap lt String  MutableInt gt         MutableInt count   freq get word   if  count    null        freq put word  new MutableInt       else       count increment

User · Answer

There are a couple of approaches    Use a Bag alorithm like the sets contained in Google Collections  Create mutable container which you can use in the Map          class My          String word          int count           And use put  word   new My  Word      Then you can check if it exists and increment when adding   Avoid rolling your own solution using lists  because if you get innerloop searching and sorting  your performance will stink  The first HashMap solution is actually quite fast  but a proper like that found in Google Collections is probably better   Counting words using Google Collections  looks something like this          HashMultiset s   new HashMultiset        s add  word        s add  word        System out println    s count  word          Using the HashMultiset is quite elegent  because a bag-algorithm is just what you need when counting words

User · Answer

As a follow-up to my own comment  Trove looks like the way to go  If  for whatever reason  you wanted to stick with the standard JDK  ConcurrentMap and AtomicLong can make the code a tiny bit nicer  though YMMV      final ConcurrentMap lt String  AtomicLong gt  map   new ConcurrentHashMap lt String  AtomicLong gt         map putIfAbsent  quot foo quot   new AtomicLong 0        map get  quot foo quot   incrementAndGet     will leave 1 as the value in the map for foo  Realistically  increased friendliness to threading is all that this approach has to recommend it

User · Answer

I d use Apache Collections Lazy Map  to initialize values to 0  and use MutableIntegers from Apache Lang as values in that map    Biggest cost is having to serach the map twice in your method  In mine you have to do it just once  Just get the value  it will get initialized if absent  and increment it

User · Answer

If you re using Eclipse Collections  you can use a HashBag  It will be the most efficient approach in terms of memory usage and it will also perform well in terms of execution speed   HashBag is backed by a MutableObjectIntMap which stores primitive ints instead of Counter objects  This reduces memory overhead and improves execution speed   HashBag provides the API you d need since it s a Collection that also allows you to query for the number of occurrences of an item   Here s an example from the Eclipse Collections Kata   MutableBag lt String gt  bag     HashBag newBagWith  one    two    two    three    three    three     Assert assertEquals 3  bag occurrencesOf  three      bag add  one    Assert assertEquals 2  bag occurrencesOf  one      bag addOccurrences  one   4   Assert assertEquals 6  bag occurrencesOf  one       Note  I am a committer for Eclipse Collections

User · Answer

I d use Apache Collections Lazy Map  to initialize values to 0  and use MutableIntegers from Apache Lang as values in that map    Biggest cost is having to serach the map twice in your method  In mine you have to do it just once  Just get the value  it will get initialized if absent  and increment it

User · Answer

Memory rotation may be an issue here  since every boxing of an int larger than or equal to 128 causes an object allocation  see Integer valueOf int    Although the garbage collector very efficiently deals with short-lived objects  performance will suffer to some degree   If you know that the number of increments made will largely outnumber the number of keys   words in this case   consider using an int holder instead  Phax already presented code for this  Here it is again  with two changes  holder class made static and initial value set to 1    static class MutableInt     int value   1    void inc       value      int get     return value          Map lt String MutableInt gt  map   new HashMap lt String MutableInt gt     MutableInt value   map get key   if  value    null      value   new MutableInt      map put key  value     else     value inc        If you need extreme performance  look for a Map implementation which is directly tailored towards primitive value types  jrudolph mentioned GNU Trove   By the way  a good search term for this subject is  histogram

User · Answer

As a follow-up to my own comment  Trove looks like the way to go  If  for whatever reason  you wanted to stick with the standard JDK  ConcurrentMap and AtomicLong can make the code a tiny bit nicer  though YMMV      final ConcurrentMap lt String  AtomicLong gt  map   new ConcurrentHashMap lt String  AtomicLong gt         map putIfAbsent  quot foo quot   new AtomicLong 0        map get  quot foo quot   incrementAndGet     will leave 1 as the value in the map for foo  Realistically  increased friendliness to threading is all that this approach has to recommend it

User · Answer

I d use Apache Collections Lazy Map  to initialize values to 0  and use MutableIntegers from Apache Lang as values in that map    Biggest cost is having to serach the map twice in your method  In mine you have to do it just once  Just get the value  it will get initialized if absent  and increment it

User · Answer

Some test results  I ve gotten a lot of good answers to this question--thanks folks--so I decided to run some tests and figure out which method is actually fastest  The five methods I tested are these    the  ContainsKey  method that I presented in the question the  TestForNull  method suggested by Aleksandar Dimitrov the  AtomicLong  method suggested by Hank Gay the  Trove  method suggested by jrudolph the  MutableInt  method suggested by phax myopenid com   Method  Here s what I did      created five classes that were identical except for the differences shown below  Each class had to perform an operation typical of the scenario I presented  opening a 10MB file and reading it in  then performing a frequency count of all the word tokens in the file  Since this took an average of only 3 seconds  I had it perform the frequency count  not the I O  10 times  timed the loop of 10 iterations but not the I O operation and recorded the total time taken  in clock seconds  essentially using Ian Darwin s method in the Java Cookbook  performed all five tests in series  and then did this another three times  averaged the four results for each method    Results  I ll present the results first and the code below for those who are interested   The ContainsKey method was  as expected  the slowest  so I ll give the speed of each method in comparison to the speed of that method    ContainsKey  30 654 seconds  baseline  AtomicLong  29 780 seconds  1 03 times as fast  TestForNull  28 804 seconds  1 06 times as fast  Trove  26 313 seconds  1 16 times as fast  MutableInt  25 747 seconds  1 19 times as fast    Conclusions  It would appear that only the MutableInt method and the Trove method are significantly faster  in that only they give a performance boost of more than 10   However  if threading is an issue  AtomicLong might be more attractive than the others  I m not really sure   I also ran TestForNull with final variables  but the difference was negligible   Note that I haven t profiled memory usage in the different scenarios  I d be happy to hear from anybody who has good insights into how the MutableInt and Trove methods would be likely to affect memory usage   Personally  I find the MutableInt method the most attractive  since it doesn t require loading any third-party classes  So unless I discover problems with it  that s the way I m most likely to go   The code  Here is the crucial code from each method   ContainsKey  import java util HashMap  import java util Map      Map lt String  Integer gt  freq   new HashMap lt String  Integer gt         int count   freq containsKey word    freq get word    0  freq put word  count   1     TestForNull  import java util HashMap  import java util Map      Map lt String  Integer gt  freq   new HashMap lt String  Integer gt         Integer count   freq get word   if  count    null        freq put word  1     else       freq put word  count   1       AtomicLong  import java util concurrent ConcurrentHashMap  import java util concurrent ConcurrentMap  import java util concurrent atomic AtomicLong      final ConcurrentMap lt String  AtomicLong gt  map        new ConcurrentHashMap lt String  AtomicLong gt         map putIfAbsent word  new AtomicLong 0    map get word  incrementAndGet      Trove  import gnu trove TObjectIntHashMap      TObjectIntHashMap lt String gt  freq   new TObjectIntHashMap lt String gt         freq adjustOrPutValue word  1  1     MutableInt  import java util HashMap  import java util Map      class MutableInt     int value   1     note that we start at 1 since we re counting   public void increment        value           public int  get            return value          Map lt String  MutableInt gt  freq   new HashMap lt String  MutableInt gt         MutableInt count   freq get word   if  count    null        freq put word  new MutableInt       else       count increment

User · Answer

Another way would be creating a mutable integer   class MutableInt     int value   0    public void inc        value      public int get      return value          Map lt String MutableInt gt  map   new HashMap lt String MutableInt gt      MutableInt value   map get  key   if  value    null      value   new MutableInt       map put  key  value     else     value inc         of course this implies creating an additional object but the overhead in comparison to creating an Integer  even with Integer valueOf  should not be so much

User · Answer

Are you sure that this is a bottleneck  Have you done any performance analysis   Try using the NetBeans profiler  its free and built into NB 6 1  to look at hotspots   Finally  a JVM upgrade  say from 1 5- 1 6  is often a cheap performance booster  Even an upgrade in build number can provide good performance boosts  If you are running on Windows and this is a server class application  use -server on the command line to use the Server Hotspot JVM  On Linux and Solaris machines this is autodetected

User · Answer

Google Guava is your friend        at least in some cases  They have this nice AtomicLongMap  Especially nice because you are dealing with long as value in your map   E g     AtomicLongMap lt String gt  map   AtomicLongMap create          map getAndIncrement word     Also possible to add more then 1 to the value   map getAndAdd word  112L

User · Answer

I suggest to use Java 8 Map  compute    It considers the case when a key doesn t exist  too   Map compute num   k  v  - gt   v    null    1   v   1

User · Answer

Instead of calling containsKey   it is faster just to call map get and check if the returned value is null or not       Integer count   map get word       if count    null           count   0            map put word  count   1

User · Answer

put  need  get   to ensure no duplicate key   So directly do a  put   and if there was a previous value  then do an addition   Map map   new HashMap      MutableInt newValue   new MutableInt  1      default   inc MutableInt oldValue   map put  key  newValue   if  oldValue    null      newValue add oldValue      old   inc     If count starts at 0  then add 1   or any others values      Map map   new HashMap      MutableInt newValue   new MutableInt  0      default MutableInt oldValue   map put  key  newValue   if  oldValue    null      newValue setValue oldValue   1      old   inc     Notice   This code is not thread safe  Use it to build then use the map  not to concurrently update it    Optimization   In a loop  keep old value to become the new value of next loop   Map map   new HashMap     final int defaut   0  final int inc   1   MutableInt oldValue   new MutableInt  default   while true      MutableInt newValue   oldValue     oldValue   map put  key  newValue      insert or      if  oldValue    null        newValue setValue oldValue   inc         update      oldValue setValue default      reuse     else     oldValue   new MutableInt  default      renew

User · Answer

Another way would be creating a mutable integer   class MutableInt     int value   0    public void inc        value      public int get      return value          Map lt String MutableInt gt  map   new HashMap lt String MutableInt gt      MutableInt value   map get  key   if  value    null      value   new MutableInt       map put  key  value     else     value inc         of course this implies creating an additional object but the overhead in comparison to creating an Integer  even with Integer valueOf  should not be so much

User · Answer

Now there is a shorter way with Java 8 using Map  merge    myMap merge key  1  Integer  sum    What it does    if key do not exists  put 1 as value otherwise sum 1 to the value linked to key   More information here

User · Answer

It s always a good idea to look at the Google Collections Library for this kind of thing  In this case a Multiset will do the trick   Multiset bag   Multisets newHashMultiset    String word    foo   bag add word   bag add word   System out println bag count word       Prints 2   There are Map-like methods for iterating over keys entries  etc  Internally the implementation currently uses a HashMap lt E  AtomicInteger gt   so you will not incur boxing costs

User · Answer

I suggest to use Java 8 Map  compute    It considers the case when a key doesn t exist  too   Map compute num   k  v  - gt   v    null    1   v   1

User · Answer

Instead of calling containsKey   it is faster just to call map get and check if the returned value is null or not       Integer count   map get word       if count    null           count   0            map put word  count   1

User · Answer

I don t know how efficient it is but the below code works as well You need to define a BiFunction at the beginning  Plus  you can make more than just increment with this method   public static Map lt String  Integer gt  strInt   new HashMap lt String  Integer gt      public static void main String   args        BiFunction lt Integer  Integer  Integer gt  bi    x y  - gt            if x    null              return y          return x y             strInt put  abc   0         strInt merge  abc   1  bi       strInt merge  abc   1  bi       strInt merge  abc   1  bi       strInt merge  abcd   1  bi        System out println strInt get  abc         System out println strInt get  abcd         output is  3 1

User · Answer

Quite simple  just use the built-in function in Map java as followed  map put key  map getOrDefault key  0    1

User · Answer

Hope I m understanding your question correctly  I m coming to Java from Python so I can empathize with your struggle    if you have  map put key  1    you would do  map put key  map get key    1    Hope this helps

User · Answer

Memory rotation may be an issue here  since every boxing of an int larger than or equal to 128 causes an object allocation  see Integer valueOf int    Although the garbage collector very efficiently deals with short-lived objects  performance will suffer to some degree   If you know that the number of increments made will largely outnumber the number of keys   words in this case   consider using an int holder instead  Phax already presented code for this  Here it is again  with two changes  holder class made static and initial value set to 1    static class MutableInt     int value   1    void inc       value      int get     return value          Map lt String MutableInt gt  map   new HashMap lt String MutableInt gt     MutableInt value   map get key   if  value    null      value   new MutableInt      map put key  value     else     value inc        If you need extreme performance  look for a Map implementation which is directly tailored towards primitive value types  jrudolph mentioned GNU Trove   By the way  a good search term for this subject is  histogram

User · Answer

I d use Apache Collections Lazy Map  to initialize values to 0  and use MutableIntegers from Apache Lang as values in that map    Biggest cost is having to serach the map twice in your method  In mine you have to do it just once  Just get the value  it will get initialized if absent  and increment it

User · Answer

Instead of calling containsKey   it is faster just to call map get and check if the returned value is null or not       Integer count   map get word       if count    null           count   0            map put word  count   1

User · Answer

I d use Apache Collections Lazy Map  to initialize values to 0  and use MutableIntegers from Apache Lang as values in that map    Biggest cost is having to serach the map twice in your method  In mine you have to do it just once  Just get the value  it will get initialized if absent  and increment it

User · Answer

Map lt String  Integer gt  map   new HashMap lt  gt     String key    a random key   int count   map getOrDefault key  0      ensure count will be one of 0 1 2 3     map put key  count   1     And that s how you increment a value with simple code   Benefit    No need to add a new class or use another concept of mutable int Not relying on any library Easy to understand what s going on exactly  Not too much abstraction    Downside    The hash map will be searched twice for get   and put    So it will not be the most performant code     Theoretically  once you call get    you already know where to put    so you should not have to search again  But searching in hash map usually takes a very minimal time that you can kind of ignore this performance issue   But if you are very serious about the issue  you are a perfectionist  another way is to use merge method  this is  probably  more efficient than the previous code snippet as you will be  theoretically  searching the map only once   though this code is not obvious from first sight  it s short and performant   map merge key  1   a b  - gt  a b     Suggestion  you should care about code readability more than little performance gain in most of the time  If the first code snippet is easier for you to understand then use it  But if you are able to understand the 2nd one fine then you can also go for it

User · Answer

The simple and easy way in java 8 is the following   final ConcurrentMap lt String  AtomicLong gt  map   new ConcurrentHashMap lt String  AtomicLong gt         map computeIfAbsent  foo   key - gt  new AtomicLong 0   incrementAndGet

User · Answer

Quite simple  just use the built-in function in Map java as followed  map put key  map getOrDefault key  0    1

User · Answer

Instead of calling containsKey   it is faster just to call map get and check if the returned value is null or not       Integer count   map get word       if count    null           count   0            map put word  count   1

User · Answer

Since a lot of people search Java topics for Groovy answers  here s how you can do it in Groovy   dev map   new HashMap lt String  Integer gt    map put  key1   3   map merge  key1   1   a  b - gt  a   b  map merge  key2   1   a  b - gt  a   b

User · Answer

Since a lot of people search Java topics for Groovy answers  here s how you can do it in Groovy   dev map   new HashMap lt String  Integer gt    map put  key1   3   map merge  key1   1   a  b - gt  a   b  map merge  key2   1   a  b - gt  a   b

User · Answer

Memory rotation may be an issue here  since every boxing of an int larger than or equal to 128 causes an object allocation  see Integer valueOf int    Although the garbage collector very efficiently deals with short-lived objects  performance will suffer to some degree   If you know that the number of increments made will largely outnumber the number of keys   words in this case   consider using an int holder instead  Phax already presented code for this  Here it is again  with two changes  holder class made static and initial value set to 1    static class MutableInt     int value   1    void inc       value      int get     return value          Map lt String MutableInt gt  map   new HashMap lt String MutableInt gt     MutableInt value   map get key   if  value    null      value   new MutableInt      map put key  value     else     value inc        If you need extreme performance  look for a Map implementation which is directly tailored towards primitive value types  jrudolph mentioned GNU Trove   By the way  a good search term for this subject is  histogram

User · Answer

Another way would be creating a mutable integer   class MutableInt     int value   0    public void inc        value      public int get      return value          Map lt String MutableInt gt  map   new HashMap lt String MutableInt gt      MutableInt value   map get  key   if  value    null      value   new MutableInt       map put  key  value     else     value inc         of course this implies creating an additional object but the overhead in comparison to creating an Integer  even with Integer valueOf  should not be so much

User · Answer

Are you sure that this is a bottleneck  Have you done any performance analysis   Try using the NetBeans profiler  its free and built into NB 6 1  to look at hotspots   Finally  a JVM upgrade  say from 1 5- 1 6  is often a cheap performance booster  Even an upgrade in build number can provide good performance boosts  If you are running on Windows and this is a server class application  use -server on the command line to use the Server Hotspot JVM  On Linux and Solaris machines this is autodetected

User · Answer

I d use Apache Collections Lazy Map  to initialize values to 0  and use MutableIntegers from Apache Lang as values in that map    Biggest cost is having to serach the map twice in your method  In mine you have to do it just once  Just get the value  it will get initialized if absent  and increment it

User · Answer

Now there is a shorter way with Java 8 using Map  merge    myMap merge key  1  Integer  sum    What it does    if key do not exists  put 1 as value otherwise sum 1 to the value linked to key   More information here

User · Answer

The various primitive wrappers  e g   Integer are immutable so there s really not a more concise way to do what you re asking unless you can do it with something like AtomicLong  I can give that a go in a minute and update  BTW  Hashtable is a part of the Collections Framework

User · Answer

The simple and easy way in java 8 is the following   final ConcurrentMap lt String  AtomicLong gt  map   new ConcurrentHashMap lt String  AtomicLong gt         map computeIfAbsent  foo   key - gt  new AtomicLong 0   incrementAndGet

User · Answer

The various primitive wrappers  e g   Integer are immutable so there s really not a more concise way to do what you re asking unless you can do it with something like AtomicLong  I can give that a go in a minute and update  BTW  Hashtable is a part of the Collections Framework

User · Answer

I suggest to use Java 8 Map  compute    It considers the case when a key doesn t exist  too   Map compute num   k  v  - gt   v    null    1   v   1

User · Answer

The various primitive wrappers  e g   Integer are immutable so there s really not a more concise way to do what you re asking unless you can do it with something like AtomicLong  I can give that a go in a minute and update  BTW  Hashtable is a part of the Collections Framework

User · Answer

It s always a good idea to look at the Google Collections Library for this kind of thing  In this case a Multiset will do the trick   Multiset bag   Multisets newHashMultiset    String word    foo   bag add word   bag add word   System out println bag count word       Prints 2   There are Map-like methods for iterating over keys entries  etc  Internally the implementation currently uses a HashMap lt E  AtomicInteger gt   so you will not incur boxing costs

User · Answer

put  need  get   to ensure no duplicate key   So directly do a  put   and if there was a previous value  then do an addition   Map map   new HashMap      MutableInt newValue   new MutableInt  1      default   inc MutableInt oldValue   map put  key  newValue   if  oldValue    null      newValue add oldValue      old   inc     If count starts at 0  then add 1   or any others values      Map map   new HashMap      MutableInt newValue   new MutableInt  0      default MutableInt oldValue   map put  key  newValue   if  oldValue    null      newValue setValue oldValue   1      old   inc     Notice   This code is not thread safe  Use it to build then use the map  not to concurrently update it    Optimization   In a loop  keep old value to become the new value of next loop   Map map   new HashMap     final int defaut   0  final int inc   1   MutableInt oldValue   new MutableInt  default   while true      MutableInt newValue   oldValue     oldValue   map put  key  newValue      insert or      if  oldValue    null        newValue setValue oldValue   inc         update      oldValue setValue default      reuse     else     oldValue   new MutableInt  default      renew

User · Answer

The Functional Java library s TreeMap datastructure has an update method in the latest trunk head   public TreeMap lt K  V gt  update final K k  final F lt V  V gt  f    Example usage   import static fj data TreeMap empty  import static fj function Integers add  import static fj pre Ord stringOrd  import fj data TreeMap   public class TreeMap Update    public static void main String   a       TreeMap lt String  Integer gt  map   empty stringOrd        map   map set  foo   1        map   map update  foo   add f 1         System out println map get  foo   some         This program prints  2

User · Answer

I think your solution would be the standard way  but - as you noted yourself - it is probably not the fastest way possible   You may look at GNU Trove  That is a library which contains all sorts of fast primitive Collections  Your example would use a TObjectIntHashMap which has a method adjustOrPutValue which does exactly what you want

User · Answer

I think your solution would be the standard way  but - as you noted yourself - it is probably not the fastest way possible   You may look at GNU Trove  That is a library which contains all sorts of fast primitive Collections  Your example would use a TObjectIntHashMap which has a method adjustOrPutValue which does exactly what you want

User · Answer

If you re using Eclipse Collections  you can use a HashBag  It will be the most efficient approach in terms of memory usage and it will also perform well in terms of execution speed   HashBag is backed by a MutableObjectIntMap which stores primitive ints instead of Counter objects  This reduces memory overhead and improves execution speed   HashBag provides the API you d need since it s a Collection that also allows you to query for the number of occurrences of an item   Here s an example from the Eclipse Collections Kata   MutableBag lt String gt  bag     HashBag newBagWith  one    two    two    three    three    three     Assert assertEquals 3  bag occurrencesOf  three      bag add  one    Assert assertEquals 2  bag occurrencesOf  one      bag addOccurrences  one   4   Assert assertEquals 6  bag occurrencesOf  one       Note  I am a committer for Eclipse Collections

User · Answer

Memory rotation may be an issue here  since every boxing of an int larger than or equal to 128 causes an object allocation  see Integer valueOf int    Although the garbage collector very efficiently deals with short-lived objects  performance will suffer to some degree   If you know that the number of increments made will largely outnumber the number of keys   words in this case   consider using an int holder instead  Phax already presented code for this  Here it is again  with two changes  holder class made static and initial value set to 1    static class MutableInt     int value   1    void inc       value      int get     return value          Map lt String MutableInt gt  map   new HashMap lt String MutableInt gt     MutableInt value   map get key   if  value    null      value   new MutableInt      map put key  value     else     value inc        If you need extreme performance  look for a Map implementation which is directly tailored towards primitive value types  jrudolph mentioned GNU Trove   By the way  a good search term for this subject is  histogram

User · Answer

A little research in 2016  https   github com leventov java-word-count  benchmark source code  Best results per method  smaller is better                     time  ms kolobokeCompile  18 8 koloboke         19 8 trove            20 8 fastutil         22 7 mutableInt       24 3 atomicInteger    25 3 eclipse          26 9 hashMap          28 0 hppc             33 6 hppcRt           36 5   Time space results

User · Answer

There are a couple of approaches    Use a Bag alorithm like the sets contained in Google Collections  Create mutable container which you can use in the Map          class My          String word          int count           And use put  word   new My  Word      Then you can check if it exists and increment when adding   Avoid rolling your own solution using lists  because if you get innerloop searching and sorting  your performance will stink  The first HashMap solution is actually quite fast  but a proper like that found in Google Collections is probably better   Counting words using Google Collections  looks something like this          HashMultiset s   new HashMultiset        s add  word        s add  word        System out println    s count  word          Using the HashMultiset is quite elegent  because a bag-algorithm is just what you need when counting words

User · Answer

Are you sure that this is a bottleneck  Have you done any performance analysis   Try using the NetBeans profiler  its free and built into NB 6 1  to look at hotspots   Finally  a JVM upgrade  say from 1 5- 1 6  is often a cheap performance booster  Even an upgrade in build number can provide good performance boosts  If you are running on Windows and this is a server class application  use -server on the command line to use the Server Hotspot JVM  On Linux and Solaris machines this is autodetected

User · Answer

Google Collections HashMultiset    - quite elegant to use  - but consume CPU and memory  Best would be to have a method like   Entry lt K V gt  getOrPut K     elegant  and low cost   Such a method will compute hash and index only once  and then we could do what we want with the entry  either replace or update the value    More elegant   - take a HashSet lt Entry gt   - extend it so that get K  put a new Entry if needed  - Entry could be your own object  --   new MyHashSet    get k  increment

User · Answer

Google Guava is your friend        at least in some cases  They have this nice AtomicLongMap  Especially nice because you are dealing with long as value in your map   E g     AtomicLongMap lt String gt  map   AtomicLongMap create          map getAndIncrement word     Also possible to add more then 1 to the value   map getAndAdd word  112L

User · Answer

Vilmantas Baranauskas  Regarding this answer  I would comment if I had the rep points  but I don t   I wanted to note that the Counter class defined there is NOT thread-safe as it is not sufficient to just synchronize inc   without synchronizing value     Other threads calling value   are not guaranteed to see the the value unless a happens-before relationship has been established with the update

User · Answer

It s always a good idea to look at the Google Collections Library for this kind of thing  In this case a Multiset will do the trick   Multiset bag   Multisets newHashMultiset    String word    foo   bag add word   bag add word   System out println bag count word       Prints 2   There are Map-like methods for iterating over keys entries  etc  Internally the implementation currently uses a HashMap lt E  AtomicInteger gt   so you will not incur boxing costs

User · Answer

Some test results  I ve gotten a lot of good answers to this question--thanks folks--so I decided to run some tests and figure out which method is actually fastest  The five methods I tested are these    the  ContainsKey  method that I presented in the question the  TestForNull  method suggested by Aleksandar Dimitrov the  AtomicLong  method suggested by Hank Gay the  Trove  method suggested by jrudolph the  MutableInt  method suggested by phax myopenid com   Method  Here s what I did      created five classes that were identical except for the differences shown below  Each class had to perform an operation typical of the scenario I presented  opening a 10MB file and reading it in  then performing a frequency count of all the word tokens in the file  Since this took an average of only 3 seconds  I had it perform the frequency count  not the I O  10 times  timed the loop of 10 iterations but not the I O operation and recorded the total time taken  in clock seconds  essentially using Ian Darwin s method in the Java Cookbook  performed all five tests in series  and then did this another three times  averaged the four results for each method    Results  I ll present the results first and the code below for those who are interested   The ContainsKey method was  as expected  the slowest  so I ll give the speed of each method in comparison to the speed of that method    ContainsKey  30 654 seconds  baseline  AtomicLong  29 780 seconds  1 03 times as fast  TestForNull  28 804 seconds  1 06 times as fast  Trove  26 313 seconds  1 16 times as fast  MutableInt  25 747 seconds  1 19 times as fast    Conclusions  It would appear that only the MutableInt method and the Trove method are significantly faster  in that only they give a performance boost of more than 10   However  if threading is an issue  AtomicLong might be more attractive than the others  I m not really sure   I also ran TestForNull with final variables  but the difference was negligible   Note that I haven t profiled memory usage in the different scenarios  I d be happy to hear from anybody who has good insights into how the MutableInt and Trove methods would be likely to affect memory usage   Personally  I find the MutableInt method the most attractive  since it doesn t require loading any third-party classes  So unless I discover problems with it  that s the way I m most likely to go   The code  Here is the crucial code from each method   ContainsKey  import java util HashMap  import java util Map      Map lt String  Integer gt  freq   new HashMap lt String  Integer gt         int count   freq containsKey word    freq get word    0  freq put word  count   1     TestForNull  import java util HashMap  import java util Map      Map lt String  Integer gt  freq   new HashMap lt String  Integer gt         Integer count   freq get word   if  count    null        freq put word  1     else       freq put word  count   1       AtomicLong  import java util concurrent ConcurrentHashMap  import java util concurrent ConcurrentMap  import java util concurrent atomic AtomicLong      final ConcurrentMap lt String  AtomicLong gt  map        new ConcurrentHashMap lt String  AtomicLong gt         map putIfAbsent word  new AtomicLong 0    map get word  incrementAndGet      Trove  import gnu trove TObjectIntHashMap      TObjectIntHashMap lt String gt  freq   new TObjectIntHashMap lt String gt         freq adjustOrPutValue word  1  1     MutableInt  import java util HashMap  import java util Map      class MutableInt     int value   1     note that we start at 1 since we re counting   public void increment        value           public int  get            return value          Map lt String  MutableInt gt  freq   new HashMap lt String  MutableInt gt         MutableInt count   freq get word   if  count    null        freq put word  new MutableInt       else       count increment

User · Answer

The Functional Java library s TreeMap datastructure has an update method in the latest trunk head   public TreeMap lt K  V gt  update final K k  final F lt V  V gt  f    Example usage   import static fj data TreeMap empty  import static fj function Integers add  import static fj pre Ord stringOrd  import fj data TreeMap   public class TreeMap Update    public static void main String   a       TreeMap lt String  Integer gt  map   empty stringOrd        map   map set  foo   1        map   map update  foo   add f 1         System out println map get  foo   some         This program prints  2

User · Answer

As a follow-up to my own comment  Trove looks like the way to go  If  for whatever reason  you wanted to stick with the standard JDK  ConcurrentMap and AtomicLong can make the code a tiny bit nicer  though YMMV      final ConcurrentMap lt String  AtomicLong gt  map   new ConcurrentHashMap lt String  AtomicLong gt         map putIfAbsent  quot foo quot   new AtomicLong 0        map get  quot foo quot   incrementAndGet     will leave 1 as the value in the map for foo  Realistically  increased friendliness to threading is all that this approach has to recommend it

User · Answer

There are a couple of approaches    Use a Bag alorithm like the sets contained in Google Collections  Create mutable container which you can use in the Map          class My          String word          int count           And use put  word   new My  Word      Then you can check if it exists and increment when adding   Avoid rolling your own solution using lists  because if you get innerloop searching and sorting  your performance will stink  The first HashMap solution is actually quite fast  but a proper like that found in Google Collections is probably better   Counting words using Google Collections  looks something like this          HashMultiset s   new HashMultiset        s add  word        s add  word        System out println    s count  word          Using the HashMultiset is quite elegent  because a bag-algorithm is just what you need when counting words

User · Answer

You should be aware of the fact that your original attempt   int count   map containsKey word    map get word    0   contains two potentially expensive operations on a map  namely containsKey and get  The former performs an operation potentially pretty similar to the latter  so you re doing the same work twice   If you look at the API for Map  get operations usually return null when the map does not contain the requested element   Note that this will make a solution like  map put  key  map get key    1     dangerous  since it might yield NullPointerExceptions  You should check for a null first   Also note  and this is very important  that HashMaps can contain nulls by definition  So not every returned null says  there is no such element   In this respect  containsKey behaves differently from get in actually telling you whether there is such an element  Refer to the API for details   For your case  however  you might not want to distinguish between a stored null and  noSuchElement   If you don t want to permit nulls you might prefer a Hashtable  Using a wrapper library as was already proposed in other answers might be a better solution to manual treatment  depending on the complexity of your application   To complete the answer  and I forgot to put that in at first  thanks to the edit function    the best way of doing it natively  is to get into a final variable  check for null and put it back in with a 1  The variable should be final because it s immutable anyway  The compiler might not need this hint  but its clearer that way    final HashMap map   generateRandomHashMap    final Object key   fetchSomeKey    final Integer i   map get key   if  i    null        map put i   1     else          do something     If you do not want to rely on autoboxing  you should say something like map put new Integer 1   i getValue      instead

User · Answer

Are you sure that this is a bottleneck  Have you done any performance analysis   Try using the NetBeans profiler  its free and built into NB 6 1  to look at hotspots   Finally  a JVM upgrade  say from 1 5- 1 6  is often a cheap performance booster  Even an upgrade in build number can provide good performance boosts  If you are running on Windows and this is a server class application  use -server on the command line to use the Server Hotspot JVM  On Linux and Solaris machines this is autodetected

User · Answer

put  need  get   to ensure no duplicate key   So directly do a  put   and if there was a previous value  then do an addition   Map map   new HashMap      MutableInt newValue   new MutableInt  1      default   inc MutableInt oldValue   map put  key  newValue   if  oldValue    null      newValue add oldValue      old   inc     If count starts at 0  then add 1   or any others values      Map map   new HashMap      MutableInt newValue   new MutableInt  0      default MutableInt oldValue   map put  key  newValue   if  oldValue    null      newValue setValue oldValue   1      old   inc     Notice   This code is not thread safe  Use it to build then use the map  not to concurrently update it    Optimization   In a loop  keep old value to become the new value of next loop   Map map   new HashMap     final int defaut   0  final int inc   1   MutableInt oldValue   new MutableInt  default   while true      MutableInt newValue   oldValue     oldValue   map put  key  newValue      insert or      if  oldValue    null        newValue setValue oldValue   inc         update      oldValue setValue default      reuse     else     oldValue   new MutableInt  default      renew

User · Answer

I think your solution would be the standard way  but - as you noted yourself - it is probably not the fastest way possible   You may look at GNU Trove  That is a library which contains all sorts of fast primitive Collections  Your example would use a TObjectIntHashMap which has a method adjustOrPutValue which does exactly what you want

User · Answer

You should be aware of the fact that your original attempt   int count   map containsKey word    map get word    0   contains two potentially expensive operations on a map  namely containsKey and get  The former performs an operation potentially pretty similar to the latter  so you re doing the same work twice   If you look at the API for Map  get operations usually return null when the map does not contain the requested element   Note that this will make a solution like  map put  key  map get key    1     dangerous  since it might yield NullPointerExceptions  You should check for a null first   Also note  and this is very important  that HashMaps can contain nulls by definition  So not every returned null says  there is no such element   In this respect  containsKey behaves differently from get in actually telling you whether there is such an element  Refer to the API for details   For your case  however  you might not want to distinguish between a stored null and  noSuchElement   If you don t want to permit nulls you might prefer a Hashtable  Using a wrapper library as was already proposed in other answers might be a better solution to manual treatment  depending on the complexity of your application   To complete the answer  and I forgot to put that in at first  thanks to the edit function    the best way of doing it natively  is to get into a final variable  check for null and put it back in with a 1  The variable should be final because it s immutable anyway  The compiler might not need this hint  but its clearer that way    final HashMap map   generateRandomHashMap    final Object key   fetchSomeKey    final Integer i   map get key   if  i    null        map put i   1     else          do something     If you do not want to rely on autoboxing  you should say something like map put new Integer 1   i getValue      instead

User · Answer

A variation on the MutableInt approach that might be even faster  if a bit of a hack  is to use a single-element int array    Map lt String int   gt  map   new HashMap lt String int   gt         int   value   map get key   if  value    null     map put key  new int   1     else     value 0     It would be interesting if you could rerun your performance tests with this variation   It might be the fastest     Edit  The above pattern worked fine for me  but eventually I changed to use Trove s collections to reduce memory size in some very large maps I was creating -- and as a bonus it was also faster   One really nice feature is that the TObjectIntHashMap class has a single adjustOrPutValue call that  depending on whether there is already a value at that key  will either put an initial value or increment the existing value   This is perfect for incrementing   TObjectIntHashMap lt String gt  map   new TObjectIntHashMap lt String gt         map adjustOrPutValue key  1  1

User · Answer

Google Collections HashMultiset    - quite elegant to use  - but consume CPU and memory  Best would be to have a method like   Entry lt K V gt  getOrPut K     elegant  and low cost   Such a method will compute hash and index only once  and then we could do what we want with the entry  either replace or update the value    More elegant   - take a HashSet lt Entry gt   - extend it so that get K  put a new Entry if needed  - Entry could be your own object  --   new MyHashSet    get k  increment

User · Answer

Hope I m understanding your question correctly  I m coming to Java from Python so I can empathize with your struggle    if you have  map put key  1    you would do  map put key  map get key    1    Hope this helps

User · Answer

Another way would be creating a mutable integer   class MutableInt     int value   0    public void inc        value      public int get      return value          Map lt String MutableInt gt  map   new HashMap lt String MutableInt gt      MutableInt value   map get  key   if  value    null      value   new MutableInt       map put  key  value     else     value inc         of course this implies creating an additional object but the overhead in comparison to creating an Integer  even with Integer valueOf  should not be so much

User · Answer

A variation on the MutableInt approach that might be even faster  if a bit of a hack  is to use a single-element int array    Map lt String int   gt  map   new HashMap lt String int   gt         int   value   map get key   if  value    null     map put key  new int   1     else     value 0     It would be interesting if you could rerun your performance tests with this variation   It might be the fastest     Edit  The above pattern worked fine for me  but eventually I changed to use Trove s collections to reduce memory size in some very large maps I was creating -- and as a bonus it was also faster   One really nice feature is that the TObjectIntHashMap class has a single adjustOrPutValue call that  depending on whether there is already a value at that key  will either put an initial value or increment the existing value   This is perfect for incrementing   TObjectIntHashMap lt String gt  map   new TObjectIntHashMap lt String gt         map adjustOrPutValue key  1  1

User · Answer

The various primitive wrappers  e g   Integer are immutable so there s really not a more concise way to do what you re asking unless you can do it with something like AtomicLong  I can give that a go in a minute and update  BTW  Hashtable is a part of the Collections Framework

User · Answer

I think your solution would be the standard way  but - as you noted yourself - it is probably not the fastest way possible   You may look at GNU Trove  That is a library which contains all sorts of fast primitive Collections  Your example would use a TObjectIntHashMap which has a method adjustOrPutValue which does exactly what you want

User · Answer

Hope I m understanding your question correctly  I m coming to Java from Python so I can empathize with your struggle    if you have  map put key  1    you would do  map put key  map get key    1    Hope this helps

User · Answer

I think your solution would be the standard way  but - as you noted yourself - it is probably not the fastest way possible   You may look at GNU Trove  That is a library which contains all sorts of fast primitive Collections  Your example would use a TObjectIntHashMap which has a method adjustOrPutValue which does exactly what you want

User · Answer

You can make use of computeIfAbsent method in Map interface provided in Java 8    final Map lt String AtomicLong gt  map   new ConcurrentHashMap lt  gt     map computeIfAbsent  A   k- gt new AtomicLong 0   incrementAndGet    map computeIfAbsent  B   k- gt new AtomicLong 0   incrementAndGet    map computeIfAbsent  A   k- gt new AtomicLong 0   incrementAndGet       A 2  B 1    The method computeIfAbsent checks if the specified key is already associated with a value or not  If no associated value then it attempts to compute its value using the given mapping function  In any case it returns the current  existing or computed  value associated with the specified key  or null if the computed value is null   On a side note if you have a situation where multiple threads update a common sum you can have a look at LongAdder class Under high contention  expected throughput of this class is significantly higher than AtomicLong  at the expense of higher space consumption

User · Answer

Vilmantas Baranauskas  Regarding this answer  I would comment if I had the rep points  but I don t   I wanted to note that the Counter class defined there is NOT thread-safe as it is not sufficient to just synchronize inc   without synchronizing value     Other threads calling value   are not guaranteed to see the the value unless a happens-before relationship has been established with the update

User · Answer

The Functional Java library s TreeMap datastructure has an update method in the latest trunk head   public TreeMap lt K  V gt  update final K k  final F lt V  V gt  f    Example usage   import static fj data TreeMap empty  import static fj function Integers add  import static fj pre Ord stringOrd  import fj data TreeMap   public class TreeMap Update    public static void main String   a       TreeMap lt String  Integer gt  map   empty stringOrd        map   map set  foo   1        map   map update  foo   add f 1         System out println map get  foo   some         This program prints  2

User · Answer

Quite simple  just use the built-in function in Map java as followed  map put key  map getOrDefault key  0    1

User · Answer

You can make use of computeIfAbsent method in Map interface provided in Java 8    final Map lt String AtomicLong gt  map   new ConcurrentHashMap lt  gt     map computeIfAbsent  A   k- gt new AtomicLong 0   incrementAndGet    map computeIfAbsent  B   k- gt new AtomicLong 0   incrementAndGet    map computeIfAbsent  A   k- gt new AtomicLong 0   incrementAndGet       A 2  B 1    The method computeIfAbsent checks if the specified key is already associated with a value or not  If no associated value then it attempts to compute its value using the given mapping function  In any case it returns the current  existing or computed  value associated with the specified key  or null if the computed value is null   On a side note if you have a situation where multiple threads update a common sum you can have a look at LongAdder class Under high contention  expected throughput of this class is significantly higher than AtomicLong  at the expense of higher space consumption

User · Answer

Hope I m understanding your question correctly  I m coming to Java from Python so I can empathize with your struggle    if you have  map put key  1    you would do  map put key  map get key    1    Hope this helps

User · Answer

I think your solution would be the standard way  but - as you noted yourself - it is probably not the fastest way possible   You may look at GNU Trove  That is a library which contains all sorts of fast primitive Collections  Your example would use a TObjectIntHashMap which has a method adjustOrPutValue which does exactly what you want

User · Answer

I suggest to use Java 8 Map  compute    It considers the case when a key doesn t exist  too   Map compute num   k  v  - gt   v    null    1   v   1

User · Answer

Since a lot of people search Java topics for Groovy answers  here s how you can do it in Groovy   dev map   new HashMap lt String  Integer gt    map put  key1   3   map merge  key1   1   a  b - gt  a   b  map merge  key2   1   a  b - gt  a   b

User · Answer

As a follow-up to my own comment  Trove looks like the way to go  If  for whatever reason  you wanted to stick with the standard JDK  ConcurrentMap and AtomicLong can make the code a tiny bit nicer  though YMMV      final ConcurrentMap lt String  AtomicLong gt  map   new ConcurrentHashMap lt String  AtomicLong gt         map putIfAbsent  quot foo quot   new AtomicLong 0        map get  quot foo quot   incrementAndGet     will leave 1 as the value in the map for foo  Realistically  increased friendliness to threading is all that this approach has to recommend it

User · Answer

Vilmantas Baranauskas  Regarding this answer  I would comment if I had the rep points  but I don t   I wanted to note that the Counter class defined there is NOT thread-safe as it is not sufficient to just synchronize inc   without synchronizing value     Other threads calling value   are not guaranteed to see the the value unless a happens-before relationship has been established with the update

User · Answer

As a follow-up to my own comment  Trove looks like the way to go  If  for whatever reason  you wanted to stick with the standard JDK  ConcurrentMap and AtomicLong can make the code a tiny bit nicer  though YMMV      final ConcurrentMap lt String  AtomicLong gt  map   new ConcurrentHashMap lt String  AtomicLong gt         map putIfAbsent  quot foo quot   new AtomicLong 0        map get  quot foo quot   incrementAndGet     will leave 1 as the value in the map for foo  Realistically  increased friendliness to threading is all that this approach has to recommend it

User · Answer

Another way would be creating a mutable integer   class MutableInt     int value   0    public void inc        value      public int get      return value          Map lt String MutableInt gt  map   new HashMap lt String MutableInt gt      MutableInt value   map get  key   if  value    null      value   new MutableInt       map put  key  value     else     value inc         of course this implies creating an additional object but the overhead in comparison to creating an Integer  even with Integer valueOf  should not be so much

User · Answer

Map lt String  Integer gt  map   new HashMap lt  gt     String key    a random key   int count   map getOrDefault key  0      ensure count will be one of 0 1 2 3     map put key  count   1     And that s how you increment a value with simple code   Benefit    No need to add a new class or use another concept of mutable int Not relying on any library Easy to understand what s going on exactly  Not too much abstraction    Downside    The hash map will be searched twice for get   and put    So it will not be the most performant code     Theoretically  once you call get    you already know where to put    so you should not have to search again  But searching in hash map usually takes a very minimal time that you can kind of ignore this performance issue   But if you are very serious about the issue  you are a perfectionist  another way is to use merge method  this is  probably  more efficient than the previous code snippet as you will be  theoretically  searching the map only once   though this code is not obvious from first sight  it s short and performant   map merge key  1   a b  - gt  a b     Suggestion  you should care about code readability more than little performance gain in most of the time  If the first code snippet is easier for you to understand then use it  But if you are able to understand the 2nd one fine then you can also go for it

User · Answer

Vilmantas Baranauskas  Regarding this answer  I would comment if I had the rep points  but I don t   I wanted to note that the Counter class defined there is NOT thread-safe as it is not sufficient to just synchronize inc   without synchronizing value     Other threads calling value   are not guaranteed to see the the value unless a happens-before relationship has been established with the update

User · Answer

Google Collections HashMultiset    - quite elegant to use  - but consume CPU and memory  Best would be to have a method like   Entry lt K V gt  getOrPut K     elegant  and low cost   Such a method will compute hash and index only once  and then we could do what we want with the entry  either replace or update the value    More elegant   - take a HashSet lt Entry gt   - extend it so that get K  put a new Entry if needed  - Entry could be your own object  --   new MyHashSet    get k  increment

User · Answer

I d use Apache Collections Lazy Map  to initialize values to 0  and use MutableIntegers from Apache Lang as values in that map    Biggest cost is having to serach the map twice in your method  In mine you have to do it just once  Just get the value  it will get initialized if absent  and increment it

User · Answer

Are you sure that this is a bottleneck  Have you done any performance analysis   Try using the NetBeans profiler  its free and built into NB 6 1  to look at hotspots   Finally  a JVM upgrade  say from 1 5- 1 6  is often a cheap performance booster  Even an upgrade in build number can provide good performance boosts  If you are running on Windows and this is a server class application  use -server on the command line to use the Server Hotspot JVM  On Linux and Solaris machines this is autodetected

User · Answer

The Functional Java library s TreeMap datastructure has an update method in the latest trunk head   public TreeMap lt K  V gt  update final K k  final F lt V  V gt  f    Example usage   import static fj data TreeMap empty  import static fj function Integers add  import static fj pre Ord stringOrd  import fj data TreeMap   public class TreeMap Update    public static void main String   a       TreeMap lt String  Integer gt  map   empty stringOrd        map   map set  foo   1        map   map update  foo   add f 1         System out println map get  foo   some         This program prints  2

User · Answer

If you re using Eclipse Collections  you can use a HashBag  It will be the most efficient approach in terms of memory usage and it will also perform well in terms of execution speed   HashBag is backed by a MutableObjectIntMap which stores primitive ints instead of Counter objects  This reduces memory overhead and improves execution speed   HashBag provides the API you d need since it s a Collection that also allows you to query for the number of occurrences of an item   Here s an example from the Eclipse Collections Kata   MutableBag lt String gt  bag     HashBag newBagWith  one    two    two    three    three    three     Assert assertEquals 3  bag occurrencesOf  three      bag add  one    Assert assertEquals 2  bag occurrencesOf  one      bag addOccurrences  one   4   Assert assertEquals 6  bag occurrencesOf  one       Note  I am a committer for Eclipse Collections

User · Answer

As a follow-up to my own comment  Trove looks like the way to go  If  for whatever reason  you wanted to stick with the standard JDK  ConcurrentMap and AtomicLong can make the code a tiny bit nicer  though YMMV      final ConcurrentMap lt String  AtomicLong gt  map   new ConcurrentHashMap lt String  AtomicLong gt         map putIfAbsent  quot foo quot   new AtomicLong 0        map get  quot foo quot   incrementAndGet     will leave 1 as the value in the map for foo  Realistically  increased friendliness to threading is all that this approach has to recommend it

User · Answer

Vilmantas Baranauskas  Regarding this answer  I would comment if I had the rep points  but I don t   I wanted to note that the Counter class defined there is NOT thread-safe as it is not sufficient to just synchronize inc   without synchronizing value     Other threads calling value   are not guaranteed to see the the value unless a happens-before relationship has been established with the update

User · Answer

There are a couple of approaches    Use a Bag alorithm like the sets contained in Google Collections  Create mutable container which you can use in the Map          class My          String word          int count           And use put  word   new My  Word      Then you can check if it exists and increment when adding   Avoid rolling your own solution using lists  because if you get innerloop searching and sorting  your performance will stink  The first HashMap solution is actually quite fast  but a proper like that found in Google Collections is probably better   Counting words using Google Collections  looks something like this          HashMultiset s   new HashMultiset        s add  word        s add  word        System out println    s count  word          Using the HashMultiset is quite elegent  because a bag-algorithm is just what you need when counting words

User · Answer

It s always a good idea to look at the Google Collections Library for this kind of thing  In this case a Multiset will do the trick   Multiset bag   Multisets newHashMultiset    String word    foo   bag add word   bag add word   System out println bag count word       Prints 2   There are Map-like methods for iterating over keys entries  etc  Internally the implementation currently uses a HashMap lt E  AtomicInteger gt   so you will not incur boxing costs

User · Answer

As a follow-up to my own comment  Trove looks like the way to go  If  for whatever reason  you wanted to stick with the standard JDK  ConcurrentMap and AtomicLong can make the code a tiny bit nicer  though YMMV      final ConcurrentMap lt String  AtomicLong gt  map   new ConcurrentHashMap lt String  AtomicLong gt         map putIfAbsent  quot foo quot   new AtomicLong 0        map get  quot foo quot   incrementAndGet     will leave 1 as the value in the map for foo  Realistically  increased friendliness to threading is all that this approach has to recommend it

User · Answer

I think your solution would be the standard way  but - as you noted yourself - it is probably not the fastest way possible   You may look at GNU Trove  That is a library which contains all sorts of fast primitive Collections  Your example would use a TObjectIntHashMap which has a method adjustOrPutValue which does exactly what you want

User · Answer

You should be aware of the fact that your original attempt   int count   map containsKey word    map get word    0   contains two potentially expensive operations on a map  namely containsKey and get  The former performs an operation potentially pretty similar to the latter  so you re doing the same work twice   If you look at the API for Map  get operations usually return null when the map does not contain the requested element   Note that this will make a solution like  map put  key  map get key    1     dangerous  since it might yield NullPointerExceptions  You should check for a null first   Also note  and this is very important  that HashMaps can contain nulls by definition  So not every returned null says  there is no such element   In this respect  containsKey behaves differently from get in actually telling you whether there is such an element  Refer to the API for details   For your case  however  you might not want to distinguish between a stored null and  noSuchElement   If you don t want to permit nulls you might prefer a Hashtable  Using a wrapper library as was already proposed in other answers might be a better solution to manual treatment  depending on the complexity of your application   To complete the answer  and I forgot to put that in at first  thanks to the edit function    the best way of doing it natively  is to get into a final variable  check for null and put it back in with a 1  The variable should be final because it s immutable anyway  The compiler might not need this hint  but its clearer that way    final HashMap map   generateRandomHashMap    final Object key   fetchSomeKey    final Integer i   map get key   if  i    null        map put i   1     else          do something     If you do not want to rely on autoboxing  you should say something like map put new Integer 1   i getValue      instead

[java] Most efficient way to increment a Map value in Java

Examples related to java

Examples related to optimization

Examples related to collections