Interfaces Comparator y Comparable (II)
Escrito por ocell hace 1 años
bajo una licencia de Creative Commons
1675 visitas. Etiquetas: good-practices, java, comparation, comparable, interface
Lo prometido es deuda y ahora que tengo un slot libre de tiempo aquí tenéis el ejemplo que ilustra la primera parte de éste artículo. Podréis observar que al implementar el interfaz Comparable mediante la sobrecarga de compareTo(...), se ha utilizado el mismo método que proporciona Integer. De forma similar se hubiera podido implementar cualquier comparación devolviendo los valores indicados, en el "contrato" de la interfaz, según nuestro propio criterio. En este caso se ha modificado el valor devuelto, multiplicándolo por -1, para obtener la ordenación inversa, tal y como lo mencionó 'jsanca'.
import java.util.Vector;
import java.util.Iterator;
import java.util.Collections;
public class Persona implements Comparable<Persona> {
private String miNombre;
private Integer miEdad;
private Float miAltura;
public Persona(String nombre, int edad, double altura) {
this.miNombre = new String(nombre);
this.miEdad = new Integer(edad);
this.miAltura = new Float(altura);
}
/**
* Return a negative integer,
* zero, or a positive integer as
* this object is less than, equal to,
* or greater than the specified object.
*/
public int compareTo(Persona per) {
// Multiplicamos por -1 para obtener la ordenación
// inversa como apuntó 'jsanca' en su comentario.
return this.miEdad.compareTo(per.getEdad()) * -1;
}
public Integer getEdad() {
return miEdad;
}
public void setEdad(int edad) {
this.miEdad = new Integer(edad);
}
public Float getAltura() {
return miAltura;
}
public void setAltura(double altura) {
this.miAltura = new Float(altura);
}
public String toString() {
StringBuffer result = new StringBuffer();
result.append("Me llamo " + this.miNombre);
result.append(", tengo " + this.miEdad);
result.append(" y mi altura es " + this.miAltura);
return result.toString();
}
/**
* Main para probar la clase.
*/
public static void main(String[] args) {
// Franc
Persona franc = new Persona("Franc", 38, 1.78);
// Rosa
Persona rosa = new Persona("Rosa", 29, 1.67);
// Maite
Persona maite = new Persona("Maite", 37, 1.98);
// Creo una comunidad de personas.
Vector miComunidad = new Vector();
miComunidad.add(franc);
miComunidad.add(rosa);
miComunidad.add(maite);
// Ordeno por edad la comunidad de personas.
Collections.sort(miComunidad);
// Ya se puede listar la comunidad ordenada.
Iterator personaIter = miComunidad.iterator();
System.out.println("Comunidad ordenada por edad.");
while (personaIter.hasNext())
System.out.println(personaIter.next());
}
}El resultado de la ejecución es el siguiente:
Mi comunidad ordenada por edad.
*Me llamo Franc, tengo 38 y mi altura es 1.78
Me llamo Maite, tengo 37 y mi altura es 1.98
Me llamo Rosa, tengo 29 y mi altura es 1.67*
Nos vemos en la próxima y última parte donde comentaré el uso de la interfaz Comparator.
Artículos Relacionados
- Interfaces Comparator y Comparable (I)
- Interfaces Comparator y Comparable (y III)
- JTextField editable por fragmentos
- Ejecutar sólo una instancia de una aplicación
- Custom taglibs con Struts 2, FreeMaker y Spring
Grupos relacionados
Este usuario no ha completado su perfil.
2 comentarios en "Interfaces Comparator y Comparable (II)"
jsanca escribió
hace 1 años
ocell escribió
hace 1 años
jsanca tomo nota para el Comparator con el Decorator :-) , lo de la sobrecarga quise comentarlo aquí (ya tube la misma discusión en mi blog). Creo que con Java es más correcto decir implementación pero tampoco es incorrecto el término sobrecarga si ves la implementación de interfaces como un tipo de herencia múltiple muy rudimentaria; en este caso estaríamos sobrecargando o re-escribiendo un método.
© Copyright 2008-2009 debug_mode=ON | Aviso legal | Contacto | FAQ | ¿Quiénes somos?
|
#1
Buen ejemplo amigo, de hecho se me viene a la mente algo como así, en caso que utilices el comparator.
PersonaComparator implements Comparator<Persona>{ public enum Order { ASC, DESC; } // .. }Y dependiendo del valor, lo multiplicas por uno o menos uno. Inclusive se podría hacer un decorador que envuelva cualquier otro comparador y agregue la funcionalidad para implementar el orden, después se llama al super, multiplicando por el valor -1 o 1, dependiendo del orden seleccionado.
Por ultimo, una tontería, el termino correcto cuando reimplementas el método compare, no debería ser re escritura o sobre escritura, en vez de sobre carga, me parece que sobre carga se utiliza cuando tienes al menos dos o más métodos con el mismo nombre.
Saludos,
J
Editado 1 veces. La última vez hace hace 1 años.