La interface
Comparable se emplea, para indicar si el objeto representado por
this es menor, igual o mayor que el objeto que se pasa como parametro. A continuacion se presentan 3 ejemplos de clases que definen la funcion
compareTo en base a una propiedad existente. Nota, en algunos paises existe el concepto de
National Identification Number (CURP en México, RUN en Chile, DNI en España y Argentina o Tarjeta de Identidad en colombia, por ejemplo)
public class ExamplePerson1 implements Comparable<ExamplePerson1> {
private String nin; // National Identification Number
private String name;
private String surname;
...
@Override
public int compareTo(ExamplePerson1 o) {
return this.nin.compareTo(o.nin);
}
}
public class ExamplePerson2 implements Comparable<ExamplePerson2> {
private Integer id;
private String name;
private String surname;
...
@Override
public int compareTo(ExamplePerson2 o) {
return this.id.compareTo(o.id);
}
}
public class ExamplePerson3 implements Comparable<ExamplePerson3> {
private int id;
private String name;
private String surname;
...
@Override
public int compareTo(ExamplePerson3 o) {
return this.id < o.id ? -1 : (this.id == o.id ? 0 : 1);
}
}
En el ejemplo 1 y 2, se emplean propiedades de tipo
String e
Integer las cuales implementan la interface
Comparable, por lo que solo se regresa el resultado de llamar la funcion
compareTo de la propiedad respectiva. En el ejemplo 3 se utiliza una propiedad de tipo nativo y se muestra un ejemplo de como puede implementarse la funcion, utilizando las clases que envuelven a los tipos nativos (
wrappers), evitando el uso de autoboxing y autounboxing.
En estos ejemplos, solo se emplea una propiedad, para implementar la funcionalidad. La recomendacion, es utilizar solo los atributos que forman la llave primaria (el concepto de base de datos). En caso de requerir utilizar mas de una propiedad, se incremanta el grado de complejidad. Como se muestra en el siguiente ejemplo.
public class ExamplePerson4 implements Comparable<ExamplePerson4> {
private Integer idPart1;
private Integer idPart2;
private String name;
private String surname;
...
@Override
public int compareTo(ExamplePerson4 o) {
int result = this.idPart1.compareTo(o.idPart1);
if(result == 0) {
result = this.idPart2.compareTo(o.idPart2);
}
return result;
}
}
Como se observa, si la comparacion de la primer propiedad es cero, hay que comparar la segunda propiedad y asi sucesivamente, hasta encontrar una distinta o ya no tener mas propiedades.
--- Actualizacion ---
En ocasiones, es necesario evitar que la comparacion genere una excepcion del tipo
NullPointerException, cuando el parametro que recibe la funcion
compareTo, es null. Para procesar el null, es necesario insertar un if para validar si es null, en caso de ser null, se regresa el valor necesario (normalmente 0), en caso contrario, se regresa el valor calculado, utilizando el algoritmo descrito anteriormente.
public class ExamplePerson5 implements Comparable<ExamplePerson5> {
private Integer id;
private String name;
private String surname;
...
@Override
public int compareTo(ExamplePerson5 o) {
return o == null ? 0 : this.id.compareTo(o.id);
}
}
Existe la posibilidad de implmentarlo utilizando un try-catch, en vez de utilizar un if. Si bien en apariencia no se ejecutan 2 operaciones, cuando se emplea el if (primero la comparacion contra null y posteriormente la evaluacion del if en si). En la practica no es optimo, dado que cuando se recibe un null, se genera una excepcion, que implicitamente es, la creacion del objeto excepcion, el llenado del stack (que en el caso de un programa muy sencillo son 3 o 4 elementos en el stack, pero en el caso de sistemas complejos, pueden ser mas de 50 elementos).
public class ExamplePerson6 implements Comparable<ExamplePerson6> {
private Integer id;
private String name;
private String surname;
...
@Override
public int compareTo(ExamplePerson6 o) {
try {
return this.id.compareTo(o.id);
} catch (NullPointerException e) {
return 0;
}
}
}
En conclusion, siempre es recomendable utilizar un if, si se necesita regresar un valor en caso de que el parametro sea null y evitar el uso de un try-catch.
