亚洲免费在线-亚洲免费在线播放-亚洲免费在线观看-亚洲免费在线观看视频-亚洲免费在线看-亚洲免费在线视频

Efficient Counter in Java

系統(tǒng) 1741 0

Reference: ?http://www.programcreek.com/2013/10/efficient-counter-in-java/

?
You may often need a counter to understand the frequency of something (e.g., words) from a database or text file. A counter can be easily implemented by using a HashMap in Java. This article compares different approaches to implement a counter. Finally, an efficient one will be concluded.

UPDATE: Check out? Java 8 counter , writing a counter is just 2 simple lines now.

1. The? Naive ?Counter

Naively, it can be implemented as the following:

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); }}

In each loop, you check if the key exists or not. If it does, increment the old value by 1, if not, set it to 1. This approach is simple and straightforward, but it is not the most efficient approach. This method is considered less efficient for the following reasons:

  • containsKey(), get() are called twice when a key already exists. That means searching the map twice.
  • Since Integer is immutable, each loop will create a new one for increment the old value

2. The? Better ?Counter

Naturally we want a mutable integer to avoid creating many Integer objects. A mutable integer class can be defined as follows:

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); }}

And the counter is improved and changed to the following:

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)); }}

This seems better because it does not require creating many Integer objects any longer. However, the search is still twice in each loop if a key exists.

3. The? Efficient ?Counter

The HashMap.put(key, value) method returns the key's current value. This is useful, because we can use the reference of the old value to update the value without searching one more time!

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. Performance Difference

To test the performance of the three different approaches, the following code is used. The performance test is on 1 million times. The raw results are as follows:

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

The difference is significant - 223 vs. 117 vs. 96. There is huge difference between? Naive ?and? Better , which indicates that creating objects are expensive!

String s = "one two three two three three";String[] sArr = s.split(" ");?long startTime = 0;long endTime = 0;long duration = 0;?// naive approachstartTime = 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 approachstartTime = 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 approachstartTime = 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);

When you use a counter, you probably also need a function to sort the map by value. You can check out? the frequently used method of HashMap .

5. Solutions from Keith

Added a couple tests:
1) Refactored "better approach" to just call get instead of containsKey. Usually, the elements you want are in the HashMap so that reduces from two searches to one.
2) Added a test with AtomicInteger, which michal mentioned.
3) Compared to singleton int array, which uses less memory according to http://amzn.com/0748614079

I ran the test program 3x and took the min to remove variance from other programs. Note that you can't do this within the program or the results are affected too much, probably due to gc.

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

Better Approach (without 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)); } }}

Better Approach (without containsKey, with 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)); } }}

Better Approach (without containsKey, with 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]++; } }}

Guava's MultiSet is probably faster still.

6. Conclusion

?

The winner is the last one which uses int arrays.

Efficient Counter in Java


更多文章、技術(shù)交流、商務(wù)合作、聯(lián)系博主

微信掃碼或搜索:z360901061

微信掃一掃加我為好友

QQ號(hào)聯(lián)系: 360901061

您的支持是博主寫(xiě)作最大的動(dòng)力,如果您喜歡我的文章,感覺(jué)我的文章對(duì)您有幫助,請(qǐng)用微信掃描下面二維碼支持博主2元、5元、10元、20元等您想捐的金額吧,狠狠點(diǎn)擊下面給點(diǎn)支持吧,站長(zhǎng)非常感激您!手機(jī)微信長(zhǎng)按不能支付解決辦法:請(qǐng)將微信支付二維碼保存到相冊(cè),切換到微信,然后點(diǎn)擊微信右上角掃一掃功能,選擇支付二維碼完成支付。

【本文對(duì)您有幫助就好】

您的支持是博主寫(xiě)作最大的動(dòng)力,如果您喜歡我的文章,感覺(jué)我的文章對(duì)您有幫助,請(qǐng)用微信掃描上面二維碼支持博主2元、5元、10元、自定義金額等您想捐的金額吧,站長(zhǎng)會(huì)非常 感謝您的哦!!!

發(fā)表我的評(píng)論
最新評(píng)論 總共0條評(píng)論
主站蜘蛛池模板: 99热精品在线免费观看 | 羞羞视频在线看 | 人人狠狠综合久久亚洲88 | 久久九九久精品国产 | 国产99精品免费视频看6 | 国产欧美在线观看视频 | 日韩欧美第一页 | 高清不卡一区二区 | 精品三区| 色综合久久中文色婷婷 | 日本一区二区三区中文字幕 | 久久国内 | 久久草国产 | 欧美一级二级aaa免费视频 | 开心激情五月婷婷 | 日韩欧美一区二区久久 | 情趣视频网站在线观看 | 色网站在线 | 免费观看黄a一级视频日本 免费观看黄色 | 免费高清在线影片一区 | 亚洲sss综合天堂久久久 | 免费观看视频成人国产 | 久久免费看 | 日韩a级片 | 综合久久99久久99播放 | 久久精品久久精品久久 | 亚洲在线高清 | 亚洲色图国产精品 | 国产在线看不卡一区二区 | 亚洲国产欧美精品 | 九九热线有精品视频99 | 国产精品久久久久久一区二区 | 日韩毛片基地一区二区三区 | 人人澡人人干 | 亚洲国产高清视频 | 日韩精品国产自在久久现线拍 | h网站国产 | 99热久久这里只有精品 | 亚洲国产一区二区三区 | 天天综合天天做 | 在线播放69热精品视频 |