Simple-Java—Collections（一）Java高效计数器

Translate from Efficient Counter in Java

Java中的高效计数器

你可能经常需要统计一段文本或数据库中某些东西（例如单词）的出现频率。在Java中，使用HashMap可以很简单的实现这么一个计数器。
这篇文章将会比较几种实现计数器的方法，最后，得出最有效率的一个。

1. 简单计数器

String s = "one two three two three three";
String[] sArr = s.split(" ");

//naive approach     
HashMap<String, Integer> counter = new HashMap<String, Integer>();

for (String a : sArr) {
    if (counter.containsKey(a)) {
        int oldValue = counter.get(a);
        counter.put(a, oldValue + 1);
    } else {
        counter.put(a, 1);
    }
}

每次循环，检查map中是否已经有该字符，如果有则value+1；如果没有，则放入map,把value置为1；
这种方法很简单，但是效率不够，体现在以下两点：

• 当key值已经存在时，调用了两次方法：containsKey()、get()，这意味着要在map中检索两次
• 由于Integer是不可变的，每个循环增加key的value时会创建一个新的对象
  
  

2. 优化计数器

为了避免Integer的“不可变”带来的重新创建对象的问题，我们创建一个“可变”的Integer对象：

class MutableInteger {

    private int val;

    public MutableInteger(int val) {
        this.val = val;
    }

    public int get() {
        return val;
    }

    public void set(int val) {
        this.val = val;
    }

    //used to print value convinently
    public String toString(){
        return Integer.toString(val);
    }
}

通过这个可变的Integer对象，改进后的计数器代码如下：

HashMap<String, MutableInteger> newCounter = new HashMap<String, MutableInteger>(); 

for (String a : sArr) {
    if (newCounter.containsKey(a)) {
        MutableInteger oldValue = newCounter.get(a);
        oldValue.set(oldValue.get() + 1);
    } else {
        newCounter.put(a, new MutableInteger(1));
    }
}

优化了两个地方：

1. 每次value+1时不需要重新创建Integer对象了
2. 改变value值不需要重新put()进去

但是，这个方法仍然进行了两次检索

3. 高效计数器

由于 HashMap.put(key, value)方法会返回这个key值原有的value，我们可以利用这一点避免两次检索
（译者注：但是每次循环又增加了一个对象创建的开销）

HashMap<String, MutableInteger> efficientCounter = new HashMap<String, MutableInteger>();

for (String a : sArr) {
    MutableInteger initValue = new MutableInteger(1);
    MutableInteger oldValue = efficientCounter.put(a, initValue);

    if(oldValue != null){
        initValue.set(oldValue.get() + 1);
    }
}

4. 三种方法的效率表现

为了体现三种方法的效率，通过代码循环了一百万次进行测试，结果如下：

Naive Approach : 222796000
Better Approach: 117283000
Efficient Approach: 96374000

结果可以近似表达为：223:117:96，简单计数器和优良计数器之间的差距很大，这证明了创建对象的时间花费很大！

String s = "one two three two three three";
String[] sArr = s.split(" ");

long startTime = 0;
long endTime = 0;
long duration = 0;

// naive approach
startTime = System.nanoTime();
HashMap<String, Integer> counter = new HashMap<String, Integer>();

for (int i = 0; i < 1000000; i++)
    for (String a : sArr) {
        if (counter.containsKey(a)) {
            int oldValue = counter.get(a);
            counter.put(a, oldValue + 1);
        } else {
            counter.put(a, 1);
        }
    }

endTime = System.nanoTime();
duration = endTime - startTime;
System.out.println("Naive Approach :  " + duration);

// better approach
startTime = System.nanoTime();
HashMap<String, MutableInteger> newCounter = new HashMap<String, MutableInteger>();

for (int i = 0; i < 1000000; i++)
    for (String a : sArr) {
        if (newCounter.containsKey(a)) {
            MutableInteger oldValue = newCounter.get(a);
            oldValue.set(oldValue.get() + 1);
        } else {
            newCounter.put(a, new MutableInteger(1));
        }
    }

endTime = System.nanoTime();
duration = endTime - startTime;
System.out.println("Better Approach:  " + duration);

