CKTIS / Java
Comparable.compareTo(): orden natural en Java
Compara objetos por su orden natural. Interpreta el signo del resultado, distingue un empate de la igualdad según equals y decide qué objeto conservar si hay empate.
Versión: Java SE 21
Sintaxis
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() designa el método de instancia int compareTo(T other) de java.lang.Comparable<T>. La llamada a.compareTo(b) recibe un argumento y compara a con b según su orden natural. Si el resultado es < 0, a va antes que b; si es == 0, hay empate; y si es > 0, a va después de b. No supongas que el resultado es exactamente -1 o 1. Para otro criterio de ordenación, usa un Comparator<T> y llama a compare(a, b).
Intercambiar los operandos debe invertir el signo, el orden debe ser transitivo y dos objetos empatados deben dar el mismo signo al compararlos con cualquier tercer objeto comparable. En una jerarquía de clases, aplica reglas de ordenación comunes a las instancias de la clase base y de las derivadas si se pueden comparar entre sí. Para campos int, usa Integer.compare(x, y) en vez de x - y, ya que la resta puede desbordarse. Un argumento null provoca NullPointerException; uno cuyo tipo impida la comparación provoca ClassCastException.
Se recomienda encarecidamente que el orden sea coherente con equals, pero no es obligatorio: a.compareTo(b) == 0 y a.equals(b) deberían producir el mismo resultado booleano. Documenta cualquier excepción a esta regla. Por ejemplo, los valores BigDecimal 2.00 y 2.0 empatan en el orden natural, pero equals devuelve false porque sus escalas difieren. Un TreeSet sin comparador los trata como un solo elemento.
La cota genérica <T extends Comparable<? super T>> permite comparar valores de tipo T aunque T herede Comparable para un supertipo. Al buscar un mínimo o un máximo, sustituye el candidato solo si el elemento nuevo es estrictamente menor (< 0) o mayor (> 0), respectivamente. Así conservas el primer elemento en caso de empate. Con dos argumentos, a.compareTo(b) <= 0 selecciona a si hay empate.
Antes de limitar un valor a un intervalo (clamp), comprueba min.compareTo(max) <= 0. Devuelve min si el valor queda por debajo, max si queda por encima y el valor original en los demás casos, incluido el empate con cualquiera de los límites.
Ejemplos
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));
}
}Resultado
a < high: true a compares equal to b: true a.equals(b): false min: 2.00 clamp: 3
`a` y `b` tienen el mismo valor numérico, pero distinta escala. `min(a, b)` conserva el primer argumento, por lo que se imprime `2.00`. `clamp` devuelve el límite superior `3` porque `4` lo supera.
Lecciones relacionadas
- Java · Lección 5 · Avanzado · Versión: 2
- Java · Lección 11 · Avanzado · Versión: 2
- Java · Lección 15 · Avanzado · Versión: 2
- Java · Lección 48 · Básico · Versión: 2
- Java · Lección 5 · Intermedio · Versión: 2