Trier une HashMap

Introduction

Une HashMap est une collection qui stocke des paires clé-valeur. Cependant, elle ne stocke pas les paires clé-valeur dans un ordre particulier et ne conserve pas l'ordre d'insertion des éléments. Il peut y avoir des cas où nous voulons visualiser les données stockées de manière triée. Dans de tels cas, nous devons trier la HashMap.

Créer un nouveau fichier Java

Tout d'abord, nous devons créer un nouveau fichier Java pour écrire le code de tri d'une HashMap. Ouvrez le terminal et accédez au répertoire où vous voulez créer le fichier. Utilisez la commande suivante pour créer un nouveau fichier nommé HashMapSortDemo.java.

touch HashMapSortDemo.java

Tri par clés à l'aide de Collections.sort()

Nous pouvons trier une HashMap par clés à l'aide de la méthode Collections.sort(). Suivez le code ci-dessous :

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map.Entry;

public class HashMapSortDemo {
    public static void main(String args[]) {
        HashMap<String, Integer> unsortedMap = new HashMap<>();
        unsortedMap.put("one", 1);
        unsortedMap.put("two", 2);
        unsortedMap.put("three", 3);
        unsortedMap.put("four", 4);
        unsortedMap.put("five", 5);

        System.out.println("Printing the Unsorted HashMap");
        for(Entry<String, Integer> e : unsortedMap.entrySet()) {
            System.out.println(e.getKey() + "-->" + e.getValue());
        }

        ArrayList<String> sortedList = new ArrayList<>(unsortedMap.keySet());
        Collections.sort(sortedList);

        System.out.println("\nPrinting the Alphabetically Sorted Keys");
        for(String s : sortedList) {
            System.out.println(s + "-->" + unsortedMap.get(s));
        }
    }
}

Le code ci-dessus trie la HashMap par clés à l'aide de la méthode Collections.sort().

Utilisez la commande suivante pour compiler et exécuter le code :

javac HashMapSortDemo.java && java HashMapSortDemo

Tri par valeurs à l'aide de Collections.sort()

Nous pouvons trier une HashMap par valeurs à l'aide de la méthode Collections.sort(). Suivez le code ci-dessous :

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map.Entry;

public class HashMapSortDemo {
    public static void main(String args[]) {
        HashMap<String, Integer> unsortedMap = new HashMap<>();
        unsortedMap.put("one", 1);
        unsortedMap.put("two", 2);
        unsortedMap.put("three", 3);
        unsortedMap.put("four", 4);
        unsortedMap.put("five", 5);

        System.out.println("Printing the Unsorted HashMap");
        for(Entry<String, Integer> e : unsortedMap.entrySet()) {
            System.out.println(e.getKey() + "-->" + e.getValue());
        }

        ArrayList<Integer> sortedList = new ArrayList<>(unsortedMap.values());
        Collections.sort(sortedList);

        System.out.println("\nPrinting the Sorted Values");
        for(Integer i : sortedList) {
            System.out.println(i);
        }
    }
}

Le code ci-dessus trie la HashMap par valeurs à l'aide de la méthode Collections.sort().

Utilisez la commande suivante pour compiler et exécuter le code :

javac HashMapSortDemo.java && java HashMapSortDemo

Tri par clés à l'aide de TreeMap

Nous pouvons trier une HashMap par clés à l'aide d'un TreeMap. Un TreeMap stocke automatiquement les paires clé-valeur dans l'ordre trié (trié par clés). Suivez le code ci-dessous :

import java.util.HashMap;
import java.util.Map.Entry;
import java.util.TreeMap;

public class HashMapSortDemo {
    public static void main(String args[]) {
        HashMap<String, Integer> unsortedMap = new HashMap<>();
        unsortedMap.put("one", 1);
        unsortedMap.put("two", 2);
        unsortedMap.put("three", 3);
        unsortedMap.put("four", 4);
        unsortedMap.put("five", 5);

        System.out.println("Printing the Unsorted HashMap");
        for(Entry<String, Integer> e : unsortedMap.entrySet()) {
            System.out.println(e.getKey() + "-->" + e.getValue());
        }

        TreeMap<String, Integer> sortedMap = new TreeMap<>(unsortedMap);

        System.out.println("\nPrinting the Sorted TreeMap");
        for(Entry<String, Integer> e : sortedMap.entrySet()) {
            System.out.println(e.getKey() + "-->" + e.getValue());
        }
    }
}

Le code ci-dessus trie la HashMap par clés à l'aide d'un TreeMap.

Utilisez la commande suivante pour compiler et exécuter le code :

javac HashMapSortDemo.java && java HashMapSortDemo

Tri par valeurs à l'aide de TreeSet

Nous pouvons trier une HashMap par valeurs à l'aide d'un TreeSet. Un TreeSet stocke également les données dans l'ordre trié (trié par valeurs). Suivez le code ci-dessous :

import java.util.HashMap;
import java.util.Map.Entry;
import java.util.TreeSet;

public class HashMapSortDemo {
    public static void main(String args[]) {
        HashMap<String, Integer> unsortedMap = new HashMap<>();
        unsortedMap.put("one", 1);
        unsortedMap.put("two", 2);
        unsortedMap.put("three", 3);
        unsortedMap.put("four", 4);
        unsortedMap.put("five", 5);

        unsortedMap.put("fourteen", 4);
        unsortedMap.put("fifteen", 5);
        unsortedMap.put("twenty", 2);

        System.out.println("Printing the Unsorted HashMap");
        for(Entry<String, Integer> e : unsortedMap.entrySet()) {
            System.out.println(e.getKey() + "-->" + e.getValue());
        }

        TreeSet<Integer> sortedSet = new TreeSet<>(unsortedMap.values());

        System.out.println("\nThe sorted values are: " + sortedSet);
    }
}

