我希望这个问题不被认为是对这个论坛太基础，但我们会看到的。我想知道如何重构一些代码以获得更好的性能，因为它会运行很多次。
假设我正在创建一个单词频率列表，使用Map（可能是HashMap），其中每个键都是包含计数的单词的字符串，值是每次找到该单词的令牌时递增的整数。
在Perl中，增加这样的值将非常容易：
$map{$word}++;
但是在Java中，这个过程要复杂得多。以下是我目前正在使用的方法：
int count = map.containsKey(word) ? map.get(word) : 0;
map.put(word, count + 1);
有了Java 8，现在有一种更短的方式，可以使用Map::merge。
myMap.merge(key, 1, Integer::sum)
myMap.merge(key, 1L, Long::sum)
分别针对long的情况。
它的作用：
更多信息请参见此处。
map.merge(key, 1, (a, b) -> a + b);有效。 - russterInteger::sum作为BiFunction，并且不喜欢@russter所给出的答案的写法。以下代码对我有效：
Map.merge(key, 1, { a, b -> a + b}) - jookyoneInteger实例，因此不会创建新对象。对于超过这个值的数值，是否创建新对象取决于运行时。相比之下，使用可变对象总是需要为每个键创建一个独立的新对象。因此，不要对性能作出一般性陈述。性能取决于键的数量和每个键的平均递增次数。 - Holger我得到了很多关于这个问题的好答案——感谢大家——所以我决定运行一些测试，找出哪种方法实际上是最快的。我测试过的五种方法是：
以下是我的做法...
我会先呈现结果，然后是下面有兴趣的人的代码。
ContainsKey方法是最慢的，这是预料之中的，因此我将给出每种方法相对于该方法的速度。
看起来只有MutableInt方法和Trove方法显着更快，因为它们提供了超过10％的性能提升。但是，如果线程是一个问题，AtomicLong可能比其他方法更具吸引力（我不太确定）。我还使用final变量运行了TestForNull，但差异微不足道。
请注意，我没有在不同场景下分析内存使用情况。我很乐意听取任何对MutableInt和Trove方法如何影响内存使用的见解。
就我个人而言，我觉得MutableInt方法最具吸引力，因为它不需要加载任何第三方类。所以，除非我发现它存在问题，否则我最有可能采用这种方法。
以下是每种方法的关键代码。
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);
}
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);
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();
}
freq.compute(word, (key, count) -> count == null ? 1 : count + 1) 吗？内部比 containsKey 少进行了一次哈希查找，因为lambda表达式的原因，很有意思可以看看它与其他方法的比较结果。 - TWiStErRobfreq.merge(word, 1, Integer::sum)。 - 4castle2016年的一项小研究：https://github.com/leventov/java-word-count，基准源代码
每种方法的最佳结果（越小越好）：
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
时间结果：
Map<String, Integer> map = new HashMap<>();
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);
这就是如何使用简单代码增加一个值。
优点：
缺点：
在理论上，一旦调用get()，您已经知道要放置的位置，因此不应再搜索。但通常在哈希映射中搜索只需要极少的时间，您可以忽略这个性能问题。
但是，如果您非常重视这个问题，您是一个完美主义者，另一种方法是使用merge方法，这可能比以前的代码片段更有效，因为您将（理论上）仅搜索一次map：（尽管这段代码乍一看不明显，但它很短且高效）
map.merge(key, 1, (a,b) -> a+b);
建议: 大多数时候，你应该更注重代码可读性，而不是追求微小的性能提升。如果第一个代码片段更容易理解，那就使用它。但是，如果您可以理解第二个代码片段，那么也可以选择使用它！
针对我的评论，推荐使用Trove。如果由于某种原因，您想坚持使用标准JDK，ConcurrentMap和AtomicLong可以使代码变得更易读，但具体情况因人而异。
final ConcurrentMap<String, AtomicLong> map = new ConcurrentHashMap<String, AtomicLong>();
map.putIfAbsent("foo", new AtomicLong(0));
map.get("foo").incrementAndGet();
这种方法只会将 foo 的映射值保留为 1。实际上，它的优点只是更友好地支持多线程。
AtomicLong传递给putIfAbsent以及方法的返回值，接着使用正确的值进行增量。当然，自从Java 8以来，使用map.computeIfAbsent("foo", key -> new AtomicLong(0)) .incrementAndGet();甚至更简单了... - Holger...至少在某些情况下。他们拥有这个很棒的AtomicLongMap。特别棒的原因是你的映射中使用了long类型的值。
例如：
AtomicLongMap<String> map = AtomicLongMap.create();
[...]
map.getAndIncrement(word);
也可以将超过1的值添加到该值中：
map.getAndAdd(word, 112L);
AtomicLongMap#getAndAdd 方法使用原始类型 long 而不是包装类，使用 new Long() 没有任何意义。另外，AtomicLongMap 是一个泛型类型；你应该将它声明为 AtomicLongMap<String>。 - Helder Pereiramultiset 的 count() 方法在最坏情况下的时间复杂度是 O(1) 还是 O(n)？文档对此并没有明确说明。 - Adam Parkin请注意，您最初的尝试
int count = map.containsKey(word) ? map.get(word) : 0;
包含对映射执行两个潜在昂贵操作，即containsKey和get。前者执行的操作与后者可能非常相似，因此您做了相同的工作两次！
如果您查看Map的API，get操作通常在地图不包含请求的元素时返回null。
请注意，这将使像下面这样的解决方案变得危险
map.put(key, map.get(key)+1);
因为它可能会产生NullPointerException。您应该首先检查是否为null。
还要注意，这非常重要，HashMap根据定义可以包含nulls。因此，不是每个返回的null都表示“没有这样的元素”。在这方面，containsKey的行为与get不同，实际上告诉您是否有这样的元素。有关详细信息，请参阅API。
但是，对于您的情况，您可能不想区分存储的null和“noSuchElement”。如果您不想允许null，则可能更喜欢Hashtable。对于手动处理，使用已经提出的包装库可能是更好的解决方案，具体取决于您的应用程序的复杂性。
final HashMap map = 生成随机HashMap();
final Object key = 获取某些Key();
final Integer i = map.get(key);
if (i != null) {
map.put(i + 1);
} else {
// 做点什么
}
如果您不想依赖自动装箱，可以像这样说：map.put(new Integer(1 + i.getValue()));。另一种方法是创建一个可变整数：
class MutableInt {
int value = 0;
public void inc () { ++value; }
public 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 ();
}
当然，这意味着创建一个额外的对象，但与创建一个整数相比（即使使用Integer.valueOf），开销不应该太大。
inc设为final在理论上可以提供可衡量的好处。 - Davis Herring你可以在Java 8中提供的Map接口中使用computeIfAbsent方法。
final Map<String,AtomicLong> map = new ConcurrentHashMap<>();
map.computeIfAbsent("A", k->new AtomicLong(0)).incrementAndGet();
map.computeIfAbsent("B", k->new AtomicLong(0)).incrementAndGet();
map.computeIfAbsent("A", k->new AtomicLong(0)).incrementAndGet(); //[A=2, B=1]
computeIfAbsent方法检查指定的键是否已经与值相关联。如果没有关联的值，则尝试使用给定的映射函数计算其值。无论如何，它都返回与指定键相关联的当前值（现有或计算的），如果计算出的值为空，则返回null。
另外，如果您遇到多个线程更新公共总和的情况，可以查看LongAdder类。在高争用率下，该类的预期吞吐量比AtomicLong高得多，但代价是更高的空间消耗。
Map::computeIfAbsent及其相关方法。 - Brian Goetz