A mio avviso, non esiste una coppia in Java perché, se si desidera aggiungere funzionalità extra direttamente alla coppia (ad es. Confrontabile), è necessario associare i tipi. In C ++, non ci interessa, e se i tipi che compongono una coppia non ne hanno operator <
, pair::operator <
non verranno compilati.
Un esempio di Comparable senza limiti:
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 esempio di Comparable with compile-time check per verificare se gli argomenti di tipo sono comparabili:
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));
Questo va bene, ma questa volta non puoi usare tipi non confrontabili come argomenti di tipo in Pair. Uno può usare molti Comparatori per Pair in alcune classi di utilità, ma le persone C ++ potrebbero non ottenerlo. Un altro modo è scrivere molte classi in una gerarchia di tipi con limiti diversi su argomenti di tipo, ma ci sono troppi limiti possibili e le loro combinazioni ...
AbstractMap.SimpleEntry
contorto?