En Java, ¿hay un objeto que actúa como un Mapa para almacenar y acceder a pares clave / valor, pero puede devolver una lista ordenada de claves y una lista ordenada de valores, de modo que las listas clave y de valores estén en el mismo orden?

Entonces, como explicación por código, estoy buscando algo que se comporte como mi OrderedMap ficticio:

OrderedMap<Integer, String> om = new OrderedMap<>();
om.put(0, "Zero");
om.put(7, "Seven");

String o = om.get(7); // o is "Seven"
List<Integer> keys = om.getKeys();
List<String> values = om.getValues();

for(int i = 0; i < keys.size(); i++)
{
    Integer key = keys.get(i);
    String value = values.get(i);
    Assert(om.get(key) == value);
}

La interfaz SortedMap (con la implementación TreeMap ) debería ser tu amiga.

La interfaz tiene los métodos:

• keySet() que devuelve un conjunto de claves en orden ascendente
• values() que devuelve una colección de todos los valores en el orden ascendente de las claves correspondientes

Entonces, esta interfaz cumple exactamente sus requisitos. Sin embargo, las claves deben tener un orden significativo. De lo contrario, puede usar LinkedHashMap donde el orden está determinado por el orden de inserción.

¿Hay un objeto que actúa como un Mapa para almacenar y acceder a pares clave / valor, pero puede devolver una lista ordenada de claves y una lista ordenada de valores, de modo que las listas clave y de valores estén en el mismo orden?

Estás buscando java.util.LinkedHashMap . Obtendrá una lista de pares Map.Entry <K, V> , que siempre se iteran en el mismo orden. Ese orden es el mismo por el que coloca los elementos. Alternativamente, use java.util.SortedMap , donde las claves deben tener un orden natural o tenerlo especificado por a Comparator.

LinkedHashMap mantiene el orden de las claves.

java.util.LinkedHashMap parece funcionar como un HashMap normal de lo contrario.

Creo que la colección más cercana que obtendrás del framework es SortedMap

Puede aprovechar la interfaz NavigableMap a la que se puede acceder y atravesar en orden ascendente o descendente. Esta interfaz está diseñada para reemplazar la interfaz SortedMap. El mapa navegable generalmente se ordena de acuerdo con el orden natural de sus teclas, o por un comparador proporcionado en el momento de la creación del mapa.

Hay tres mayoría de las implementaciones útiles de la misma: TreeMap , ImmutableSortedMap y ConcurrentSkipListMap .

Ejemplo de TreeMap:

TreeMap<String, Integer> users = new TreeMap<String, Integer>();
users.put("Bob", 1);
users.put("Alice", 2);
users.put("John", 3);

for (String key: users.keySet()) {
  System.out.println(key + " (ID = "+ users.get(key) + ")");
}

Salida:

Alice (ID = 2)
Bob (ID = 1)
John (ID = 3)

Creo que la interfaz SortedMap hace cumplir lo que pides y TreeMap lo implementa.

http://java.sun.com/j2se/1.5.0/docs/api/java/util/SortedMap.html http://java.sun.com/j2se/1.5.0/docs/api/java/util /TreeMap.html

Desde Java 6 también existe una alternativa segura y sin bloqueo de subprocesos a TreeMap . Ver ConcurrentSkipListMap .

tl; dr

Para mantener Map< Integer , String >un orden ordenado por clave, use cualquiera de las dos clases que implementan las interfaces SortedMap/ NavigableMap:

• TreeMap
• ConcurrentSkipListMap

Si manipula el mapa dentro de un solo hilo, use el primero TreeMap,. Si manipula a través de hilos, use el segundo,ConcurrentSkipListMap ,.

Para más detalles, consulte la tabla a continuación y la siguiente discusión.

Detalles

Aquí hay una tabla gráfica que hice mostrando las características de los diez Map implementaciones incluidas con Java 11.

La NavigableMapinterfaz es lo que SortedMapdebería haber sido en primer lugar. losSortedMap lógica debe ser retirado, pero no puede ser tan algunas implementaciones mapa tercera partes pueden estar usando la interfaz.

Como puede ver en esta tabla, solo dos clases implementan las interfaces SortedMap/ NavigableMap:

• TreeMap
• ConcurrentSkipListMap

Ambos mantienen las claves en orden, ya sea por su orden natural (utilizando el compareTométodo de Comparable( https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/ Comparable.html ) interfaz) o por una Comparatorimplementación que pasa. La diferencia entre estas dos clases es que la segunda ConcurrentSkipListMapes segura para subprocesos , altamente concurrente .

Consulte también la columna Orden de iteración en la tabla a continuación.

• La LinkedHashMapclase devuelve sus entradas por el orden en que se insertaron originalmente .
• EnumMapdevuelve entradas en el orden en que se define la clase enum de la clave . Por ejemplo, un mapa de qué empleado cubre qué día de la semana ( Map< DayOfWeek , Person >) usa la DayOfWeekclase enum integrada en Java. Esa enumeración se define con el lunes primero y el domingo pasado. Entonces las entradas en un iterador aparecerán en ese orden.

Las otras seis implementaciones no prometen el orden en que informan sus entradas.

He usado el mapa Simple Hash, la lista vinculada y las Colecciones para ordenar un Mapa por valores.

import java.util.*;
import java.util.Map.*;
public class Solution {

    public static void main(String[] args) {
        // create a simple hash map and insert some key-value pairs into it
        Map<String, Integer> map = new HashMap<String, Integer>();
        map.put("Python", 3);
        map.put("C", 0);
        map.put("JavaScript", 4);
        map.put("C++", 1);
        map.put("Golang", 5);
        map.put("Java", 2);
        // Create a linked list from the above map entries
        List<Entry<String, Integer>> list = new LinkedList<Entry<String, Integer>>(map.entrySet());
        // sort the linked list using Collections.sort()
        Collections.sort(list, new Comparator<Entry<String, Integer>>(){
        @Override
         public int compare(Entry<String, Integer> m1, Entry<String, Integer> m2) {
        return m1.getValue().compareTo(m2.getValue());
        }
      });
      for(Entry<String, Integer> value: list) {
         System.out.println(value);
     }
   }
}

El resultado es:

C=0
C++=1
Java=2
Python=3
JavaScript=4
Golang=5