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