Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

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

Fuentes