сравнения и сортировки ArrayList значений в HashMap Java

Question

У меня есть HashMap

Map<String, ArrayList<String>> games = new hashmap<String, Arraylist<String>>(); 

содержит имя в качестве ключа и список игр, как значения. так:

A= [ cricket, soccer, tennis, baseball] 
B= [soccer, badminton, rugby] 
C= [cricket, badminton] 
D= [rugby, cricket, soccer] 
E= [cricket, baseball] 
F= [tennis, rugby] 

теперь я хочу, чтобы подсчитать вхождение каждого значения (criket, футбол и т.д.) и Назначают только одно значение для ключа на основе совпадения значений. здесь, крикет произошел 4 раза, футбол произошел 3 раза и так далее. И сравните значения каждой клавиши и проверьте, сколько раз было сколько раз. Затем я хочу присвоить значение с максимальным вступлением. что я хочу иметь HashMap, который будет выглядеть следующим образом:

A= [ cricket] // because among its 4 values, cricket has occured maximum times. 
B= [soccer] // among its 3 values, soccer has occured maximum times. 
C= [cricket] 
D= [cricket] 
E= [cricket] 
F= [rugby] // among its 2 values, rugby has occured maximum times which is 3. 

И так далее ... я понятия не имею, о том, как справиться с этой ситуацией. Поэтому, пожалуйста, помогите мне в этом, и предоставит подробную информацию. спасибо

Answer 1

Предположим, что этот алгоритм может помочь вам.

public void testAlgorithm(){ 
     Map<String, List<String>> map = this.generateDatasource(); 
     Map<String, Integer> numberMap = this.calculateHappeds(map); 
     Map<String, String> rstMap = new HashMap<String, String>(); 
     for (String key : map.keySet()) { 
      List<String> sports = map.get(key); 
      Integer index = 0; 
      for (int i = 0; i < sports.size(); i++) { 
       if (numberMap.get(sports.get(i)) > numberMap.get(sports.get(index))) { 
        index = i; 
       } 
      } 
      rstMap.put(key, sports.get(index)); 
     } 
     for (String key : rstMap.keySet()) { 
      System.out.println(key + " = " + " [ " + rstMap.get(key) + " ]"); 
     } 
    } 

    private Map<String, Integer> calculateHappeds(Map<String, List<String>> map) { 
     Map<String, Integer> calculate = new HashMap<String, Integer>(); 
     for (String key : map.keySet()) { 
      List<String> sports = map.get(key); 
      for (String sport : sports) { 
       if (calculate.containsKey(sport)) { 
        Integer count = calculate.get(sport); 
        count += 1; 
        calculate.put(sport, count); 
       }else { 
        calculate.put(sport,1); 
       } 
      } 
     } 
     return calculate; 
    } 

    private Map<String, List<String>> generateDatasource() { 
     Map<String, List<String>> map = new HashMap<String, List<String>>(); 
     List<String> a = new ArrayList<String>(); 
     a.add("cricket"); 
     a.add("soccer"); 
     a.add("tennis"); 
     a.add("baseball"); 
     map.put("A", a); 

     List<String> b = new ArrayList<String>(); 
     b.add("soccer"); 
     b.add("badminton"); 
     b.add("rugby"); 
     map.put("B", b); 

     List<String> c = new ArrayList<String>(); 
     c.add("cricket"); 
     c.add("badminton"); 
     map.put("C", c); 

     List<String> d = new ArrayList<String>(); 
     d.add("rugby"); 
     d.add("cricket"); 
     d.add("soccer"); 
     map.put("D", d); 

     List<String> e = new ArrayList<String>(); 
     e.add("cricket"); 
     e.add("baseball"); 
     map.put("E", e); 

     List<String> f = new ArrayList<String>(); 
     f.add("tennis"); 
     f.add("rugby"); 
     map.put("F", f); 
     return map; 
    } 

потому что rstMap является карта, поэтому выход

D = [ cricket ] 
E = [ cricket ] 
F = [ rugby ] 
A = [ cricket ] 
B = [ soccer ] 
C = [ cricket ] 

Answer 2

Я бы сказал, что ваш самый простой способ создать класс, который расширяет свою реализацию targetMap (HashMap в данном случае). В новом классе сохраните вторую карту для каждого из своих значений в Integer, которая хранит количество значений в вашем ArrayList. Затем переопределите методы #clear(), #put(), #putAll() и #remove() для управления вашей второй картой. Для Ex:

