Sortieren einer HashMap

Einführung

Eine HashMap ist eine Sammlung, die Schlüssel-Wert-Paare speichert. Allerdings speichert sie die Schlüssel-Wert-Paare nicht in einer bestimmten Reihenfolge und behält die Einfügereihenfolge der Elemente nicht bei. Es können Fälle auftreten, in denen wir die gespeicherten Daten in aufsteigender Reihenfolge anzeigen möchten. In solchen Fällen müssen wir die HashMap sortieren.

Erstellen einer neuen Java-Datei

Zunächst müssen wir eine neue Java-Datei erstellen, um den Code zum Sortieren einer HashMap zu schreiben. Öffnen Sie das Terminal und navigieren Sie zum Verzeichnis, in dem Sie die Datei erstellen möchten. Verwenden Sie den folgenden Befehl, um eine neue Datei mit dem Namen HashMapSortDemo.java zu erstellen.

touch HashMapSortDemo.java

Sortieren nach Schlüsseln mit Collections.sort()

Wir können eine HashMap nach Schlüsseln mithilfe der Collections.sort()-Methode sortieren. Folgen Sie dem unten stehenden Code:

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));
        }
    }
}

Der obige Code sortiert die HashMap nach Schlüsseln mithilfe der Collections.sort()-Methode.

Verwenden Sie den folgenden Befehl, um den Code zu kompilieren und auszuführen:

javac HashMapSortDemo.java && java HashMapSortDemo

Sortieren nach Werten mit Collections.sort()

Wir können eine HashMap nach Werten mithilfe der Collections.sort()-Methode sortieren. Folgen Sie dem unten stehenden Code:

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);
        }
    }
}

Der obige Code sortiert die HashMap nach Werten mithilfe der Collections.sort()-Methode.

Verwenden Sie den folgenden Befehl, um den Code zu kompilieren und auszuführen:

javac HashMapSortDemo.java && java HashMapSortDemo

Sortieren nach Schlüsseln mit TreeMap

Wir können eine HashMap nach Schlüsseln mithilfe eines TreeMap sortieren. Ein TreeMap speichert die Schlüssel-Wert-Paare automatisch in aufsteigender Reihenfolge (sortiert nach Schlüsseln). Folgen Sie dem unten stehenden Code:

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());
        }
    }
}

Der obige Code sortiert die HashMap nach Schlüsseln mithilfe eines TreeMap.

Verwenden Sie den folgenden Befehl, um den Code zu kompilieren und auszuführen:

javac HashMapSortDemo.java && java HashMapSortDemo

Sortieren nach Werten mit TreeSet

Wir können eine HashMap nach Werten mithilfe eines TreeSet sortieren. Ein TreeSet speichert auch die Daten in aufsteigender Reihenfolge (sortiert nach Werten). Folgen Sie dem unten stehenden Code:

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);
    }
}

Der obige Code sortiert die HashMap nach Werten mithilfe eines TreeSet.

Verwenden Sie den folgenden Befehl, um den Code zu kompilieren und auszuführen:

javac HashMapSortDemo.java && java HashMapSortDemo

Sortieren mit Stream und Lambda-Ausdrücken

Wir können eine HashMap in einer einzigen Codezeile sortieren, indem wir Java Streams und Lambda-Ausdrücke verwenden. Folgen Sie dem unten stehenden Code:

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);
    }
}

Der obige Code sortiert die HashMap mithilfe von Java Streams und Lambda-Ausdrücken.

Verwenden Sie den folgenden Befehl, um den Code zu kompilieren und auszuführen:

javac HashMapSortDemo.java && java HashMapSortDemo

Sortieren nach Werten mit Stream und Lambda-Ausdrücken

Wir können auch eine HashMap nach Werten sortieren, indem wir Java Streams und Lambda-Ausdrücke verwenden. Folgen Sie dem unten stehenden Code:

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);
    }
}

Der obige Code sortiert die HashMap nach Werten mithilfe von Java Streams und Lambda-Ausdrücken.

Verwenden Sie den folgenden Befehl, um den Code zu kompilieren und auszuführen:

javac HashMapSortDemo.java && java HashMapSortDemo

Verwendung der Google Guava-Bibliothek

Die Google Guava-Bibliothek bietet uns die Klasse ImmutableSortedMap. Wir können die copyOf()-Methode dieser Klasse verwenden, um eine HashMap zu sortieren. Folgen Sie dem unten stehenden Code:

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);
    }
}

Der obige Code sortiert die HashMap mithilfe der Google Guava-Bibliothek.

Verwenden Sie den folgenden Befehl, um den Code zu kompilieren und auszuführen:

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

Aufräumen

Schließlich löschen Sie die Datei HashMapSortDemo.java mit dem folgenden Befehl:

rm HashMapSortDemo.java

Zusammenfassung

In diesem Lab haben wir gesehen, wie man eine HashMap nach Schlüsseln oder Werten sortiert. Wir haben verschiedene Methoden wie Collections.sort(), TreeMap, TreeSet, Java Streams und Lambda-Ausdrücke sowie die Google Guava-Bibliothek verwendet, um die HashMap zu sortieren. Wir haben auch über ihre Anwendungsfälle gelernt und wie wir effizienten Code schreiben können, um die HashMap in Java zu sortieren.