En Java, existe-t-il un objet qui agit comme une carte pour stocker et accéder aux paires clé / valeur, mais peut renvoyer une liste ordonnée de clés et une liste ordonnée de valeurs, de sorte que les listes de clés et de valeurs soient dans le même ordre?

Donc, en tant qu'explication par code, je cherche quelque chose qui se comporte comme mon OrderedMap fictif:

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

L' interface SortedMap (avec l'implémentation TreeMap ) devrait être votre ami.

L'interface a les méthodes:

• keySet() qui renvoie un ensemble de clés dans l'ordre croissant
• values() qui retourne une collection de toutes les valeurs dans l'ordre croissant des clés correspondantes

Cette interface répond donc exactement à vos besoins. Cependant, les clés doivent avoir un ordre significatif. Sinon, vous pouvez utiliser le LinkedHashMap où l'ordre est déterminé par l'ordre d'insertion.

Existe-t-il un objet qui agit comme une carte pour stocker et accéder aux paires clé / valeur, mais peut renvoyer une liste ordonnée de clés et une liste ordonnée de valeurs, de sorte que les listes de clés et de valeurs soient dans le même ordre?

Vous recherchez java.util.LinkedHashMap . Vous obtiendrez une liste de paires Map.Entry <K, V> , qui sont toujours itérées dans le même ordre. Cet ordre est le même que l'ordre dans lequel vous placez les éléments. Vous pouvez également utiliser java.util.SortedMap , où les clés doivent avoir un ordre naturel ou le spécifier par un Comparator.

LinkedHashMap maintient l'ordre des clés.

java.util.LinkedHashMap semble fonctionner comme un HashMap normal dans le cas contraire.

Je pense que la collection la plus proche que vous obtiendrez du cadre est le SortedMap

Vous pouvez tirer parti de l' interface NavigableMap qui peut être consultée et parcourue dans l'ordre croissant ou décroissant des clés. Cette interface est destinée à remplacer l'interface SortedMap. La carte navigable est généralement triée en fonction de l'ordre naturel de ses clés, ou par un comparateur fourni au moment de la création de la carte.

Il existe trois implémentations les plus utiles: TreeMap , ImmutableSortedMap et ConcurrentSkipListMap .

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

Production:

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

Je pense que l'interface SortedMap applique ce que vous demandez et TreeMap l'implémente.

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

Depuis Java 6, il existe également une alternative thread-safe non bloquante à TreeMap . Voir ConcurrentSkipListMap .

tl; dr

Pour conserver Map< Integer , String >un ordre trié par clé, utilisez l'une des deux classes implémentant les interfaces SortedMap/ NavigableMap:

• TreeMap
• ConcurrentSkipListMap

Si vous manipulez la carte dans un seul thread, utilisez le premier TreeMap,. Si vous manipulez sur des threads, utilisez le second ConcurrentSkipListMap,.

Pour plus de détails, consultez le tableau ci-dessous et la discussion suivante.

Détails

Voici un tableau graphique que j'ai fait montrant les fonctionnalités des dix Mapimplémentations fournies avec Java 11.

L' NavigableMapinterface est ce qui SortedMapaurait dû être en premier lieu. La SortedMaplogique devrait être supprimée mais ne peut pas l'être car certaines implémentations de cartes tierces peuvent utiliser l'interface.

Comme vous pouvez le voir dans ce tableau, seules deux classes implémentent les interfaces SortedMap/ NavigableMap:

• TreeMap
• ConcurrentSkipListMap

Ces deux conservent les clés dans l'ordre trié, soit par leur ordre naturel (en utilisant la compareTométhode du Comparable( https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/ Comparable.html ) ou par une Comparatorimplémentation que vous passez. La différence entre ces deux classes est que la seconde ConcurrentSkipListMap, est thread-safe , hautement concurrente .

Voir également la colonne Ordre d'itération dans le tableau ci-dessous.

• La LinkedHashMapclasse renvoie ses entrées par l'ordre dans lequel elles ont été insérées à l'origine .
• EnumMaprenvoie les entrées dans l'ordre dans lequel la classe d'énumération de la clé est définie . Par exemple, une carte indiquant quel employé couvre quel jour de la semaine ( Map< DayOfWeek , Person >) utilise la DayOfWeekclasse enum intégrée à Java. Cette énumération est définie avec lundi premier et dimanche dernier. Les entrées d'un itérateur apparaîtront donc dans cet ordre.

Les six autres implémentations ne font aucune promesse quant à l'ordre dans lequel elles signalent leurs entrées.

J'ai utilisé la carte Simple Hash, la liste chaînée et les collections pour trier une carte par valeurs.

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

La sortie est:

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