Comment puis-je analyser une carte (foreach) dans le même ordre que je l'ai créé (JAVA)

Question

Donc j'ai une carte que j'ai créée (données insérées) dans l'ordre que je voulais. Lors de l'analyse de la carte, la première clé renvoyée dans foreach n'est pas la première clé insérée. Y a-t-il un moyen pour que cela se produise?

Le tri de ma carte est également difficile car il doit être trié par valeur et dans un champ spécifique de la valeur. Ty

Answer 1

Voyons voir. Vos exigences semblent être:

1. Vous avez un ensemble de paires clé/valeur, où les clés sont uniques.
2. Vous souhaitez pouvoir rechercher rapidement la valeur d'une clé donnée.
3. Vous souhaitez pouvoir parcourir les touches (ou paires) dans l'ordre d'insertion.
4. Vous souhaitez pouvoir parcourir les valeurs dans l'ordre d'un champ du type de valeur.

Aucune classe de collection Java standard ne satisfait à toutes ces exigences. Et je ne pense pas que les collections Commons ou les collections Google seraient non plus ...

Si vous deviez supprimer la condition 3, un TreeSet (instancié avec un Comparator personnalisé) ferait l'affaire. Si vous deviez éliminer l'exigence 4, alors un LinkedHashMap ferait l'affaire.

Pour satisfaire toutes les exigences que vous devez faire une des opérations suivantes:

• Utilisez un LinkedHashMap, et quand vous voulez itérer dans un certain ordre en fonction des valeurs extrait collection values de la carte, les trier en utilisant votre comparateur personnalisé et renvoient un itérateur pour la collection triée.

• Utilisez à la fois un LinkedHashMap et un et mettez à jour les deux en parallèle.

• Créez une classe de fascias personnalisée pour un LinkedHashMap et un TreeMap. Cela doit maintenir les deux structures de données à jour lorsque vous appelez put, remove etcetera, et également fournir des méthodes supplémentaires pour obtenir les valeurs triées.

Answer 2

Extrayez http://java.sun.com/j2se/1.4.2/docs/api/java/util/LinkedHashMap.html pour une implémentation de Map avec un ordre d'itération prévisible. Vous pouvez également envisager d'utiliser une liste si vous ne faites pas de recherche par clé.

Answer 3

Si vous pouvez trier vos éléments à l'avance par l'attribut value, vous pouvez utiliser un LinkedListHashMap, car cela préserve l'ordre que vous spécifiez. Cependant, cela semble un peu fragile, et ne convient pas si vous avez besoin d'ajouter plus d'éléments à la carte plus tard. L'alternative est de stocker les valeurs dans une liste, triées selon vos besoins, et d'utiliser la recherche binaire pour récupérer les éléments et trouver le point d'insertion pour les nouveaux éléments.

Vous pouvez même envelopper tout cela et le placer derrière une interface Map.

La classe Collections fournit binarySearch. Voici un aperçu:

• Mettez votre classe de valeur dans une liste, List<Value> values.
• Implémentez une classe Comparable<Value> qui compare les valeurs à l'aide de l'attribut sur lequel vous souhaitez les trier. Utilisez le Comparator<Value> pour trier la liste.
• Maintenant que la liste est triée, vous pouvez utiliser Collections.binarySearch(values, aValue, Comparator<Value>) pour trouver l'index de la valeur réelle. Notez que aValue n'est pas une valeur réelle - c'est une valeur avec les attributs définis pour fournir la clé, mais le reste n'est pas initialisé. La valeur aValue est utilisée uniquement pour contenir la clé de tri.

Dans le code

List<Value> values = new ArrayList<Values>(); 
// .. add values 
values.add(new Value(key, data1, data2, etc..)); 
Comparator<Value> compValue = new Comparator<Value>() { 
    public int compare(Value v1, Value v2) { 
    return v1.getKey()>v2.getKey(); 
    } 
} 

Collections.sort(values, compValue); 
// now we can search on key 
int index = Collections.binarySearch(values, new Value(keyTofind), valueComp); 
Value foundValue = null; // value with the key may not be in the list 
if (index>=0) 
    foundValue = values.get(index); 

// we can also update the list 
Value newValue = new Value(key, data, data2, etc...); 
int insert = Collections.binarySearch(values, newValue, valueComp); 
// insert will be negative 
values.add((-insert)-1, newValue); 

EDIT: Si vous enveloppez cela dans une interface cartographique, par exemple En prolongeant AbstractMap, il sera sérialisable.