Ordenar un HashMap según las claves en Java

Recibimos los detalles de las calificaciones obtenidas por los estudiantes en forma de HashMap , donde el nombre del estudiante es la clave y las calificaciones obtenidas son el valor. Nuestra tarea es clasificar el mapa de acuerdo con los valores clave, es decir, los nombres de los estudiantes en orden alfabético (lexicográfico).
Ejemplos: 

Input : Key = Jayant, Value = 80
        Key = Anushka, Value = 80
        Key = Amit, Value = 75
        Key = Abhishek, Value = 90
        Key = Danish, Value = 40
Output : Sorted Map according to Names:
         Key = Abhishek, Value = 90
         Key = Amit, Value = 75
         Key = Anushka, Value = 80
         Key = Danish, Value = 40
         Key = Jayant, Value = 80

Usando TreeMap (método putAll) 

La idea es poner todos los datos de HashMap en un TreeMap . TreeMap sigue la implementación basada en Red Black Tree . El mapa se ordena según el orden natural de sus claves. Haga clic aquí para más
 

Java

// Java Code to sort Map by key value
import java.util.*;
class sortmapKey {
 
    // This map stores unsorted values
    static Map<String, Integer> map = new HashMap<>();
 
    // Function to sort map by Key
    public static void sortbykey()
    {
        // TreeMap to store values of HashMap
        TreeMap<String, Integer> sorted = new TreeMap<>();
 
        // Copy all data from hashMap into TreeMap
        sorted.putAll(map);
 
        // Display the TreeMap which is naturally sorted
        for (Map.Entry<String, Integer> entry : sorted.entrySet())
            System.out.println("Key = " + entry.getKey() +
                         ", Value = " + entry.getValue());       
    }
     
    // Driver Code
    public static void main(String args[])
    {
        // putting values in the Map
        map.put("Jayant", 80);
        map.put("Abhishek", 90);
        map.put("Anushka", 80);
        map.put("Amit", 75);
        map.put("Danish", 40);
 
        // Calling the function to sortbyKey
        sortbykey();
    }
}
Producción

Key = Abhishek, Value = 90
Key = Amit, Value = 75
Key = Anushka, Value = 80
Key = Danish, Value = 40
Key = Jayant, Value = 80

Nota: TreeMap proporciona un costo de tiempo de registro (n) garantizado para las operaciones containsKey , get , put y remove. 

Usando TreeMap (Constructor) 

Java

// Java Code to sort Map by key value
import java.util.*;
class sortmapKey {
 
    // This map stores unsorted values
    static Map<String, Integer> map = new HashMap<>();
 
    // Function to sort map by Key
    public static void sortbykey()
    {
        // TreeMap to store values of HashMap
        TreeMap<String, Integer> sorted
            = new TreeMap<>(map);
 
        // Display the TreeMap which is naturally sorted
        for (Map.Entry<String, Integer> entry :
             sorted.entrySet())
            System.out.println("Key = " + entry.getKey()
                               + ", Value = "
                               + entry.getValue());
    }
 
    // Driver Code
    public static void main(String args[])
    {
        // putting values in the Map
        map.put("Jayant", 80);
        map.put("Abhishek", 90);
        map.put("Anushka", 80);
        map.put("Amit", 75);
        map.put("Danish", 40);
 
        // Calling the function to sortbyKey
        sortbykey();
    }
}
Producción

Key = Abhishek, Value = 90
Key = Amit, Value = 75
Key = Anushka, Value = 80
Key = Danish, Value = 40
Key = Jayant, Value = 80

Usando ArrayList 

En este enfoque, creamos una lista de claves utilizando el constructor ArrayList . Luego ordenamos la lista usando el método Collections.sort() .

Java

// Java Code to sort Map by key value
import java.util.*;
class sortmapKey {
 
    // This map stores unsorted values
    static Map<String, Integer> map = new HashMap<>();
 
    // Function to sort map by Key
    public static void sortbykey()
    {
        ArrayList<String> sortedKeys
            = new ArrayList<String>(map.keySet());
 
        Collections.sort(sortedKeys);
 
        // Display the TreeMap which is naturally sorted
        for (String x : sortedKeys)
            System.out.println("Key = " + x
                               + ", Value = " + map.get(x));
    }
 
    // Driver Code
    public static void main(String args[])
    {
        // putting values in the Map
        map.put("Jayant", 80);
        map.put("Abhishek", 90);
        map.put("Anushka", 80);
        map.put("Amit", 75);
        map.put("Danish", 40);
 
        // Calling the function to sortbyKey
        sortbykey();
    }
}
Producción

