CKTIS / Java
Comparable.compareTo(): ordinamento naturale in Java
Confronta gli oggetti secondo il loro ordinamento naturale. Interpreta il segno del risultato, distingui un pareggio dall’uguaglianza secondo equals e scegli quale oggetto conservare.
Versione: Java SE 21
Sintassi
Java SE 21 — java.lang.Comparable<T>
Interface method: int compareTo(T other);
Call: int result = a.compareTo(b);
Implementation signature for MyType implements Comparable<MyType>: @Override public int compareTo(MyType other)
Generic bound for natural-order helpers: <T extends Comparable<? super T>>Comparable.compareTo() indica il metodo di istanza int compareTo(T other) dell’interfaccia java.lang.Comparable<T>. La chiamata a.compareTo(b) accetta un argomento e confronta a con b secondo il loro ordinamento naturale. Un risultato < 0 indica che a precede b, == 0 indica un pareggio e > 0 indica che a segue b. Non dare per scontato che il risultato sia esattamente -1 o 1. Per un ordinamento diverso usa un Comparator<T> e chiama compare(a, b).
Scambiando gli operandi si deve invertire il segno, l’ordinamento deve essere transitivo e due oggetti a pari merito devono dare lo stesso segno se confrontati con un qualsiasi terzo oggetto confrontabile. In una gerarchia di classi, applica regole condivise alle istanze della classe base e delle classi derivate se possono essere confrontate tra loro. Per i campi int usa Integer.compare(x, y), non x - y, perché la sottrazione può causare un overflow. Un argomento null provoca una NullPointerException; un tipo di argomento che impedisce il confronto provoca una ClassCastException.
La coerenza con equals è fortemente raccomandata, ma non obbligatoria: a.compareTo(b) == 0 e a.equals(b) dovrebbero dare lo stesso risultato booleano. Documenta eventuali eccezioni. Per esempio, i valori BigDecimal 2.00 e 2.0 sono a pari merito nell’ordinamento naturale, ma equals restituisce false perché le scale sono diverse. Un TreeSet senza comparatore li tratta come lo stesso elemento.
Il vincolo generico <T extends Comparable<? super T>> permette di confrontare valori di tipo T anche se T eredita Comparable per un supertipo. Nella ricerca di un minimo o di un massimo, sostituisci il candidato solo se il nuovo elemento è strettamente minore (< 0) o maggiore (> 0), rispettivamente. In caso di pareggio rimane così il primo elemento. Con due argomenti, a.compareTo(b) <= 0 seleziona a in caso di pareggio.
Prima di limitare un valore a un intervallo (clamp), controlla che min.compareTo(max) <= 0. Restituisci min sotto l’intervallo, max sopra e il valore originale negli altri casi, anche quando equivale a uno dei due estremi secondo l’ordinamento.
Esempi
import java.math.BigDecimal;
public class Main {
static <T extends Comparable<? super T>> T min(T a, T b) {
return a.compareTo(b) <= 0 ? a : b;
}
static <T extends Comparable<? super T>> T clamp(T value, T min, T max) {
if (min.compareTo(max) > 0) {
throw new IllegalArgumentException("min > max");
}
if (value.compareTo(min) < 0) return min;
if (value.compareTo(max) > 0) return max;
return value;
}
public static void main(String[] args) {
BigDecimal a = new BigDecimal("2.00");
BigDecimal b = new BigDecimal("2.0");
BigDecimal high = new BigDecimal("3");
System.out.println("a < high: " + (a.compareTo(high) < 0));
System.out.println("a compares equal to b: " + (a.compareTo(b) == 0));
System.out.println("a.equals(b): " + a.equals(b));
System.out.println("min: " + min(a, b));
System.out.println("clamp: " + clamp(new BigDecimal("4"), a, high));
}
}Risultato
a < high: true a compares equal to b: true a.equals(b): false min: 2.00 clamp: 3
`a` e `b` sono numericamente uguali, ma hanno scale diverse. `min(a, b)` conserva il primo argomento, quindi viene stampato `2.00`. `clamp` restituisce il limite superiore `3` perché `4` lo supera.
Lezioni correlate
- Java · Lezione 5 · Avanzato · Versione: 2
- Java · Lezione 11 · Avanzato · Versione: 2
- Java · Lezione 15 · Avanzato · Versione: 2
- Java · Lezione 48 · Base · Versione: 2
- Java · Lezione 5 · Intermedio · Versione: 2