java - how - ¿Cómo imprimir el contenido de un HashMap<String, String> en orden ascendente en función de sus valores?

map string string java

Question

Tengo este HashMap que necesito imprimir en orden ascendente de acuerdo con los valores que contiene ( no las claves ).

Pero el orden cuando lo imprimo es aparentemente aleatorio.

¿Cuál es la mejor manera de imprimirlo en orden ascendente ?

Map<String, String> codes = new HashMap<String, String>();
codes.put("A1", "Aania");
codes.put("X1", "Abatha");
codes.put("C1", "Acathan");
codes.put("S1", "Adreenas");

En otras palabras, el ejemplo anterior debería imprimirse así:

A1, Aania
X1, Abatha
C1, Acathan
S1, Adreenas

Answer 1

1. Crear un TreeMap<String,String>
2. Agregue cada una de las entradas de HashMap con el valor como clave.
3. iterar el TreeMap

Si los valores no son únicos, necesitaría una lista en la segunda posición.

Answer 2

Es hora de agregar algunas lambdas:

codes.entrySet()
.stream()
.sorted(Comparator.comparing(Map.Entry::getValue))
.forEach(System.out::println);

Answer 3

Java 8

map.entrySet().stream().sorted(Map.Entry.comparingByValue()).forEach(System.out::println);

Answer 4

La solución más sencilla sería utilizar un mapa ordenado como TreeMap en lugar de HashMap. Si no tiene control sobre la construcción del mapa, la solución mínima sería construir un conjunto ordenado de claves. Realmente no necesitas un nuevo mapa.

Set<String> sortedKeys = new TreeSet<String>();
sortedKeys.addAll(codes.keySet());
for(String key: sortedKeys){
println(key + ":" + codes.get(key));
}

Answer 5

No podrás hacer esto solo desde la clase HashMap.

Tomaría los Map<String, String> codes , construiría un mapa inverso de TreeMap<String, String> reversedMap donde TreeMap<String, String> reversedMap los valores de los codes Map a las teclas (esto requeriría que su Map original tenga un one to to una asignación de clave a valor). Dado que el TreeMap proporciona iteradores que devuelven entradas en orden ascendente de claves, esto le dará la combinación valor / clave del primer mapa en el orden (ordenado por valores) que desee.

Map<String, String> reversedMap = new TreeMap<String, String>(codes);
//then you just access the reversedMap however you like...
for (Map.Entry entry : reversedMap.entrySet()) {
System.out.println(entry.getKey() + ", " + entry.getValue());
}

Existen varias bibliotecas de colecciones (colecciones comunes, colecciones de Google, etc.) que tienen implementaciones de mapas bidireccionales similares.

Answer 6

Puede usar una lista del conjunto de entradas en lugar del conjunto de claves y es una opción más natural dado que está ordenando según el valor. Esto evita muchas búsquedas innecesarias en la clasificación e impresión de las entradas.

Map<String, String> map = ...
List<Map.Entry<String, String>> listOfEntries = new ArrayList<Map.Entry<String, String>>(map.entrySet());
Collections.sort(listOfEntries, new SortByValueComparator());
for(Map.Entry<String, String> entry: listOfEntries)
System.out.println(entry);
static class SortByValueComparator implements Comparator<Map.Entry<String, String>> {
public int compareTo(Map.Entry<String, String> e1, Map.Entry<String, String> e2) {
return e1.getValue().compateTo(e2.getValue());
}
}

Answer 7

Tendrá que hacer una lista de las claves, ordenarlas de acuerdo con los valores correspondientes, luego iterar sobre las claves ordenadas.

Map<String, String> map = getMyMap();
List<String> keys = new ArrayList<String>(map.keySet());
Collections.sort(keys, someComparator);
for (String key: keys) {
System.out.println(key + ": " + map.get(key));
}

En cuanto a qué usar para algunos someComparator , aquí hay algunas rutinas prácticas y genéricas de creación de comparadores que a menudo encuentro útiles. El primero ordena por los valores de acuerdo con su ordenación natural, y el segundo le permite especificar cualquier Comparador arbitrario para ordenar los valores:

public static <K, V extends Comparable<? super V>>
Comparator<K> mapValueComparator(final Map<K, V> map) {
return new Comparator<K>() {
public int compare(K key1, K key2) {
return map.get(key1).compareTo(map.get(key2));
}
};
}
public static <K, V>
Comparator<K> mapValueComparator(final Map<K, V> map,
final Comparator<V> comparator) {
return new Comparator<K>() {
public int compare(K key1, K key2) {
return comparator.compare(map.get(key1), map.get(key2));
}
};
}

Answer 8

Tratar:

try
{
int cnt= m.getSmartPhoneCount("HTC",true);
System.out.println("total count of HTC="+cnt);
}
catch (NoSuchBrandSmartPhoneAvailableException e)
{
// TODO Auto-generated catch
e.printStackTrace();
}

Answer 9

el bucle for de for (entrada Map.Entry: codes.entrySet() ) no funcionó para mí. Iterador usado en su lugar.

Iterator<Map.Entry<String, String>> i = codes.entrySet().iterator();
while(i.hasNext()){
String key = i.next().getKey();
System.out.println(key+", "+codes.get(key));
}

Answer 10

el código más simple y más corto que creo que es este: public void listPrinter (LinkedHashMap caseList) {

 for(Entry entry:caseList.entrySet()) {
System.out.println("K: /t"+entry.getKey()+", V: /t"+entry.getValue());
}
}

Answer 11

solo necesitas usar:

 Map<>.toString().replace("]","/n");

y reemplaza el corchete final de cada clave = valor establecido con una nueva línea.

Answer 12

 SmartPhone[] sp=new SmartPhone[4];
sp[0]=new SmartPhone(1,"HTC","desire","black",20000,10,true,true);
sp[1]=new SmartPhone(2,"samsung","grand","black",5000,10,false,true);
sp[2]=new SmartPhone(14,"google nexus","desire","black",2000,30,true,false);
sp[3]=new SmartPhone(13,"HTC","desire","white",50000,40,false,false);

Answer 13

while (itr.hasNext()) {
Vehicle vc=(Vehicle) itr.next();
if(vc.getVehicleType().equalsIgnoreCase(s)) {
count++;
}
}