SHashMap extends HashMap<String, ArrayList<String>>{ 
    HashMap<String,Integer> valMap; 

    public void put(String key, ArrayList<String> vals){ 
    for(String s: vals){ 
     if(valMap.containsKey(s)){ 
      valMap.put(s,valMap.get(s)+1); 
     }else{ 
      valMap.put(s,1); 
     } 
    } 
    return super.put(key,vals); // Keep the hierarchy accurate 
    } 
} 

Затем, просто добавьте метод простой getMax (String), который проверяет valMap на один с наибольшим кол:

public String getMax(String key){ 
    String max = null; 
    int countMax =0; 
    for(String val:get(key)){ 
     if(valMap.get(val) > countMax){ 
      countMax = valMap.get(val); 
      max = val; 
     } 
    } 
    return max; 
} 

Реализовать в #clear, #putAll и #remove методы для надлежащей корректировки данных в valMap, как того требуют ваши потребности и использование. В зависимости от вашего использования существует несколько способов сделать это более эффективным, но это должно помочь вам в дороге.

Answer 3

public class CountMap { 

/* data 
    A= [ cricket, soccer, tennis, baseball] 
    B= [soccer, badminton, rugby] 
    C= [cricket, badminton] 
    D= [rugby, cricket, soccer] 
    E= [cricket, baseball] 
    F= [tennis, rugby]*/ 

    public CountMap(){} 

    private static Map<String,List<String>> testDdata= new HashMap<>(); 
    private static Map<String,Integer> sportsCoount= new HashMap<>(); 


    public static void main(String[] args){ 

     //prepare test data 
     prepareTestData(); 

     prepareOutputMap(); 
    } 

    private static void prepareOutputMap() { 

     // sportsCoountMap is ready now 
     for(String key:testDdata.keySet()){ 
      List<String> valueList= testDdata.get(key); 

      for(String testValue:valueList){ 
       Integer value=sportsCoount.get(testValue); 
       if(value!=null){ 
        value++; 
        sportsCoount.put(testValue,value); 
       }else{ 
        value=1; 
        sportsCoount.put(testValue, value); 
       } 
      } 
     } 

     PriorityQueue<Entry<String, Integer>> pq = new PriorityQueue<Map.Entry<String,Integer>>(sportsCoount.size(), new Comparator<Entry<String, Integer>>() { 

      @Override 
      public int compare(Entry<String, Integer> arg0, 
        Entry<String, Integer> arg1) { 
       return arg1.getValue().compareTo(arg0.getValue()); 
      } 
     }); 
     pq.addAll(sportsCoount.entrySet()); 
     /*while (!pq.isEmpty()) { 
      System.out.println(pq.poll()); 
     }*/ 

     Entry<String,Integer> entry; 

     List<String> keyList= new ArrayList<String>(); 
     keyList.addAll(testDdata.keySet()); 

     Collections.sort(keyList); 
     for(String key:keyList){ 
      entry= pq.poll(); 
      System.out.println(key+"="+entry.getKey()); 
     } 

    } 

    private static void prepareTestData() { 
     List<String> data1= new ArrayList<>(); 
     //cricket, soccer, tennis, baseball 
     data1.add("cricket"); 
     data1.add("soccer"); 
     data1.add("tennis"); 
     data1.add("baseball"); 
     testDdata.put("A", data1); 

     List<String> data2= new ArrayList<>(); 
     //soccer, badminton, rugby 
     data2.add("soccer"); 
     data2.add("badminton"); 
     data2.add("rugby"); 
     testDdata.put("B", data2); 

     List<String> data3= new ArrayList<>(); 
     //cricket, badminton 
     data3.add("cricket"); 
     data3.add("badminton"); 
     testDdata.put("C", data3); 

     List<String> data4= new ArrayList<>(); 
     //rugby, cricket, soccer 
     data4.add("rugby"); 
     data4.add("cricket"); 
     data4.add("soccer"); 
     testDdata.put("D", data4); 

     List<String> data5= new ArrayList<>(); 
     //cricket, baseball 
     data5.add("cricket"); 
     data5.add("baseball"); 
     testDdata.put("E", data5); 


    } 
} 

> OutPut:- 
> 
> A=cricket 
> B=soccer 
> C=rugby 
> D=baseball 
> E=badminton