In Java, esiste un oggetto che agisce come una mappa per archiviare e accedere a coppie chiave / valore, ma può restituire un elenco ordinato di chiavi e un elenco ordinato di valori, in modo tale che gli elenchi chiave e valore siano nello stesso ordine?

Quindi, come spiegazione per codice, sto cercando qualcosa che si comporti come la mia mappa ordinata fittizia:

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

Il SortedMap di interfaccia (con l'implementazione TreeMap ) dovrebbe essere tuo amico.

L'interfaccia ha i metodi:

• keySet() che restituisce un set di chiavi in ​​ordine crescente
• values() che restituisce una raccolta di tutti i valori in ordine crescente delle chiavi corrispondenti

Quindi questa interfaccia soddisfa esattamente le tue esigenze. Tuttavia, le chiavi devono avere un ordine significativo. Altrimenti è possibile utilizzare LinkedHashMap in cui l'ordine è determinato dall'ordine di inserzione.

Esiste un oggetto che agisce come una mappa per memorizzare e accedere a coppie chiave / valore, ma può restituire un elenco ordinato di chiavi e un elenco ordinato di valori, in modo tale che gli elenchi chiave e valore siano nello stesso ordine?

Stai cercando java.util.LinkedHashMap . Otterrai un elenco di coppie Map.Entry <K, V> , che vengono sempre ripetute nello stesso ordine. Tale ordine è uguale all'ordine in cui si inseriscono gli articoli. In alternativa, utilizzare java.util.SortedMap , dove le chiavi devono avere un ordinamento naturale o averlo specificato da a Comparator.

LinkedHashMap mantiene l'ordine delle chiavi.

java.util.LinkedHashMap sembra funzionare come una normale HashMap altrimenti.

Penso che la raccolta più vicina che otterrai dal framework sia SortedMap

È possibile sfruttare l' interfaccia NavigableMap a cui è possibile accedere e attraversare in ordine crescente o decrescente. Questa interfaccia è destinata a sostituire l'interfaccia SortedMap. La mappa navigabile viene solitamente ordinata in base all'ordinamento naturale delle sue chiavi o da un comparatore fornito al momento della creazione della mappa.

Ci sono tre maggior parte delle implementazioni utili di esso: TreeMap , ImmutableSortedMap e ConcurrentSkipListMap .

Esempio di 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) + ")");
}

Produzione:

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

Penso che l'interfaccia SortedMap applichi ciò che chiedi e 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

Da Java 6 esiste anche un'alternativa thread-safe non bloccante a TreeMap . Vedi ConcurrentSkipListMap .

tl; dr

Per mantenere Map< Integer , String >un ordine ordinato per chiave, utilizzare una delle due classi che implementano le interfacce SortedMap/ NavigableMap:

• TreeMap
• ConcurrentSkipListMap

Se si manipola la mappa all'interno di un singolo thread, utilizzare il primo TreeMap,. Se manipoli tra i thread, usa il secondo ConcurrentSkipListMap,.

Per i dettagli, vedere la tabella seguente e la seguente discussione.

Dettagli

Ecco una tabella grafica che ho creato che mostra le funzionalità delle dieci Mapimplementazioni in bundle con Java 11.

L' NavigableMapinterfaccia è quella che SortedMapavrebbe dovuto essere in primo luogo. Il SortedMaplogicamente dovrebbe essere rimosso ma non può essere poiché alcune implementazioni di mappe di terze parti potrebbero utilizzare l'interfaccia.

Come puoi vedere in questa tabella, solo due classi implementano le interfacce SortedMap/ NavigableMap:

• TreeMap
• ConcurrentSkipListMap

Entrambi mantengono le chiavi in ​​ordine ordinato, sia per il loro ordine naturale (usando il compareTometodo del Comparable( https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/ Comparable.html )) o tramite Comparatorun'implementazione che passi. La differenza tra queste due classi è che la seconda ConcurrentSkipListMap, è thread-safe , altamente concorrenziale .

Vedi anche la colonna Ordine di iterazione nella tabella seguente.

• La LinkedHashMapclasse restituisce le voci in base all'ordine in cui sono state inizialmente inserite .
• EnumMaprestituisce le voci nell'ordine in cui è definita la classe enum della chiave . Ad esempio, una mappa di quale dipendente copre quale giorno della settimana ( Map< DayOfWeek , Person >) utilizza la DayOfWeekclasse enum integrata in Java. Quell'enum è definito con lunedì primo e domenica scorso. Quindi le voci in un iteratore appariranno in quell'ordine.

Le altre sei implementazioni non promettono l'ordine in cui riportano le loro voci.

Ho usato la mappa Hash semplice, l'elenco collegato e le raccolte per ordinare una mappa in base ai valori.

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

L'output è:

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