dictionary sort - ¿Cómo ordenar los valores del mapa por clave en Java?





by key (12)


Solo usa TreeMap

new TreeMap<String, String>(unsortMap);

Tenga en cuenta que el TreeMap se clasifica de acuerdo con el orden natural de sus 'claves'

Tengo un mapa que tiene cadenas tanto para claves como para valores.

Los datos son como los siguientes:

"pregunta 1", "1"
"pregunta 9", "1"
"pregunta 2", "4"
"pregunta 5", "2"

Quiero ordenar el mapa en función de sus claves. Entonces, al final, tendré la question1, question2, question3 ... y así sucesivamente.


Finalmente, estoy tratando de obtener dos cadenas de este mapa.

  • Primera Cadena: Preguntas (en orden 1 ..10)
  • Segunda cadena: Respuestas (en el mismo orden que la pregunta)

Ahora mismo tengo lo siguiente:

Iterator it = paramMap.entrySet().iterator();
while (it.hasNext()) {
    Map.Entry pairs = (Map.Entry) it.next();
    questionAnswers += pairs.getKey() + ",";
}

Esto me pone las preguntas en una cadena pero no están en orden.




En Java 8 también puedes usar .stream (). Sorted ():

myMap.keySet().stream().sorted().forEach(key -> {
        String value = myMap.get(key);

        System.out.println("key: " + key);
        System.out.println("value: " + value);
    }
);



También podemos ordenar la clave utilizando el método Arrays.sort.

Map<String, String> map = new HashMap<String, String>();
Object[] objArr = new Object[map.size()];
for (int i = 0; i < map.size(); i++) {
objArr[i] = map.get(i);
}
Arrays.sort(objArr);
for (Object str : objArr) {
System.out.println(str);
}



En java 8

Para ordenar un Map<K, V> por clave, coloque las claves en una List<K> :

List<K> result = map.keySet().stream().sorted().collect(Collectors.toList());

Para ordenar un Map<K, V> por clave, List<Map.Entry<K, V>> entradas en una List<Map.Entry<K, V>> :

List<Map.Entry<K, V>> result =
    map.entrySet()
       .stream()
       .sorted(Map.Entry.comparingByKey())
       .collect(Collectors.toList());

Por último, pero no menos importante: para ordenar las cadenas de una manera sensible al entorno local, use una Collator (comparador):

Collator collator = Collator.getInstance(Locale.US);
collator.setStrength(Collator.PRIMARY); // case insensitive collator

List<Map.Entry<String, String>> result =
    map.entrySet()
       .stream()
       .sorted(Map.Entry.comparingByKey(collator))
       .collect(Collectors.toList());



Utilizando Java 8:

Map<String, Integer> sortedMap = unsortMap.entrySet().stream()
            .sorted(Map.Entry.comparingByKey())
            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue,
                    (oldValue, newValue) -> oldValue, LinkedHashMap::new));



Usando el TreeMap puedes ordenar el mapa.

Map<String, String> map = new HashMap<>();        
Map<String, String> treeMap = new TreeMap<>(map);
for (String str : treeMap.keySet()) {
    System.out.println(str);
}



List<String> list = new ArrayList<String>();
Map<String, String> map = new HashMap<String, String>();
for (String str : map.keySet()) {
 list.add(str);
}
Collections.sort(list);
for (String str : list) {
 System.out.println(str);
}






Si ya tiene un mapa y desea clasificarlo por teclas, simplemente use:

Map<String, String> treeMap = new TreeMap<String, String>(yourMap);

Un ejemplo completo de trabajo:

import java.util.HashMap;
import java.util.Set;
import java.util.Map;
import java.util.TreeMap;
import java.util.Iterator;

class SortOnKey {

public static void main(String[] args) {
   HashMap<String,String> hm = new HashMap<String,String>();
   hm.put("3","three");
   hm.put("1","one");
   hm.put("4","four");
   hm.put("2","two");
   printMap(hm);
   Map<String, String> treeMap = new TreeMap<String, String>(hm);
   printMap(treeMap);
}//main

public static void printMap(Map<String,String> map) {
    Set s = map.entrySet();
    Iterator it = s.iterator();
    while ( it.hasNext() ) {
       Map.Entry entry = (Map.Entry) it.next();
       String key = (String) entry.getKey();
       String value = (String) entry.getValue();
       System.out.println(key + " => " + value);
    }//while
    System.out.println("========================");
}//printMap

}//class



Siempre que no pueda usar TreeMap , en Java 8 podemos usar el método toMap() en Collectors que toma los siguientes parámetros:

  • keymapper : función de mapeo para producir claves
  • valuemapper : función de mapeo para producir valores
  • mergeFunction : una función de combinación, utilizada para resolver colisiones entre valores asociados con la misma clave
  • mapSupplier : una función que devuelve un mapa nuevo y vacío en el que se insertarán los resultados.

Ejemplo de Java 8

Map<String,String> sample = new HashMap<>();  // push some values to map  
Map<String, String> newMapSortedByKey = sample.entrySet().stream()
                    .sorted(Map.Entry.<String,String>comparingByKey().reversed())
                    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
Map<String, String> newMapSortedByValue = sample.entrySet().stream()
                        .sorted(Map.Entry.<String,String>comparingByValue().reversed())
                        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1,e2) -> e1, LinkedHashMap::new));

Podemos modificar el ejemplo para usar un comparador personalizado y para ordenar según las claves como:

Map<String, String> newMapSortedByKey = sample.entrySet().stream()
                .sorted((e1,e2) -> e1.getKey().compareTo(e2.getKey()))
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1,e2) -> e1, LinkedHashMap::new));



Asumir que TreeMap no es bueno para usted (y suponiendo que no puede usar genéricos):

List sortedKeys=new ArrayList(yourMap.keySet());
Collections.sort(sortedKeys);
// Do what you need with sortedKeys.



Si tiene curiosidad acerca de aún más optimizaciones que se pueden hacer a este código, considere esto:

Comenzando con el bucle original:

for (unsigned i = 0; i < 100000; ++i)
{
    for (unsigned j = 0; j < arraySize; ++j)
    {
        if (data[j] >= 128)
            sum += data[j];
    }
}

Con el intercambio de bucles, podemos cambiar con seguridad este bucle a:

for (unsigned j = 0; j < arraySize; ++j)
{
    for (unsigned i = 0; i < 100000; ++i)
    {
        if (data[j] >= 128)
            sum += data[j];
    }
}

Luego, puede ver que el condicional if es constante durante la ejecución del bucle i , por lo que puede levantar el if :

for (unsigned j = 0; j < arraySize; ++j)
{
    if (data[j] >= 128)
    {
        for (unsigned i = 0; i < 100000; ++i)
        {
            sum += data[j];
        }
    }
}

Luego, verá que el bucle interno se puede contraer en una sola expresión, asumiendo que el modelo de punto flotante lo permite (/ fp: se lanza rápido, por ejemplo)

for (unsigned j = 0; j < arraySize; ++j)
{
    if (data[j] >= 128)
    {
        sum += data[j] * 100000;
    }
}

Ese es 100.000 veces más rápido que antes





java dictionary hashmap