Comment trier un HashMap en Java

Question

Comment pouvons-nous trier un HashMap<key, ArrayList> ?

Je veux trier sur la base d'une valeur dans le champ ArrayList .

Answer 1

Fonction de comparaison personnalisée qui comprend une fonctionnalité pour le Alphabet turc ou langues autres que l'anglais .

public <K extends Comparable,V extends Comparable> LinkedHashMap<K,V> sortByKeys(LinkedHashMap<K,V> map){
    List<K> keys = new LinkedList<K>(map.keySet());
    Collections.sort(keys, (Comparator<? super K>) new Comparator<String>() {
        @Override
        public int compare(String first, String second) {
            Collator collator = Collator.getInstance(Locale.getDefault());
            //Collator collator = Collator.getInstance(new Locale("tr", "TR"));
            return collator.compare(first, second);
        }
    });

    LinkedHashMap<K,V> sortedMap = new LinkedHashMap<K,V>();
    for(K key: keys){
        sortedMap.put(key, map.get(key));
    }

    return sortedMap;
}

Voici l'exemple d'utilisation suivant

LinkedHashMap<String, Boolean> ligList = new LinkedHashMap<String, Boolean>();
ligList = sortByKeys(ligList);

Answer 2

Sans plus d'informations, il est difficile de savoir exactement ce que vous voulez. Toutefois, lorsque vous choisissez la structure de données à utiliser, vous devez tenir compte de l'usage que vous en faites. Les hashmaps ne sont pas conçus pour le tri - ils sont conçus pour une extraction facile. Dans votre cas, vous devrez donc probablement extraire chaque élément de la table de hachage et les placer dans une structure de données plus propice au tri, comme un tas ou un ensemble, puis les trier.

Answer 3

Si vous souhaitez combiner une Map pour une récupération efficace avec une SortedMap, vous pouvez utiliser la fonction ConcurrentSkipListMap .

Bien entendu, il faut que la clé soit la valeur utilisée pour le tri.

Answer 4

Avez-vous envisagé d'utiliser un LinkedHashMap<>() ?

  public static void main(String[] args) {
    Map<Object, Object> handler = new LinkedHashMap<Object, Object>();
    handler.put("item", "Value");
    handler.put(2, "Movies");
    handler.put("isAlive", true);

    for (Map.Entry<Object, Object> entrY : handler.entrySet())
        System.out.println(entrY.getKey() + ">>" + entrY.getValue());

    List<Map.Entry<String, Integer>> entries = new ArrayList<Map.Entry<String, Integer>>();
    Collections.sort(entries, new Comparator<Map.Entry<String, Integer>>() {
        public int compare(Map.Entry<String, Integer> a,
                Map.Entry<String, Integer> b) {
            return a.getValue().compareTo(b.getValue());
        }
    });
}

les résultats dans un objet lié organisé.

 item>>Value
 2>>Movies
 isAlive>>true

vérifier la pièce de tri choisie aquí ..

Answer 5

J'ai développé une classe qui peut être utilisée pour trier une carte sur la base des clés et des valeurs. L'idée de base est que si vous avez trié une carte en utilisant des clés, alors créez un TreepMap à partir de votre carte qui triera la carte par clés. Et dans le cas d'un tri par valeurs, créez une liste à partir de entrySet et triez la liste en utilisant l'interface comparateur.

Voici la solution complète :

public static void main(String[] args) {
    Map<String, Integer> unSortedMap = new LinkedHashMap<String, Integer>();
    unSortedMap.put("A", 2);
    unSortedMap.put("V", 1);
    unSortedMap.put("G", 5);
    System.out.println("Unsorted Map :\n");
    for (Map.Entry<String, Integer> entry : unSortedMap.entrySet()) {
        System.out.println(entry.getKey() + "   " + entry.getValue());
    }
    System.out.println("\n");
    System.out.println("Sorting Map Based on Keys :\n");
    Map<String, Integer> keySortedMap = new TreeMap<String, Integer>(unSortedMap);
    for (Map.Entry<String, Integer> entry : keySortedMap.entrySet()) {
        System.out.println(entry.getKey() + "   " + entry.getValue());
    }
    System.out.println("\n");
    System.out.println("Sorting Map Based on Values :\n");
    List<Entry<String, Integer>> entryList = new ArrayList<Entry<String, Integer>>(unSortedMap.entrySet());
    Collections.sort(entryList, new Comparator<Entry<String, Integer>>() {

        @Override
        public int compare(Entry<String, Integer> obj1, Entry<String, Integer> obj2) {
            return obj1.getValue().compareTo(obj2.getValue());
        }
    });
    unSortedMap.clear();
    for (Entry<String, Integer> entry : entryList) {
        unSortedMap.put(entry.getKey(), entry.getValue());
        System.out.println(entry.getKey() + "   " + entry.getValue());
    }
}

Le code est correctement testé :D