a
El projecte d’aquest post el pots descarregar fent clic AQUI.
Una de les funcionalitats més interessants a l’hora de treballar amb estructures de dades tipus “pila”, “cua”, “llista” etc. és la seva ordenació. En el post de “Ordenar Arrays en Java (Amb els seus índexs)” implementem un API que ens permetia ordenar Arrays i els seus índexs, que és una funcionalitat molt important que no implementat per cap API coneguda i de forma senzilla.
En aquest post anem a mostrar com ordenar ArrayList, bé sigui amb un ArrayList de dades atòmics o amb un ArrayList d’objectes.
Per realitzar aquestes operacions necessitarem treballar amb la Classe “Collections” de Java. No anem a explicar les característiques d’aquesta classe, sinó que simplement anem a utilitzar-la per ordenar ArrayList ‘s. Com sol ser habitual en aquesta web, passem a mostrar aquesta funcionalitat amb un exemple:
Tindrem un ArrayList anomenat “arrayListInt” que és un array d’enters i que li posarem els següents valors (sinó sabeu el mètode add, mirar el post “ArrayList en Java, amb exemples”):
private static ArrayList arrayListInt = new ArrayList<>();// Guardo datos en el ArrayListarrayListInt.add(3); arrayListInt.add(4);arrayListInt.add(2);arrayListInt.add(6);arrayListInt.add(5);arrayListInt.add(1);arrayListInt.add(7);
si imprimim aquest ArrayList en l’ordre en què hem guardat els elements, tindrem que el primer element serà el va numerar ‘3’, el segon el nombre ‘6’ i si seguim l’ordre, l’últim serà el nombre ‘7 ‘.
Per ordenar aquest ArrayList de menys a més, utilitzarem el mètode “sort” de la classe Collections:
Collections.sort(arrayListInt);
Amb aquest mètode ens tornarà el ArrayList ordenat de menor a major, sent la sortida la següent (en el projecte que us podeu descarregar, podeu veure els mètode que imprimeixen per pantalla els ArrayList):
Per ordenar de més a menys, hem de crear-nos un objecte de la classe Comparator perquè compari els elements i els posi en ordre invers. Això ho fem de la següent manera:
Comparator<Integer> comparador = Collections.reverseOrder();Collections.sort(arrayListInt, comparador);
Executant aquesta part de el programa i imprimint per pantalla el ArrayList resultant, tenim el ArrayList ordenat de major a menor:
Posicion(1) = 7Posicion(2) = 6Posicion(3) = 5Posicion(4) = 4Posicion(5) = 3Posicion(6) = 2Posicion(7) = 1
Però ¿que passa si el que tenim és un ArrayList d’objectes de una determinada classe i el que volem ordenar aquest ArrayList pel valor d’un determinat atribut ?. Bé doncs hi ha una senzilla solució que anem a mostrar a continuació i que consisteix en sobreescriure un mètode de la classe Comparator.
Suposem que tenim una classe “Persona” de la manera següent:
class Persona {private String nombre;private int edad;public Persona() {}public Persona(String nombre, int edad) {this.nombre = nombre;this.edad = edad;}public String getNombre() {return nombre;}public void setNombre(String nombre) {this.nombre = nombre;}public int getEdad() {return edad;}public void setEdad(int edad) {this.edad = edad;}@Overridepublic String toString() {return this.getNombre() + " - " + this.getEdad();}}
Suposem que tenim un ArrayList anomenat” persones “amb els següents objectes de la classe persona:
private static ArrayList personas = new ArrayList<>();................................personas.add(new Persona("Pepe", 28));personas.add(new Persona("Juan", 32));personas.add(new Persona("Paco", 40));personas.add(new Persona("Susi", 24));personas.add(new Persona("Lola", 20));personas.add(new Persona("Jose", 28));personas.add(new Persona("Dani", 24));personas.add(new Persona("Sara", 36));
Aquest ArrayList el volem ordenar (de menor a major edat) en funció de l’edat de les persones, per tant hem de sobre escriure el mètode “compari” de la classe Comparator i cridar a el mètode “sort” de la classe collections. Això ho fem de la manera següent:
Collections.sort(personas, new Comparator<Persona>() {@Overridepublic int compare(Persona p1, Persona p2) {return new Integer(p1.getEdad()).compareTo(new Integer(p2.getEdad()));}});
Com veiem el que fa el mètode “compari” és comparar dues edats donades. En aquest cas estem comparant dos atributs de tipus “Integer”. Si ho volem fer amb un String, Double, etc. només hem de canviar el tipus de dada. Com a sortida a aquest codi tenim el següent:
Posicion(1) = Lola - 20Posicion(2) = Dani - 24Posicion(3) = Susi - 24Posicion(4) = Pepe - 28Posicion(5) = Jose - 28Posicion(6) = Juan - 32Posicion(7) = Sara - 36Posicion(8) = Paco - 40
Si ara volem ordenar-de major a menor edat, només hem de canviar el mètode “compari” posant la comparació a l’inrevés:
Collections.sort(personas, new Comparator<Persona>() {@Overridepublic int compare(Persona p1, Persona p2) {// Aqui esta el truco, ahora comparamos p2 con p1 y no al reves como antesreturn new Integer(p2.getEdad()).compareTo(new Integer(p1.getEdad()));}});
Com a resultat d’aquesta ordenació obtenim el següent:
Posicion(1) = Paco - 40Posicion(2) = Sara - 36Posicion(3) = Juan - 32Posicion(4) = Pepe - 28Posicion(5) = Jose - 28Posicion(6) = Dani - 24Posicion(7) = Susi - 24Posicion(8) = Lola - 20
Això és en resum tot el necessari per ordenar ArrayList, bé siguin per un atribut d’una sèrie d’objectes o amb dades atòmics (en realitat són objectes que representen dades atòmics, Integer, Double, etc.). No hem entrat en detall d’explicar les classes Comparator i Collections ja que en principi la finalitat d’aquest post és la de donar una solució a l’ordenació de ArrayList.