CKTIS / Java
Comparable.compareTo(): ordem natural em Java
Compara objetos pela sua ordem natural. Interpreta o sinal do resultado, distingue um empate da igualdade segundo equals e decide que objeto manter em caso de empate.
Versão: Java SE 21
Sintaxe
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 o método de instância int compareTo(T other) da interface java.lang.Comparable<T>. A chamada a.compareTo(b) recebe um argumento e compara a com b pela sua ordem natural. Um resultado < 0 indica que a vem antes de b, == 0 indica um empate e > 0 indica que a vem depois de b. Não assumas que o resultado é exatamente -1 ou 1. Para outra ordem, usa um Comparator<T> e chama compare(a, b).
Trocar os operandos tem de inverter o sinal, a ordem tem de ser transitiva e dois objetos empatados têm de dar o mesmo sinal quando comparados com qualquer terceiro objeto comparável. Numa hierarquia de classes, aplica as mesmas regras de ordenação às instâncias da classe base e das classes derivadas se puderem ser comparadas entre si. Para campos int, usa Integer.compare(x, y), não x - y, pois a subtração pode causar um transbordo. Um argumento null provoca NullPointerException; um argumento cujo tipo impede a comparação provoca ClassCastException.
É vivamente recomendável, mas não obrigatório, que a ordem seja coerente com equals: a.compareTo(b) == 0 e a.equals(b) devem dar o mesmo resultado booleano. Documenta qualquer desvio. Por exemplo, os valores BigDecimal 2.00 e 2.0 empatam na ordem natural, mas equals devolve false porque as escalas são diferentes. Um TreeSet sem comparador trata-os como o mesmo elemento.
A restrição genérica <T extends Comparable<? super T>> permite comparar valores do tipo T mesmo quando T herda Comparable para um supertipo. Ao procurar o mínimo ou o máximo, substitui o candidato apenas se o novo elemento for estritamente menor (< 0) ou maior (> 0), respetivamente. Assim manténs o primeiro elemento em caso de empate. Com dois argumentos, a.compareTo(b) <= 0 escolhe a em caso de empate.
Antes de limitar um valor a um intervalo (clamp), verifica min.compareTo(max) <= 0. Devolve min abaixo do intervalo, max acima e o valor original nos restantes casos, incluindo quando empata com qualquer um dos limites.
Exemplos
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` e `b` têm o mesmo valor numérico, mas escalas diferentes. `min(a, b)` mantém o primeiro argumento, pelo que é apresentado `2.00`. `clamp` devolve o limite superior `3` porque `4` o excede.
Lições relacionadas
- Java · Lição 5 · Avançado · Versão: 2
- Java · Lição 11 · Avançado · Versão: 2
- Java · Lição 15 · Avançado · Versão: 2
- Java · Lição 48 · Básico · Versão: 2
- Java · Lição 5 · Intermédio · Versão: 2