Analyse de neuf problèmes majeurs avec Map en Java

De manière générale, Map est une structure de données composée de paires clé-valeur, et chaque clé est unique dans la collection. Utilisons K et V pour représenter les clés et les valeurs afin d'expliquer les neuf problèmes majeurs de Map en Java.
0. Convertir une carte en type liste
En Java, l'interface Map propose trois méthodes d'acquisition de collection : jeu de clés, jeu de valeurs et jeu de valeurs-clés. Ils peuvent tous être convertis en type List via le constructeur ou la méthode addAll(). Le code suivant illustre comment construire une ArrayList à partir d'une carte :

// key list
List keyList = new ArrayList(map.keySet());
// value list
List valueList = new ArrayList(map.valueSet());
// key-value list
List entryList = new ArrayList(map.entrySet());

1 Parcourir la carte via l'entrée
Cette façon d'exister sous forme de paires clé-valeur en Java est. appelé Map.Entry. Map.entrySet() renvoie un ensemble clé-valeur, qui est une méthode de parcours très efficace.

for(Entry entry: map.entrySet()) {
// get key
K key = entry.getKey();
// get value
V value = entry.getValue();
}

Itérateur Nous l'utilisons aussi souvent, surtout avant JDK1.5

Iterator itr = map.entrySet().iterator();
while(itr.hasNext()) {
Entry entry = itr.next();
// get key
K key = entry.getKey();
// get value
V value = entry.getValue();
}

2. Utilisez Key pour faire correspondre le tri de la carte
Le tri nécessite des opérations fréquentes sur le ke de la carte. Une façon est de l'implémenter via un comparateur :

List list = new ArrayList(map.entrySet());
Collections.sort(list, new Comparator() {
@Override
public int compare(Entry e1, Entry e2) {
return e1.getKey().compareTo(e2.getKey());
}
});

Une autre façon est via SortedMap, mais doit implémenter le Comparable. interface.

SortedMap sortedMap = new TreeMap(new Comparator() {
@Override
public int compare(K k1, K k2) {
return k1.compareTo(k2);
}
});
sortedMap.putAll(map);

3. Trier la carte par valeur
C'est un peu similaire au point précédent, le code est le suivant :

List list = new ArrayList(map.entrySet());
Collections.sort(list, new Comparator() {
@Override
public int compare(Entry e1, Entry e2) {
return e1.getValue().compareTo(e2.getValue());
}
});

4. Initialiser une carte constante statique

Lorsque vous souhaitez créer une carte statique globale, nous avons les deux méthodes suivantes, et elles sont thread-safe.
Dans Test1, bien que nous ayons déclaré que map est statique, nous pouvons toujours changer sa valeur lors de l'initialisation, tout comme Test1.map.put(3,"two");
Dans Test2 , nous passons une classe interne et définissez-le pour qu'il ne soit pas modifiable, puis lorsque nous exécuterons Test2.map.put(3, "trois"), il lancera un

UnsupportedOperationException 异常来禁止你修改。
 public class Test1 {
private static final Map map;
static {
map = new HashMap();
map.put(1, "one");
map.put(2, "two");
}
}
public class Test2 {
private static final Map map;
static {
Map aMap = new HashMap();
aMap.put(1, "one");
aMap.put(2, "two");
map = Collections.unmodifiableMap(aMap);
}
}

Différences entre HashMap, TreeMap, et Hashtable
Dans l'interface Map, il existe trois implémentations : HashMap, TreeMap et Hashtable.
Ils sont différents. Pour plus de détails, veuillez vous référer à l'article "HashMap vs. TreeMap vs. Hashtable vs. LinkedHashMap".

6. Requête inversée dans la carte
Après avoir ajouté une paire clé-valeur à la carte, cela signifie qu'il existe une correspondance biunivoque entre les clés et les valeurs dans la carte. Map, et une clé correspond à une valeur. Mais parfois, nous avons besoin d'une requête inverse, comme trouver sa clé via une certaine valeur. Cette structure de données est appelée carte bidirectionnelle. Malheureusement, le JDK ne la prend pas en charge.
Apache et Guava fournissent conjointement cette implémentation de carte bidirectionnelle, dans l'implémentation, il stipule que les clés et les valeurs doivent avoir une relation 1:1.

7. Copie d'une carte
Java propose de nombreuses méthodes pour copier une carte, mais ces méthodes ne sont pas toujours synchronisées. En termes simples, lorsqu'une carte change, celle copiée reste la même. Ce qui suit est une méthode d'implémentation plus efficace :
Map copiéMap = Collections.synchronizedMap(map);
Bien sûr, il existe une autre méthode, qui est le clonage. Cependant, notre créateur Java, Josh Bloch, ne recommande pas cette approche. Il a dit un jour dans une interview sur la question du clonage de cartes : Les méthodes de clonage sont fournies dans de nombreuses classes parce que les gens en ont vraiment besoin. Mais le clonage est très limitatif et entraîne dans de nombreux cas des effets inutiles.
8. Créer une carte vide
Si cette carte est définie pour être indisponible, cela peut être réalisé via ce qui suit
map = Collections.emptyMap();
Au contraire, lorsque nous l'utilisons , Vous pouvez directement
map = new HashMap();

Ce qui précède est l'intégralité du contenu de cet article. J'espère qu'il sera utile à l'apprentissage de chacun, et j'espère également que tout le monde le fera. prend en charge le site Web PHP chinois.

Pour plus d'articles sur l'analyse des neuf problèmes majeurs de Map en Java, veuillez faire attention au site Web PHP chinois !