Comment puis-je trier un HashMap par ses valeurs tout en préservant les paires clé-valeur en Java ?

Tri de Hashmap par valeurs

Problème :

Nous devons trier une HashMap en fonction de les valeurs qu'il contient et maintenir les paires clé-valeur pendant tri.

Solution :

Le tri d'un HashMap par valeurs peut être réalisé en utilisant une approche générique. Les étapes suivantes décrivent le processus :

1. Créer une liste chaînée : Convertissez les entrées HashMap en une LinkedList, en vous assurant que l'ordre d'insertion est préservé.
2. Comparateur personnalisé : Définissez un comparateur personnalisé pour comparer les valeurs des entrées. Il doit prendre en compte les options d'ordre croissant et décroissant.
3. Trier la liste : Utilisez le comparateur personnalisé pour trier la LinkedList en fonction des valeurs. Puisque les entrées sont liées, les clés seront également triées.
4. Convertir en HashMap trié : Utilisez la LinkedList triée pour construire une nouvelle LinkedHashMap, où les clés et les valeurs sont associées telles qu'elles étaient. dans le HashMap original.
5. Version personnalisée : Une version personnalisée de la méthode de tri peut être créé, permettant un classement spécifique des valeurs ascendantes ou décroissantes.

Exemple d'implémentation :

Le code Java suivant implémente l'algorithme de tri :

import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

public class SortMapByValue {

    public static final boolean ASC = true;
    public static final boolean DESC = false;

    public static void main(String[] args) {

        // Create dummy HashMap
        Map<integer string> unsortedMap = new HashMap();
        unsortedMap.put(1, "froyo");
        unsortedMap.put(2, "abby");
        unsortedMap.put(3, "denver");
        unsortedMap.put(4, "frost");
        unsortedMap.put(5, "daisy");

        // Sort in ascending order
        Map<integer string> sortedMapAsc = sortByValue(unsortedMap, ASC);

        // Sort in descending order
        Map<integer string> sortedMapDesc = sortByValue(unsortedMap, DESC);

        // Print sorted maps
        System.out.println("Sorted Ascending:");
        printMap(sortedMapAsc);
        System.out.println("Sorted Descending:");
        printMap(sortedMapDesc);
    }

    private static Map<integer string> sortByValue(Map<integer string> map, boolean order) {

        List<entry string>> list = new LinkedList(map.entrySet());

        // Custom comparator for values
        Collections.sort(list, new Comparator<entry string>>() {
            public int compare(Entry<integer string> o1, Entry<integer string> o2) {
                if (order) {
                    return o1.getValue().compareTo(o2.getValue());
                } else {
                    return o2.getValue().compareTo(o1.getValue());
                }
            }
        });

        // Return sorted LinkedHashMap
        Map<integer string> sortedMap = new LinkedHashMap();
        for (Entry<integer string> entry : list) {
            sortedMap.put(entry.getKey(), entry.getValue());
        }

        return sortedMap;
    }

    public static void printMap(Map<integer string> map) {
        for (Entry<integer string> entry : map.entrySet()) {
            System.out.println(entry.getKey() + " - " + entry.getValue());
        }
        System.out.println();
    }
}</integer></integer></integer></integer></integer></integer></entry></entry></integer></integer></integer></integer></integer>

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!