Ordenar un HashMap

Introducción

Un HashMap es una colección que almacena pares de clave-valor. Sin embargo, no almacena los pares de clave-valor en ningún orden particular y no mantiene el orden de inserción de los elementos. Pueden haber casos en los que queramos ver los datos almacenados de manera ordenada. En tales casos, necesitamos ordenar el HashMap.

Crear un nuevo archivo de Java

Primero, necesitamos crear un nuevo archivo Java para escribir el código para ordenar un HashMap. Abra la terminal y navegue hasta el directorio donde desea crear el archivo. Utilice el siguiente comando para crear un nuevo archivo llamado HashMapSortDemo.java.

touch HashMapSortDemo.java

Ordenar por claves utilizando Collections.sort()

Podemos ordenar un HashMap por claves utilizando el método Collections.sort(). Siga el código a continuación:

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

El código anterior está ordenando el HashMap por claves utilizando el método Collections.sort().

Utilice el siguiente comando para compilar y ejecutar el código:

javac HashMapSortDemo.java && java HashMapSortDemo

Ordenar por valores utilizando Collections.sort()

Podemos ordenar un HashMap por valores utilizando el método Collections.sort(). Siga el código a continuación:

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

El código anterior está ordenando el HashMap por valores utilizando el método Collections.sort().

Utilice el siguiente comando para compilar y ejecutar el código:

javac HashMapSortDemo.java && java HashMapSortDemo

Ordenar por claves utilizando TreeMap

Podemos ordenar un HashMap por claves utilizando un TreeMap. Un TreeMap almacena automáticamente los pares de clave-valor en orden ascendente (ordenados por claves). Siga el código a continuación:

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

El código anterior está ordenando el HashMap por claves utilizando un TreeMap.

Utilice el siguiente comando para compilar y ejecutar el código:

javac HashMapSortDemo.java && java HashMapSortDemo

Ordenar por valores utilizando TreeSet

Podemos ordenar un HashMap por valores utilizando un TreeSet. Un TreeSet también almacena los datos en orden ascendente (ordenados por valores). Siga el código a continuación:

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("\nLos valores ordenados son: " + sortedSet);
    }
}

El código anterior está ordenando el HashMap por valores utilizando un TreeSet.

Utilice el siguiente comando para compilar y ejecutar el código:

javac HashMapSortDemo.java && java HashMapSortDemo

Ordenamiento utilizando Stream y expresiones Lambda

Podemos ordenar un HashMap en una sola línea de código utilizando Java Streams y las expresiones Lambda. Siga el código a continuación:

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("Imprimiendo el HashMap no ordenado");
        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("\nImprimiendo los pares clave-valor ordenados");
        sortedStream.forEach(System.out :: println);
    }
}

El código anterior está ordenando el HashMap utilizando Java Streams y expresiones Lambda.

Utilice el siguiente comando para compilar y ejecutar el código:

javac HashMapSortDemo.java && java HashMapSortDemo

Ordenar por valores utilizando Stream y expresiones Lambda

También podemos ordenar un HashMap por valores utilizando Java Streams y expresiones Lambda. Siga el código a continuación:

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("Imprimiendo el HashMap no ordenado");
        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("\nImprimiendo los pares clave-valor ordenados");
        sortedStream.forEach(System.out :: println);
    }
}

El código anterior está ordenando el HashMap por valores utilizando Java Streams y expresiones Lambda.

Utilice el siguiente comando para compilar y ejecutar el código:

javac HashMapSortDemo.java && java HashMapSortDemo

Usando la biblioteca Guava de Google

La biblioteca Guava de Google nos proporciona una clase ImmutableSortedMap. Podemos utilizar el método copyOf() de esta clase para ordenar un HashMap. Siga el código a continuación:

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("Imprimiendo el HashMap no ordenado");
        for (Entry<String, Integer> e : unsortedMap.entrySet()) {
            System.out.println(e.getKey() + "-->" + e.getValue());
        }

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

        System.out.println("\nImprimiendo el ImmutableSortedMap ordenado");
        System.out.println(sortedMap);
    }
}

El código anterior está ordenando el HashMap utilizando la biblioteca Guava de Google.

Utilice el siguiente comando para compilar y ejecutar el código:

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

Limpiando

Finalmente, elimine el archivo HashMapSortDemo.java utilizando el siguiente comando:

rm HashMapSortDemo.java

Resumen

En este laboratorio, hemos visto cómo ordenar un HashMap por claves o valores. Hemos utilizado diferentes métodos como Collections.sort(), TreeMap, TreeSet, Java Streams y expresiones Lambda, y la biblioteca Guava de Google para ordenar el HashMap. También hemos aprendido sobre sus casos de uso y cómo podemos escribir un código eficiente para ordenar el HashMap en Java.