内存旋转在这里可能是一个问题，因为对大于或等于128的int进行装箱都会导致对象分配(参见Integer.valueOf(int))。尽管垃圾收集器非常有效地处理存在时间很短的对象，但性能会在一定程度上受到影响。

如果您知道增量的数量将大大超过键的数量(在本例中为=words)，请考虑使用int holder。Phax已经为此提供了代码。这里又是一次，有两个变化(holder类是静态的，初始值设置为1):

static class MutableInt {
  int value = 1;
  void inc() { ++value; }
  int get() { return value; }
}
...
Map<String,MutableInt> map = new HashMap<String,MutableInt>();
MutableInt value = map.get(key);
if (value == null) {
  value = new MutableInt();
  map.put(key, value);
} else {
  value.inc();
}

如果需要极致的性能，请寻找直接针对基本值类型定制的Map实现。jrudolph提到了GNU Trove。

顺便说一下，这个主题的一个很好的搜索词是“直方图”。

各种原语包装器(例如Integer)都是不可变的，因此实际上没有更简洁的方法来实现您的要求，除非您可以使用AtomicLong之类的东西来实现。我可以在一分钟内进行更新。顺便说一下，哈希表是集合框架的一部分。

有几种方法:

使用袋子算法，比如谷歌集合中包含的集合。 创建可变容器，你可以在Map中使用:

    class My{
        String word;
        int count;
    }

并使用put(“word”，new My(“word”));然后您可以检查它是否存在，并在添加时增加。

避免使用列表来滚动您自己的解决方案，因为如果您使用内循环搜索和排序，您的性能将会非常糟糕。第一个HashMap解决方案实际上相当快，但在谷歌Collections中找到的合适的解决方案可能更好。

使用谷歌集合计数单词，看起来像这样:

    HashMultiset s = new HashMultiset();
    s.add("word");
    s.add("word");
    System.out.println(""+s.count("word") );

使用HashMultiset是非常优雅的，因为在计数单词时，袋算法正是您所需要的。

番石榴是你的朋友…

.．.至少在某些情况下是这样。他们有这个很好的AtomicLongMap。特别好，因为你在地图上处理的是长值。

E.g.

AtomicLongMap<String> map = AtomicLongMap.create();
[...]
map.getAndIncrement(word);

也可以在值上增加多于1的值:

map.getAndAdd(word, 112L); 

部分测试结果

对于这个问题，我已经得到了很多很好的答案——谢谢大家——所以我决定进行一些测试，找出哪种方法实际上是最快的。我测试的五个方法是:

我在问题中提到的“ContainsKey”方法 Aleksandar Dimitrov建议的“TestForNull”方法 Hank Gay建议的“AtomicLong”方法 即鲁道夫提出的“宝藏”方法 phax.myopenid.com建议的“MutableInt”方法

方法

我是这么做的……

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.

结果

我将首先展示结果，并为感兴趣的人提供下面的代码。

正如预期的那样，ContainsKey方法是最慢的，因此我将给出每个方法的速度与该方法的速度的比较。

ContainsKey: 30.654秒(基线) AtomicLong: 29.780秒(速度的1.03倍) TestForNull: 28.804秒(1.06倍) Trove: 26.313秒(快1.16倍) MutableInt: 25.747秒(1.19倍)

结论

似乎只有MutableInt方法和Trove方法明显更快，因为只有它们的性能提升超过10%。然而，如果线程是一个问题，AtomicLong可能比其他的更有吸引力(我不确定)。我还用final变量运行了TestForNull，但是差别可以忽略不计。

注意，我没有分析不同场景中的内存使用情况。我很高兴听到任何人对MutableInt和Trove方法如何可能影响内存使用有很好的见解。

就我个人而言，我觉得MutableInt方法最有吸引力，因为它不需要加载任何第三方类。因此，除非我发现它有问题，否则我很可能会走这条路。

的代码

下面是每个方法的关键代码。

ContainsKey

import java.util.HashMap;
import java.util.Map;
...
Map<String, Integer> freq = new HashMap<String, Integer>();
...
int count = freq.containsKey(word) ? freq.get(word) : 0;
freq.put(word, count + 1);

测试空

import java.util.HashMap;
import java.util.Map;
...
Map<String, Integer> freq = new HashMap<String, Integer>();
...
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<String, AtomicLong> map = 
    new ConcurrentHashMap<String, AtomicLong>();
...
map.putIfAbsent(word, new AtomicLong(0));
map.get(word).incrementAndGet();

宝库

import gnu.trove.TObjectIntHashMap;
...
TObjectIntHashMap<String> freq = new TObjectIntHashMap<String>();
...
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<String, MutableInt> freq = new HashMap<String, MutableInt>();
...
MutableInt count = freq.get(word);
if (count == null) {
    freq.put(word, new MutableInt());
}
else {
    count.increment();
}

你确定这是瓶颈吗?你做过性能分析吗?

尝试使用NetBeans分析器(它是免费的，内置在NB 6.1中)来查看热点。

最后，JVM升级(比如从1.5升级到>1.6)通常是一种廉价的性能增强。即使是版本号的升级也能提供良好的性能提升。如果您在Windows上运行，并且这是一个服务器类应用程序，请在命令行上使用-server来使用server Hotspot JVM。在Linux和Solaris机器上，这是自动检测到的。