Classe de paire générique

La nécessité d'une Paire de classe habituellement les cultures en place, dans les grands projets - je suis en train de (re)mettre en œuvre un pour le projet en cours (comme les précédentes implémentations ne sont pas accessibles).

Généralement je fais immuable POJO, avec une fonction de commodité pour créer des instances. Par exemple:

public class Pair<T,U>
{
    public final T first;
    public final U second;
    public static <T,U> Pair<T,U> of(T first, U second);
}

De sorte que l'utilisateur peut écrire:

return Pair.of (a, b);

et

Pair<A,B> p = someThing ();
doSomething (p.first);
doSomethingElse (p.second);

Comme mentionné ci-dessus, la Paire classe doit également mettre en œuvre hashCode(), equals(), facultatif mais utile toString(), comme peut-être le clone() et compareTo() pour une utilisation lorsque ceux-ci sont pris en charge par T et U - si le travail supplémentaire est nécessaire pour décrire la façon dont ces contrats sont pris en charge par la Paire de classe.

Ici est une mise en œuvre à partir de l'Android SDK

/**
 * Container to ease passing around a tuple of two objects. This object provides a sensible
 * implementation of equals(), returning true if equals() is true on each of the contained
 * objects.
 */
public class Pair<F, S> {
    public final F first;
    public final S second;

    /**
     * Constructor for a Pair.
     *
     * @param first the first object in the Pair
     * @param second the second object in the pair
     */
    public Pair(F first, S second) {
        this.first = first;
        this.second = second;
    }

    /**
     * Checks the two objects for equality by delegating to their respective
     * {@link Object#equals(Object)} methods.
     *
     * @param o the {@link Pair} to which this one is to be checked for equality
     * @return true if the underlying objects of the Pair are both considered
     *         equal
     */
    @Override
    public boolean equals(Object o) {
        if (!(o instanceof Pair)) {
            return false;
        }
        Pair<?, ?> p = (Pair<?, ?>) o;
        return Objects.equal(p.first, first) && Objects.equal(p.second, second);
    }

    /**
     * Compute a hash code using the hash codes of the underlying objects
     *
     * @return a hashcode of the Pair
     */
    @Override
    public int hashCode() {
        return (first == null ? 0 : first.hashCode()) ^ (second == null ? 0 : second.hashCode());
    }

    /**
     * Convenience method for creating an appropriately typed pair.
     * @param a the first object in the Pair
     * @param b the second object in the pair
     * @return a Pair that is templatized with the types of a and b
     */
    public static <A, B> Pair <A, B> create(A a, B b) {
        return new Pair<A, B>(a, b);
    }
}

Généralement un générique Paire de type a deux paramètres de type générique, pas - de sorte que vous pourriez avoir (par exemple) un Pair<String, Integer>. C'est généralement plus utile, de l'OMI.

Je dirais aussi que vous pensez est plus classique nom pour votre type de paramètre que la "chose". Par exemple, vous pouvez utiliser Pair<A, B> ou Pair<T, U>.

Après le montage, il semble bon.

Cependant, vous devriez vraiment mettre en œuvre les hashCode et equals de méthodes, de sorte que deux paires contenant les mêmes objets sont égaux les uns aux autres, et peuvent être utilisés comme clés dans une table de hachage. Et toString si vous vous sentez généreux. Ces méthodes ne sont pas tenus de satisfaire aux exigences que vous avez été donnés, mais ils sont des choses qu'un bon programmeur devrait ajouter.

Pas. Avez-vous essayé de coder ça pour voir si ça fonctionne?

Vous semblez avoir raté cette partie de l'exigence:

La classe doit être paramétré sur deux types un pour le premier membre et un pour le deuxième membre de la paire.

Ce qui signifie que la classe devrait probablement être définie comme quelque chose de plus comme:

public class Pair<T1, T2>

et les autres méthodes de mise à jour en conséquence. (En passant, j'ai utilisé T1 et T2 pour désigner les types comme par convention, un court - 1 ou 2 char - identificateur est utilisé).

Aussi,

return thing.first;

et

return thing.second;

ne sont pas aller au travail, comme dans votre exemple, thing est un type, pas un objet. Pensez ce que vous voulez revenir ici. Avez-vous encore besoin d'appeler une méthode?

Une fois que vous avez fait vos modifications, le code, puis d'écrire un test unitaire ou un simple test-harnais pour vérifier si cela fonctionne.

thing est un Variable de Type dans une inhabituelle notation - nous avons l'habitude d'utiliser une majuscule-ci (comme T). Ensuite: une variable de type n'a pas de méthodes, de sorte que votre getters ne compile pas.

Rapide amélioration: remplacer tous les thing avec T

Solution rapide pour les accesseurs:

public T getFirst() {
 return first;
}

public T getSecond() {
 return second;
}

---

Une exigence était de permettre à deux types différents pour la paire de membres. Donc la classe de signature devrait ressembler à:

public Pair<S,T> {
  private S first;
  private T second;
  //...
}

J'ai mis en place quelque chose de similaire, mais avec statique builder et les chaînes de setters

public class Pair<R, L> {
private R left;
private L right;
public static <K,V> Pair<K, V> of(K k, V v) {
return new Pair<K,V>(k, v);
}
public Pair() {}
public Pair(R key, L value) {
this.left(key);
this.right(value);
}
public R left() {
return left;
}
public Pair<R, L> left(R key) {
this.left = key;
return this;
}
public L right() {
return right;
}
public Pair<R, L> right(L value) {
this.right = value;
return this;
}
}