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