Le code ci-dessus trie la HashMap par valeurs à l'aide d'un TreeSet.

Utilisez la commande suivante pour compiler et exécuter le code :

javac HashMapSortDemo.java && java HashMapSortDemo

Tri à l'aide de Stream et d'expressions Lambda

Nous pouvons trier une HashMap en une seule ligne de code en utilisant les flux Java (Java Streams) et les expressions Lambda. Suivez le code ci-dessous :

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.stream.Stream;

public class HashMapSortDemo {
    public static void main(String args[]) {
        HashMap<String, Integer> unsortedMap = new HashMap<>();
        unsortedMap.put("one", 1);
        unsortedMap.put("two", 2);
        unsortedMap.put("three", 3);
        unsortedMap.put("four", 4);
        unsortedMap.put("five", 5);

        System.out.println("Printing the Unsorted HashMap");
        for(Entry<String, Integer> e : unsortedMap.entrySet()) {
            System.out.println(e.getKey() + "-->" + e.getValue());
        }

        Stream<Entry<String, Integer>> sortedStream = unsortedMap.entrySet()
                                      .stream()
                                      .sorted(Map.Entry.<String, Integer>comparingByKey());

        System.out.println("\nPrinting the Sorted Key-Value Pairs");
        sortedStream.forEach(System.out :: println);
    }
}

Le code ci-dessus trie la HashMap en utilisant les flux Java (Java Streams) et les expressions Lambda.

Utilisez la commande suivante pour compiler et exécuter le code :

javac HashMapSortDemo.java && java HashMapSortDemo

Tri par valeurs à l'aide de Stream et d'expressions Lambda

Nous pouvons également trier une HashMap par valeurs en utilisant les flux Java (Java Streams) et les expressions Lambda. Suivez le code ci-dessous :

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.stream.Stream;

public class HashMapSortDemo {
    public static void main(String args[]) {
        HashMap<String, Integer> unsortedMap = new HashMap<>();
        unsortedMap.put("one", 1);
        unsortedMap.put("two", 2);
        unsortedMap.put("three", 3);
        unsortedMap.put("four", 4);
        unsortedMap.put("five", 5);

        System.out.println("Printing the Unsorted HashMap");
        for(Entry<String, Integer> e : unsortedMap.entrySet()) {
            System.out.println(e.getKey() + "-->" + e.getValue());
        }

        Stream<Entry<String, Integer>> sortedStream = unsortedMap.entrySet()
                                     .stream()
                                     .sorted(Map.Entry.<String, Integer>comparingByValue());

        System.out.println("\nPrinting the Sorted Key-Value Pairs");
        sortedStream.forEach(System.out :: println);
    }
}

Le code ci-dessus trie la HashMap par valeurs en utilisant les flux Java (Java Streams) et les expressions Lambda.

Utilisez la commande suivante pour compiler et exécuter le code :

javac HashMapSortDemo.java && java HashMapSortDemo

Utilisation de la bibliothèque Guava d'Google

La bibliothèque Guava d'Google nous fournit une classe ImmutableSortedMap. Nous pouvons utiliser la méthode copyOf() de cette classe pour trier une HashMap. Suivez le code ci-dessous :

import java.util.HashMap;
import java.util.Map.Entry;
import com.google.common.collect.ImmutableSortedMap;

public class HashMapSortDemo {
    public static void main(String args[]) {
        HashMap<String, Integer> unsortedMap = new HashMap<>();
        unsortedMap.put("one", 1);
        unsortedMap.put("two", 2);
        unsortedMap.put("three", 3);
        unsortedMap.put("four", 4);
        unsortedMap.put("five", 5);

        System.out.println("Printing the Unsorted HashMap");
        for (Entry<String, Integer> e : unsortedMap.entrySet()) {
            System.out.println(e.getKey() + "-->" + e.getValue());
        }

        ImmutableSortedMap<String, Integer> sortedMap = ImmutableSortedMap.copyOf(unsortedMap);

        System.out.println("\nPrinting the Sorted ImmutableSortedMap");
        System.out.println(sortedMap);
    }
}

Le code ci-dessus trie la HashMap en utilisant la bibliothèque Guava d'Google.

Utilisez la commande suivante pour compiler et exécuter le code :

javac -cp ".:guava-30.1.1-jre.jar" HashMapSortDemo.java && java -cp ".:guava-30.1.1-jre.jar" HashMapSortDemo

Nettoyage

Enfin, supprimez le fichier HashMapSortDemo.java à l'aide de la commande suivante :

rm HashMapSortDemo.java

Récapitulatif

Dans ce laboratoire, nous avons vu comment trier une HashMap par clés ou par valeurs. Nous avons utilisé différentes méthodes telles que Collections.sort(), TreeMap, TreeSet, les flux Java (Java Streams) et les expressions Lambda, ainsi que la bibliothèque Guava d'Google pour trier la HashMap. Nous avons également appris à connaître leurs cas d'utilisation et comment écrire un code efficace pour trier la HashMap en Java.