Em Java, existe um objeto que funciona como um mapa para armazenar e acessar pares de chave / valor, mas pode retornar uma lista ordenada de chaves e uma lista ordenada de valores, de modo que as listas de chaves e valores estejam na mesma ordem?

Portanto, como explicação por código, estou procurando algo que se comporte como meu OrderedMap fictício:

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

O SortedMap de interface (com a implementação TreeMap ) deve ser seu amigo.

A interface possui os métodos:

• keySet() que retorna um conjunto de chaves em ordem crescente
• values() que retorna uma coleção de todos os valores na ordem crescente das chaves correspondentes

Portanto, essa interface atende exatamente aos seus requisitos. No entanto, as chaves devem ter uma ordem significativa. Caso contrário, você pode usar o LinkedHashMap onde o pedido é determinado pelo pedido de inserção.

Existe um objeto que funciona como um mapa para armazenar e acessar pares de chave / valor, mas pode retornar uma lista ordenada de chaves e uma lista ordenada de valores, de modo que as listas de chaves e valores estejam na mesma ordem?

Você está procurando java.util.LinkedHashMap . Você obterá uma lista dos pares Map.Entry <K, V> , que sempre são iterados na mesma ordem. Essa ordem é igual à ordem em que você coloca os itens. Como alternativa, use o java.util.SortedMap , onde as chaves devem ter uma ordem natural ou especificada por a Comparator.

LinkedHashMap mantém a ordem das chaves.

java.util.LinkedHashMap parece funcionar como um HashMap normal, caso contrário.

Eu acho que a coleção mais próxima que você obterá do framework é o SortedMap

Você pode aproveitar a interface NavigableMap que pode ser acessada e atravessada em ordem crescente ou decrescente de chave. Essa interface pretende substituir a interface SortedMap. O mapa navegável geralmente é classificado de acordo com a ordem natural de suas chaves ou por um comparador fornecido no momento da criação do mapa.

Existem três implementações mais úteis: TreeMap , ImmutableSortedMap e ConcurrentSkipListMap .

Exemplo do 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) + ")");
}

Resultado:

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

Eu acho que a interface SortedMap reforça o que você pede e o TreeMap implementa isso.

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 o Java 6, também existe uma alternativa segura e sem bloqueio de threads para o TreeMap . Consulte ConcurrentSkipListMap .

tl; dr

Para manter Map< Integer , String >uma ordem classificada por chave, use uma das duas classes que implementam as interfaces SortedMap/ NavigableMap:

• TreeMap
• ConcurrentSkipListMap

Se estiver manipulando o mapa em um único encadeamento, use o primeiro TreeMap,. Se estiver manipulando threads, use o segundo ConcurrentSkipListMap,.

Para detalhes, consulte a tabela abaixo e a discussão a seguir.

Detalhes

Aqui está uma tabela gráfica que eu criei mostrando os recursos das dez Mapimplementações incluídas no Java 11.

A NavigableMapinterface é o que SortedMapdeveria ter sido em primeiro lugar. A SortedMaplógica deve ser removida, mas não pode ser, pois algumas implementações de mapas de terceiros podem estar usando a interface.

Como você pode ver nesta tabela, apenas duas classes implementam as interfaces SortedMap/ NavigableMap:

• TreeMap
• ConcurrentSkipListMap

Ambos mantêm as chaves na ordem classificada, por ordem natural (usando o compareTométodo de Comparable( https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/ Comparable.html )) ou por uma Comparatorimplementação aprovada. A diferença entre essas duas classes é que a segunda ,,ConcurrentSkipListMap é segura para threads , altamente simultânea .

Consulte também a coluna Ordem de iteração na tabela abaixo.

• A LinkedHashMapclasse retorna suas entradas pela ordem em que foram originalmente inseridas .
• EnumMapretorna entradas na ordem em que a classe enum da chave é definida . Por exemplo, um mapa de qual funcionário está cobrindo qual dia da semana ( Map< DayOfWeek , Person >) usa a DayOfWeekclasse enum incorporada ao Java. Essa enumeração é definida com segunda e domingo, primeiro. Portanto, as entradas em um iterador aparecerão nessa ordem.

As outras seis implementações não prometem a ordem em que relatam suas entradas.

Eu usei o mapa Simple Hash, lista vinculada e coleções para classificar um 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);
     }
   }
}

A saída é:

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