Trier un TreeMap basé sur le nombre de valeurs

Question

Je voudrais redéfinir le Comparateur comme la taille du HashSet, mais j'obtiens l'erreur que la méthode de comparaison doit surcharger ou implémenter une méthode super type.

Comment est-ce que je peux créer une TreeMap avec la comparaison de taille de Hashset?

private Map<Integer, HashSet<Integer>> nodes = new TreeMap<>(
    new Comparator(){ 
     @Override 
     public int compare(HashSet<Integer> o1 , HashSet<Integer> o2) {  
      return (o1.size()).compareTo(o2.size()); 
          //o2.size().compareTo(o1.size()); 
     } 
    }); 

Answer 1

Vous pouvez utiliser et écrire comparer Comparator code pour trier les valeurs en fonction de la taille de HashSet comme ci-dessous:

import java.util.Comparator; 
import java.util.HashMap; 
import java.util.HashSet; 
import java.util.Map; 
import java.util.TreeMap; 

public class Solution { 
    public static void main(String[] args) { 
     Map<String, HashSet<Integer>> map = new HashMap<String, HashSet<Integer>>(); 
     HashSet<Integer> aSet = new HashSet<>(); 
     aSet.add(1); 
     aSet.add(2); 
     aSet.add(3); 
     aSet.add(4); 
     aSet.add(5); 
     map.put("a", aSet); 
     HashSet<Integer> bSet = new HashSet<>(); 
     bSet.add(1); 
     bSet.add(2); 
     bSet.add(3); 
     bSet.add(4); 
     map.put("b", bSet); 
     HashSet<Integer> cSet = new HashSet<>(); 
     cSet.add(1); 
     cSet.add(2); 
     cSet.add(3); 
     cSet.add(4); 
     cSet.add(5); 
     cSet.add(6); 
     cSet.add(7); 
     map.put("c", cSet); 
     System.out.println(map); 

     Map sortedMap = sortByValue(map); 
     System.out.println(sortedMap); 
    } 

    public static Map sortByValue(Map unsortedMap) { 
     Map sortedMap = new TreeMap(new ValueComparator(unsortedMap)); 
     sortedMap.putAll(unsortedMap); 
     return sortedMap; 
    } 

} 

class ValueComparator implements Comparator { 
    Map map; 

    public ValueComparator(Map map) { 
     this.map = map; 
    } 

    public int compare(Object keyA, Object keyB) { 
     HashSet<Integer> valueA = (HashSet<Integer>) map.get(keyA); 
     HashSet<Integer> valueB = (HashSet<Integer>) map.get(keyB); 
     Integer valASize = valueA.size(); 
     Integer valBSize = valueB.size(); 
     return valASize.compareTo(valBSize); 
    } 
}