Key = Abhishek, Value = 90
Key = Amit, Value = 75
Key = Anushka, Value = 80
Key = Danish, Value = 40
Key = Jayant, Value = 80

 Usando Java 8 Lambdas

Aquí cambiaremos la forma en que clasificamos y usaremos la expresión lambda para clasificar. La lógica es la misma, e incluso también pasamos el objeto comparador pero solo usando lambda.

A continuación se muestra la implementación del enfoque anterior:

Java

// Java Code to sort Map by key value
import java.util.*;
class sortmapKey {
 
    // This map stores unsorted key
    static Map<String, Integer> map = new HashMap<>();
 
    // function to sort hashmap by keys
    public static Map<String, Integer>
    sortByKey(Map<String, Integer> hm)
    {
        // Create a list from elements of HashMap
        List<Map.Entry<String, Integer> > list
            = new LinkedList<Map.Entry<String, Integer> >(
                hm.entrySet());
 
        // Sort the list using lambda expression
        Collections.sort(
            list,
            (i1, i2) -> i1.getKey().compareTo(i2.getKey()));
 
        // put data from sorted list to hashmap
        HashMap<String, Integer> temp
            = new LinkedHashMap<String, Integer>();
        for (Map.Entry<String, Integer> aa : list) {
            temp.put(aa.getKey(), aa.getValue());
        }
        return temp;
    }
 
    // Driver Code
    public static void main(String args[])
    {
        // putting values in the Map
        map.put("Jayant", 80);
        map.put("Abhishek", 90);
        map.put("Anushka", 80);
        map.put("Amit", 75);
        map.put("Danish", 40);
 
        // Calling the function to sortbyKey
        Map<String, Integer> hm1 = sortByKey(map);
 
        // print the sorted hashmap
        for (Map.Entry<String, Integer> en :
             hm1.entrySet()) {
            System.out.println("Key = " + en.getKey()
                               + ", Value = "
                               + en.getValue());
        }
    }
}
Producción

Key = Abhishek, Value = 90
Key = Amit, Value = 75
Key = Anushka, Value = 80
Key = Danish, Value = 40
Key = Jayant, Value = 80

Uso de flujos de Java 8

Aquí usaremos flujos para ordenar el mapa. Usaremos el método stream() para obtener el flujo de entrySet seguido de la expresión lambda dentro del método sorted() para ordenar el flujo y, finalmente, lo convertiremos en un mapa usando el método toMap() . Dentro del método toMap(), usamos la referencia del método LinkedHashMap::new para conservar el orden del mapa.

Java

// Java Code to sort Map by key value
import static java.util.stream.Collectors.*;
 
import java.lang.*;
import java.util.*;
import java.util.stream.*;
import java.util.stream.Collectors;
class sortmapKey {
 
    // This map stores unsorted values
    static Map<String, Integer> map = new HashMap<>();
 
    // Function to sort map by Key
    public static void sortbykey()
    {
        HashMap<String, Integer> temp
            = map.entrySet()
                  .stream()
                  .sorted((i1, i2)
                              -> i1.getKey().compareTo(
                                  i2.getKey()))
                  .collect(Collectors.toMap(
                      Map.Entry::getKey,
                      Map.Entry::getValue,
                      (e1, e2) -> e1, LinkedHashMap::new));
 
        // Display the HashMap which is naturally sorted
        for (Map.Entry<String, Integer> entry :
             temp.entrySet()) {
            System.out.println("Key = " + entry.getKey()
                               + ", Value = "
                               + entry.getValue());
        }
    }
 
    // Driver Code
    public static void main(String args[])
    {
        // putting values in the Map
        map.put("Jayant", 80);
        map.put("Abhishek", 90);
        map.put("Anushka", 80);
        map.put("Amit", 75);
        map.put("Danish", 40);
 
        // Calling the function to sortbyKey
        sortbykey();
    }
}
Producción

Key = Abhishek, Value = 90
Key = Amit, Value = 75
Key = Anushka, Value = 80
Key = Danish, Value = 40
Key = Jayant, Value = 80

Este artículo es una contribución de DANISH KALEEM y Arnav Kr. Mandalo . Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo usando contribuya.geeksforgeeks.org o envíe su artículo por correo a contribuya@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.
 

Publicación traducida automáticamente

Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *