Existe-t-il un moyen de mettre un objet Entry
entier en un objet Map
comme:
map.put(entry);
au lieu de passer une paire clé-valeur comme:
map.put(key,value);
?
J'ai effectué une recherche sur les méthodes d'interface de la carte, mais il n'y a pas de méthode permettant à De prendre une entrée et de la placer dans la carte. C'est pourquoi je l'ai implémentéen utilisant un peu d'héritage et des interfaces Java 8.
import Java.util.AbstractMap;
import Java.util.HashMap;
import Java.util.Map;
import Java.util.TreeMap;
public class Maps {
// Test method
public static void main(String[] args) {
Map.Entry<String, String> entry1 = newEntry("Key1", "Value1");
Map.Entry<String, String> entry2 = newEntry("Key2", "Value2");
System.out.println("HashMap");
MyMap<String, String> hashMap = new MyHashMap<>();
hashMap.put(entry1);
hashMap.put(entry2);
for (String key : hashMap.keySet()) {
System.out.println(key + " = " + hashMap.get(key));
}
System.out.println("\nTreeMap");
MyMap<String, String> treeMap = new MyTreeMap<>();
treeMap.put(entry1);
treeMap.put(entry2);
for (String key : treeMap.keySet()) {
System.out.println(key + " = " + treeMap.get(key));
}
}
/**
* Creates a new Entry object given a key-value pair.
* This is just a helper method for concisely creating a new Entry.
* @param key key of the entry
* @param value value of the entry
*
* @return the Entry object containing the given key-value pair
*/
private static <K,V> Map.Entry<K,V> newEntry(K key, V value) {
return new AbstractMap.SimpleEntry<>(key, value);
}
/**
* An enhanced Map interface.
*/
public static interface MyMap<K,V> extends Map<K,V> {
/**
* Puts a whole entry containing a key-value pair to the map.
* @param entry
*/
public default V put(Entry<K,V> entry) {
return put(entry.getKey(), entry.getValue());
}
}
/**
* An enhanced HashMap class.
*/
public static class MyHashMap<K,V> extends HashMap<K,V> implements MyMap<K,V> {}
/**
* An enhanced TreeMap class.
*/
public static class MyTreeMap<K,V> extends TreeMap<K,V> implements MyMap<K,V> {}
}
L'interface MyMap
est simplement une interface qui étend l'interface Map
by en ajoutant une autre méthode, la public default V put(Entry<K,V> entry)
. En plus de la définition de la méthode, une implémentation par défaut est également codée En faisant cela, nous pouvons maintenant ajouter cette méthode à n’importe quelle classe qui implémente L’interface Map
en définissant simplement une nouvelle classe qui implémente l’interface MyMap
et en étendant la classe d’implémentation de la carte de notre choix. Tout cela, en une ligne! Ceci est démontré dans la partie inférieure du code ci-dessus où deux classes Sont créées, chacune prolongeant les implémentations de HashMap et TreeMap
Pour instancier une carte avec des entrées (comme vous pouvez le faire avec Arrays.asList(T... a)
ou Sets.newHashSet(T... a)
dans la bibliothèque Google Guava, j'ai trouvé ceci:
import Java.util.AbstractMap;
import Java.util.Map;
public class MapWithEntries {
private static final Map.Entry<String, String> ENTRY_1 = new AbstractMap.SimpleEntry<>("A", "Hello");
private static final Map.Entry<String, String> ENTRY_2 = new AbstractMap.SimpleEntry<>("B", "World");
private static final Map<String, String> MAP_WITH_ENTRIES = Map.ofEntries(ENTRY_1, ENTRY_2);
}
Le ImmutableMap.Builder
de Guava prend les entrées directement .
Évidemment, cela ne modifie pas directement une Map
existante, mais cela pourrait bien égratigner la même chose.