Java - Comment créer une nouvelle entrée( clé, valeur)
Je voudrais créer un nouvel élément similaire à Util.Map.Entry qui contiendra la structure key, value.
Le problème est que je ne peux pas instancier un Map.Entry parce que c'est une interface.
Quelqu'un sait-il comment créer un nouvel objet clé/valeur générique pour Map?Entrée?
9 answers
Vous pouvez simplement implémenter l'interface Map.Entry<K, V> vous-même:
import java.util.Map;
final class MyEntry<K, V> implements Map.Entry<K, V> {
private final K key;
private V value;
public MyEntry(K key, V value) {
this.key = key;
this.value = value;
}
@Override
public K getKey() {
return key;
}
@Override
public V getValue() {
return value;
}
@Override
public V setValue(V value) {
V old = this.value;
this.value = value;
return old;
}
}
Puis utilisez-le:
Map.Entry<String, Object> entry = new MyEntry<String, Object>("Hello", 123);
System.out.println(entry.getKey());
System.out.println(entry.getValue());
Il y a public static class AbstractMap.SimpleEntry<K,V>. Ne laissez pas la partie Abstract du nom vous induire en erreur: ce n'est en fait PAS une classe abstract (mais son niveau supérieur AbstractMap est).
Le fait que c'est une classe imbriquée static signifie que vous N'avez PAS besoin d'une instance AbstractMap englobante pour l'instancier, donc quelque chose comme ça compile bien:
Map.Entry<String,Integer> entry =
new AbstractMap.SimpleEntry<String, Integer>("exmpleString", 42);
Comme indiqué dans une autre réponse, Goyave a aussi une commode static méthode de fabrique Maps.immutableEntry que vous pouvez utiliser.
Vous avez dit:
Je ne peux pas utiliser
Map.Entrylui-même car apparemment c'est un objet en lecture seule que je ne peux pas instancier newinstanceof
Ce n'est pas tout à fait exact. La raison pour laquelle vous ne pouvez pas l'instancier directement (c'est à dire avec new) parce que c'est un interface Map.Entry.
Mise en garde et astuce
Comme indiqué dans la documentation, AbstractMap.SimpleEntry est @since 1.6, donc si vous êtes coincé à 5.0, alors il n'est pas disponible pour vous.
Pour rechercher une autre classe connue qui implements Map.Entry, vous pouvez en fait aller directement au javadoc. À partir de la version Java 6
Carte d'interface.Entrée
Toutes les classes d'implémentation connues :
Malheureusement, la version1.5 ne répertorie aucune classe d'implémentation connue que vous pouvez utiliser, vous avez donc peut-être été bloqué avec l'implémentation de la vôtre.
Essayez Cartes.immutableEntry à partir de Goyave
Cela a l'avantage d'être compatible avec Java 5 (contrairement à AbstractMap.SimpleEntry qui nécessite Java 6.)
Exemple de AbstractMap.SimpleEntry:
import java.util.Map;
import java.util.AbstractMap;
import java.util.AbstractMap.SimpleEntry;
Instancier:
ArrayList<Map.Entry<Integer, Integer>> arr =
new ArrayList<Map.Entry<Integer, Integer>>();
Ajouter les lignes:
arr.add(new AbstractMap.SimpleEntry(2, 3));
arr.add(new AbstractMap.SimpleEntry(20, 30));
arr.add(new AbstractMap.SimpleEntry(2, 4));
Extraire les lignes:
System.out.println(arr.get(0).getKey());
System.out.println(arr.get(0).getValue());
System.out.println(arr.get(1).getKey());
System.out.println(arr.get(1).getValue());
System.out.println(arr.get(2).getKey());
System.out.println(arr.get(2).getValue());
Doit imprimer:
2
3
20
30
2
4
C'est bon pour définir les arêtes des structures de graphes. Comme ceux entre les neurones dans votre tête.
Pourquoi Map.Entry? Je suppose que quelque chose comme une paire clé-valeur est adapté au cas.
Utiliser java.util.AbstractMap.SimpleImmutableEntry ou java.util.AbstractMap.SimpleEntry
org.apache.commons.lang3.tuple.Pair implémente java.util.Map.Entry et peut également être utilisé de façon autonome.
Comme d'autres l'ont mentionné, le com.google.common.collect.Maps.immutableEntry(K, V) de goyave fait l'affaire.
Je préfère Pair pour ses couramment Pair.of(L, R) syntaxe.
J'ai défini une classe de paire générique que j'utilise tout le temps. C'est génial. En prime, en définissant une méthode d'usine statique (Paire.créer) Je n'ai qu'à écrire les arguments de type moitié moins souvent.
public class Pair<A, B> {
private A component1;
private B component2;
public Pair() {
super();
}
public Pair(A component1, B component2) {
this.component1 = component1;
this.component2 = component2;
}
public A fst() {
return component1;
}
public void setComponent1(A component1) {
this.component1 = component1;
}
public B snd() {
return component2;
}
public void setComponent2(B component2) {
this.component2 = component2;
}
@Override
public String toString() {
return "<" + component1 + "," + component2 + ">";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result
+ ((component1 == null) ? 0 : component1.hashCode());
result = prime * result
+ ((component2 == null) ? 0 : component2.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
final Pair<?, ?> other = (Pair<?, ?>) obj;
if (component1 == null) {
if (other.component1 != null)
return false;
} else if (!component1.equals(other.component1))
return false;
if (component2 == null) {
if (other.component2 != null)
return false;
} else if (!component2.equals(other.component2))
return false;
return true;
}
public static <A, B> Pair<A, B> create(A component1, B component2) {
return new Pair<A, B>(component1, component2);
}
}
Si vous utilisez Clojure, vous avez une autre option:
(defn map-entry
[k v]
(clojure.lang.MapEntry/create k v))
À partir de Java 9, {[9] } il existe une nouvelle méthode utilitaire permettant de créer une entrée immuable qui est Map#entry(Object, Object).
Voici un exemple simple:
Entry<String, String> entry = Map.entry("foo", "bar");
Comme il est immuable, appeler setValue lancera un UnsupportedOperationException. Les autres limites sont le fait qu'il n'est pas sérialisable et null clé ou la valeur est interdit, si ce n'est pas acceptable pour vous, vous aurez besoin d'utiliser AbstractMap.SimpleImmutableEntry ou AbstractMap.SimpleEntry au lieu de cela.