À mon avis, il n'y a pas de paire en Java car, si vous souhaitez ajouter des fonctionnalités supplémentaires directement sur la paire (par exemple, comparable), vous devez délimiter les types. En C ++, nous ne nous en soucions pas, et si les types composant une paire n'en ont pas operator <
, pair::operator <
ils ne se compileront pas aussi bien.
Un exemple de comparable sans limite:
public class Pair<F, S> implements Comparable<Pair<? extends F, ? extends S>> {
public final F first;
public final S second;
/* ... */
public int compareTo(Pair<? extends F, ? extends S> that) {
int cf = compare(first, that.first);
return cf == 0 ? compare(second, that.second) : cf;
}
//Why null is decided to be less than everything?
private static int compare(Object l, Object r) {
if (l == null) {
return r == null ? 0 : -1;
} else {
return r == null ? 1 : ((Comparable) (l)).compareTo(r);
}
}
}
/* ... */
Pair<Thread, HashMap<String, Integer>> a = /* ... */;
Pair<Thread, HashMap<String, Integer>> b = /* ... */;
//Runtime error here instead of compile error!
System.out.println(a.compareTo(b));
Un exemple de Comparable avec la vérification à la compilation pour savoir si les arguments de type sont comparables:
public class Pair<
F extends Comparable<? super F>,
S extends Comparable<? super S>
> implements Comparable<Pair<? extends F, ? extends S>> {
public final F first;
public final S second;
/* ... */
public int compareTo(Pair<? extends F, ? extends S> that) {
int cf = compare(first, that.first);
return cf == 0 ? compare(second, that.second) : cf;
}
//Why null is decided to be less than everything?
private static <
T extends Comparable<? super T>
> int compare(T l, T r) {
if (l == null) {
return r == null ? 0 : -1;
} else {
return r == null ? 1 : l.compareTo(r);
}
}
}
/* ... */
//Will not compile because Thread is not Comparable<? super Thread>
Pair<Thread, HashMap<String, Integer>> a = /* ... */;
Pair<Thread, HashMap<String, Integer>> b = /* ... */;
System.out.println(a.compareTo(b));
C'est bien, mais cette fois, vous ne pouvez pas utiliser des types non comparables comme arguments de type dans Pair. On peut utiliser beaucoup de comparateurs pour Pair dans certaines classes utilitaires, mais les gens C ++ peuvent ne pas l'obtenir. Une autre façon est d'écrire beaucoup de classes dans une hiérarchie de types avec différentes limites sur les arguments de type, mais il y a trop de limites possibles et leurs combinaisons ...
AbstractMap.SimpleEntry
alambiqué?