// efficient approach
startTime = System.nanoTime();

HashMap<String, MutableInteger> efficientCounter = new HashMap<String, MutableInteger>();

for (int i = 0; i < 1000000; i++)
    for (String a : sArr) {
        MutableInteger initValue = new MutableInteger(1);
        MutableInteger oldValue = efficientCounter.put(a, initValue);

        if (oldValue != null) {
            initValue.set(oldValue.get() + 1);
        }
    }

endTime = System.nanoTime();
duration = endTime - startTime;
System.out.println("Efficient Approach:  " + duration);

5. Keith网站上的更好方法

增加了三个测试：

1. 重构优良计数器，用get方法取代了containKey，这样HashMap里面的两次检索减成了一个
2. 取消自定义可变类型的Integer类，用Java中的AtomicInteger
3. 根据How to Do Text Analysis with Java 一书，value改为用单个int数组存储，可使用更少内存。

下面是对比结果。我运行测试案例三次，为避免其他程序的影响，取三次结果中最小值。注意，你不能让你的程序受到太多影响。例如内存不足会让垃圾回收机制器进行回收。

Naive: 201716122
Better Approach: 112259166
Efficient Approach: 93066471
Better Approach (without containsKey): 69578496
Better Approach (without containsKey, with AtomicInteger): 94313287
Better Approach (without containsKey, with int[]): 65877234

以下是代码：

更好的方法（取消使用containsKey）:

HashMap<String, MutableInteger> efficientCounter2 = new HashMap<String, MutableInteger>();
for (int i = 0; i < NUM_ITERATIONS; i++) {
    for (String a : sArr) {
        MutableInteger value = efficientCounter2.get(a);

        if (value != null) {
            value.set(value.get() + 1);
        } else {
            efficientCounter2.put(a, new MutableInteger(1));
        }
    }
}

更好的方法（取消使用containsKey，用AtomicInteger）:

HashMap<String, AtomicInteger> atomicCounter = new HashMap<String, AtomicInteger>();
for (int i = 0; i < NUM_ITERATIONS; i++) {
    for (String a : sArr) {
        AtomicInteger value = atomicCounter.get(a);

        if (value != null) {
            value.incrementAndGet();
        } else {
            atomicCounter.put(a, new AtomicInteger(1));
        }
    }
}

更好的方法（取消使用containsKey，用int[]）:

HashMap<String, int[]> intCounter = new HashMap<String, int[]>();
for (int i = 0; i < NUM_ITERATIONS; i++) {
    for (String a : sArr) {
        int[] valueWrapper = intCounter.get(a);

        if (valueWrapper == null) {
            intCounter.put(a, new int[] { 1 });
        } else {
            valueWrapper[0]++;
        }
    }
}

6. 结论

从图可以看出，最终胜利者是最后一个使用int[]数组的方法

参考：
1.Most efficient way to increment a Map value in Java.
2.HashMap.put()

7. 译者补充

这里进一步对高效计数器和改进版的高效计数器进行一下对比

测试字符串”one two three two three three”，都采用int[]数组存储

• 原本高效计数器：去除了两次检索，但每次循环都声明了一个新对象

for (String string : sArray) {
    int[] n=new int[]{1};
    int[] num = map.put(string,n);
    if (num != null)
        n[0]=++num[0];
}

• Keith网站改进版：需要一次检索，但没有声明多余的对象

for (String  key: sArray) {
    int[] n=map.get(key);
    if(n==null)
        map.put(key, new int[]{1});
    else
        n[0]++;
}

三次运行得出最终耗时结果

48396425
26244898

在这个例子我们似乎可以看出，依旧是改进版的计数器更高效。

但如果把字符串延长10倍，再次运行

21581658187
22019343923

此时两种方法时间花费特别接近，如果把字符串继续延长，改进版的效率则不一定比原来的高。

所以这里得出我的结论：

没有最高效的计数器，只有最合适的计数器。在字符串比较小的情况下，本文末尾结论的计数器最高效。但字符串增加， HashMap检索代价增加的情况下，则第一种高效计数器更好。