统计列表中字符串的出现次数，排序和提取仅在Java中排名前1000位

Question

我遇到了问题。

我有一个包含事件名称的大型Java String列表（约100K条目）。

它是这样的：

List<String> myList = new ArrayList<>(); 
myList.add("eventB"); 
myList.add("eventB"); 
myList.add("eventA"); 
myList.add("eventB"); 
myList.add("eventA"); 
myList.add("eventA"); 
myList.add("eventA"); 
myList.add("eventB"); 
myList.add("eventB"); 
myList.add("eventC"); 
myList.add("eventD"); 
myList.add("eventC"); 
... 

我需要一种方法来计算每一个事件的发生，选择顶部1000事件及其发生。我不知道所有的事件的名字......我已经得到了大约1000种不同的事件名称..

我的输出应该是这样的：

    ___ 
_________________ | 
| EventName | # | | 
|___________|_____| | 
| eventB | 609 | | 
| eventC | 542 | | 
| eventD | 540 | | 
| eventA | 463 | \ top 1000 
| .  | . |/entry 
| .  | . | | 
| .  | . | | 
| eventN | 123 | | 
|___________|_____| | 
       ___| 

我需要eventName的和整数的字符串（＃）。 （我会放他们之后到Web应用程序的HTML表格）

我尝试了这种方式：

Map<String,Integer> myMap = new HashMap<String, Integer>(); 
for(String evnt : myList){ 
    if(!myMap.containsKey(evnt)) 
     myMap.put(evnt,1); 
    else{ 
     myMap.put(evnt, myMap.get(evnt)+1); 
    } 
} 

但现在我不知道怎么样呢..

Answer 1

检查下面的代码存储事件的数量在地图

public static void main(String[] args) { 
    List<String> myList = new ArrayList<>(); 
    myList.add("eventB"); 
    myList.add("eventB"); 
    myList.add("eventA"); 
    myList.add("eventB"); 
    myList.add("eventA"); 
    myList.add("eventA"); 
    myList.add("eventA"); 
    myList.add("eventA"); 
    myList.add("eventA"); 
    myList.add("eventC"); 
    myList.add("eventD"); 
    myList.add("eventC"); 
    Map<String, Integer> countEventMap = new HashMap<String, Integer>(); 
    for (String event : myList) { 
     if (countEventMap.get(event) != null) { 
      countEventMap.put(event, countEventMap.get(event) + 1); 
     } else 
      countEventMap.put(event, 1); 
    } 

} 

我们获得最高1000您有一个基于价值进行排序，参考Sorting HashMap by values

为了提高性能，你可以使用并发性，请检查此链接Data inconsistency using ConcurrentHashMap，您可以修改该链接以访问列表，其中每个线程从特定索引开始并在某处结束。

Answer 2

使用

Map<Key,List <String>> 

活动将是你的关键

Answer 3

循环每一个元素，得到字符串名称，将其添加到了h地图或将其当前值增加1.

HashMap<String, Integer> map = new HashMap<String, Integer>(); 
for (String s : list) { 
    if (map.containsKey(s)) { 
     map.put(s, map.get(s) + 1); 
    } else { 
     map.put(s, 1); 
    } 
} 

可能不是最有效的方法，但它会以您指定的方式工作并存储它们。之后，你需要对其进行分类，但我会让你弄清楚。

Answer 4

你需要做的是在三个步骤

1. 计数事件的发生都。
2. 按价值排序事件。
3. 切片top n事件。

下面的代码：

的

import java.util.ArrayList; 
import java.util.Comparator; 
import java.util.HashMap; 
import java.util.Iterator; 
import java.util.List; 
import java.util.Map; 
import java.util.Set; 
import java.util.TreeMap; 

public class TopEventCount { 

    public static void main(String[] args) { 
     List<String> myList = getAllEvents(); 
     Map<String, Integer> unsortedMap = countEvents(myList); 
     System.out.println("Unsorted Map :: " + unsortedMap); 
     Map<String, Integer> sortedMap = sortMapByValue(unsortedMap); 
     System.out.println("sorted Map :: " + sortedMap); 

     List<String> topEvents = top(2, sortedMap); 
     System.out.println("Top Event :: "+topEvents); 
    } 

    private static List<String> top(int topElements, Map<String, Integer> sortedMap) { 
     List<String> topEvents = new ArrayList<String>(); 
     Set<String> allEvents = sortedMap.keySet(); 

     Iterator<String> itr = allEvents.iterator(); 
     int count = 0; 
     while(itr.hasNext() && count < topElements) { 
      topEvents.add(itr.next()); 
      count++; 
     } 
     return topEvents; 
    } 

    private static Map<String, Integer> sortMapByValue(
      Map<String, Integer> unsortedMap) { 
     ValueComparator bvc = new ValueComparator(unsortedMap); 
     TreeMap<String, Integer> sortedMap = new TreeMap<String, Integer>(bvc); 
     sortedMap.putAll(unsortedMap); 
     return sortedMap; 
    } 

    private static Map<String, Integer> countEvents(List<String> myList) { 
     Map<String, Integer> myMap = new HashMap<String, Integer>(); 
     for (String evnt : myList) { 
      if (!myMap.containsKey(evnt)) 
       myMap.put(evnt, 1); 
      else { 
       myMap.put(evnt, myMap.get(evnt) + 1); 
      } 
     } 
     return myMap; 
    } 

    private static List<String> getAllEvents() { 
     List<String> myList = new ArrayList<>(); 
     myList.add("eventB"); 
     myList.add("eventB"); 
     myList.add("eventA"); 
     myList.add("eventB"); 
     myList.add("eventA"); 
     myList.add("eventA"); 
     myList.add("eventA"); 
     myList.add("eventB"); 
     myList.add("eventB"); 
     myList.add("eventC"); 
     myList.add("eventD"); 
     myList.add("eventC"); 
     myList.add("eventE"); 

     return myList; 
    } 
} 

class ValueComparator implements Comparator<String> { 

    Map<String, Integer> base; 

    public ValueComparator(Map<String, Integer> base) { 
     this.base = base; 
    } 

    // Note: this comparator imposes orderings that are inconsistent with 
    // equals. 
    public int compare(String a, String b) { 
     if (base.get(a) >= base.get(b)) { 
      return -1; 
     } else { 
      return 1; 
     } // returning 0 would merge keys 
    } 
} 

所有的代码是自我解释。下面是输出：

未排序地图:: {eventA = 4，田赛= 1，eventD = 1，eventC = 2，eventB = 5}

排序地图:: {eventB = 5，eventA = 4，eventC = 2，eventD = 1，田赛= 1}

顶部2事件:: [eventB，eventA]