Un KeyValuePair en Java

Je suis à la recherche d'un KeyValuePair classe en Java.

Depuis java.util lourdement utilise des interfaces n'est pas mise en œuvre concrète, seulement la Carte.Interface de saisie.

Est-il canonique de la mise en œuvre, je peux importer?
Il est l'un de ces "plombiers de la programmation des classes" je déteste mettre en œuvre 100x fois.

Je le recommande contre l'utilisation d'un générique KeyValuePair classe. Beaucoup mieux à définir un domaine spécifique de la classe avec le plus instructif des accesseurs (par exemple getProductId(), getProductPrice()).
Je suis en désaccord. Nous n'utilisons pas de domaine spécifique Map ou List classes, pourquoi devrait-il en être autrement? Un KeyValuePair est juste une Carte avec une entrée.
Juste point, mais je pense que le concept générique d'une Paire est plus facilement ouverte à des abus que le passage de l'Collections autour. Par exemple, si quelqu'un veut retourner deux valeurs à partir d'une méthode, il est tentant de retourner une Paire<X,Y> mais en général, cela est révélateur d'une conception sous-jacente du problème (par exemple, Pourquoi ne pas en X et Y unifiée en quelque sorte de toute façon dans le modèle de domaine si ils sont intrinsèquement liés?)
Parce que ce n'est pas <X,Y>, c'est <Key,Value>. Il n'est pas de demander de l'arbitraire d'un Pair type, il demande à un KeyValuePair type.
Malgré cela, je préfère les passer autour d'une seule instance de l'objet dans mon code, potentiellement avec un getKey() la méthode définie; par exemple, je préfère: processProduct(Produit) processProduct(KeyValuePair<Integer, Produit>) où le nombre Entier est l'ID de produit. Je suis d'accord que KeyValuePair (c'est à dire la Carte.Entry) ou même un générique Paire est utile dans une logique de la méthode, mais je ne l'aime pas de "fuite" comme un type de retour ou être fourni comme un paramètre de méthode; par exemple, je n'ai jamais passer autour de la Carte.De l'entrée.

InformationsquelleAutor maayank | 2010-06-04

java key-value

228

La documentation AbstractMap.SimpleEntry est générique et peut être utile.
- ...ou AbstractMap.SimpleImmutableEntry le cas échéant.
- Je devrais donc utiliser List<AbstractMap.SimpleEntry> correct?
- Mieux utiliser AbstractMap.SimpleEntry / AbstractMap.SimpleImmutableEntry comme base pour votre propre domaine spécifique de la classe, d'être OO. Dans le simplemost cas, il est juste de donner un nouveau nom à la classe et les deux éléments.
- Dans l'intérêt des bonnes pratiques, il convient de noter que dans la plupart des cas java.util.Map.Entry<K, V> devrait être utilisé dans le but de programmer des interfaces. Donc, vous devriez être en utilisant List<Map.Entry<K, V>>, par exemple, pour la même raison, vous ne l'utilisez ArrayList<AbstractMap.SimpleEntry<K,V>> dans la consommation de code. Le code que crée l'instance doit utiliser un béton de classe, évidemment.
InformationsquelleAutor Eyal Schneider
96

Android les programmeurs pourraient utiliser BasicNameValuePair

Mise à jour:

BasicNameValuePair est maintenant obsolète API (22).
Utilisation Paire à la place.

Exemple d'utilisation:
```
Pair<Integer, String> simplePair = new Pair<>(42, "Second");
Integer first = simplePair.first; //42
String second = simplePair.second; //"Second"
```
- Ce n'est pas seulement pour Android programmeurs, c'est tout un programme en java.
- oui tout programmeur java pourrait télécharger jar à partir de hc.apache.org mais android a ceux construit en
- En fait pour les utilisateurs d'Android, un bon choix est android.util.Paire.
- pourquoi est-ce? Il est ajouté à 5 de l'api de niveau.
- Ce n'est pas universellement disponibles pour le langage et requièrent plus d'une norme JRE runtime. Pair vient de javafx.util, qui introduit une dépendance sur JavaFX, comme OracleJDK, OpenJDK ou OpenJFX. Si vous utilisez l'un de ces temps d'exécution Java puis une grande, mais il n'y a pas moyen trivial pour l'ajouter à une installation JRE avec un Maven ou Gradle de dépendance.
InformationsquelleAutor kreker
42

La Paire catégorie de Commons Lang qui pourraient vous aider:
```
Pair<String, String> keyValue = new ImmutablePair("key", "value");
```
Bien sûr, vous devez inclure commons-lang.
- L'url ne fonctionne pas
- url changements de temps à autre. J'ai googlé Paire Commons Lang" et il l'a trouvé. J'ai enlevé le lien pour prévenir d'autres downvotes 🙁
- android.util.Pair
- Depuis la 1.6 il y a eu java.util.AbstractMap.SimpleEntry - ce qui rend les communes Paire redondante.
- Je préfère communes Paire personnellement - ne pas avoir à creuser pour une classe à l'intérieur de AbstractMap. Mais si vous ne voulez pas dépendre de l'commons lang pour une raison quelconque, je pouvais le voir.
InformationsquelleAutor remipod
13

Utilisation de javafx.util.Paire est suffisant pour la plupart des simples Clé-Valeur appariements entre les deux types qui peuvent être instanciées.
```
Pair<Integer, String> myPair = new Pair<>(7, "Seven");
Integer key = myPair.getKey();
String value = myPair.getValue();
```
- C'est disponible sur Android (Bibliothèque de prise en charge), trop.
- Il n'est pas disponible dans le serveur de JDK (sans tête) ou à partir de Java 1.9 jusqu'.
InformationsquelleAutor AaronCarson

import java.util.Map;

public class KeyValue<K, V> implements Map.Entry<K, V>
{
    private K key;
    private V value;

    public KeyValue(K key, V value)
    {
        this.key = key;
        this.value = value;
    }

    public K getKey()
    {
        return this.key;
    }

    public V getValue()
    {
        return this.value;
    }

    public K setKey(K key)
    {
        return this.key = key;
    }

    public V setValue(V value)
    {
        return this.value = value;
    }
}

InformationsquelleAutor Neoheurist

J'aime utiliser

Propriétés

Exemple:

Properties props = new Properties();

props.setProperty("displayName", "Jim Wilson"); //(key, value)

String name = props.getProperty("displayName"); //=> Jim Wilson

String acctNum = props.getProperty("accountNumber"); //=> null

String nextPosition = props.getProperty("position", "1"); //=> 1

Si vous êtes familier avec une table de hachage, vous sera très familier avec ce déjà

InformationsquelleAutor Nathan Clark Baumgartner

0

Mon préféré est
```
HashMap<Type1, Type2>
```
Tout ce que vous avez à faire est de spécifier le type de données de la clé pour le Type 1 et le type de données pour la valeur de Type2. C'est la plus commune de la clé-valeur de l'objet que j'ai vu en Java.

https://docs.oracle.com/javase/7/docs/api/java/util/HashMap.html
- Vous semblez avoir manqué une partie de ses qualifications dans cette question. Une collection qui ne correspond pas au besoin d'une seule valeur de la clé de paire. Il mentionne le type de Carte unique entrée, Map.Entry<K,V> mais je voulais un cas plus général. Ce type peut être instanciée directement, voir cette réponse: stackoverflow.com/a/3110563/3251909
- Gros problème avec cela est que la table de hachage ne permet pas de conserver l'ordre.
InformationsquelleAutor Matthew Park
0

J'ai publié un NameValuePair classe dans GlobalMentor de base de la bibliothèque, disponible dans Maven. C'est un projet en cours avec une longue histoire, donc veuillez soumettre toute demande de modifications ou améliorations.

InformationsquelleAutor Garret Wilson

Vous devez vous connecter pour publier un commentaire.