O proxecto desta publicación pode descargalo premendo aquí.
Unha das características máis interesantes ao traballar con estruturas de datos tipo” Stack “,” cola “,” lista “, etc. É a túa ordenación. No cargo de “Arrays de orde en Java (cos seus índices)” implementamos unha API que nos permitiu ordenar arrays e os seus índices, que é unha funcionalidade moi importante que non foi implementada por ningunha API coñecida e de forma sinxela.
Neste post mostraremos como solicitar a Arraylist, xa sexa cunha matriz de datos atómica ou cunha lista de obxectos.
para realizar estas operacións teremos que traballar coa clase de” coleccións “de Java. Non imos explicar as características desta clase, pero simplemente imos usalo para encargar a Arraylist. Como é habitual neste sitio web, pasamos a mostrar esta funcionalidade cun exemplo:
que imos ter un arraylist chamado “arraylistint” que é unha variedade de enteiros E que imos poñer os seguintes valores (pero vostede sabe o método ADD, mira a publicación “Arraylist en Java, con exemplos”):
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);
Se imprimimos este arraylist na orde en que gardamos os elementos, teremos que o primeiro elemento será numerado ‘3’, o segundo número ‘6’ e se seguimos A orde, a última será o número ‘7’.
Para solicitar este maior arrayista maior, usaremos o método “xénero” da clase de coleccións:
Collections.sort(arrayListInt);
con este método devolverá o arraylist ordenado de menos a maior, a saída sendo a seguinte (no proxecto que pode descargar, pode ver o método que imprime a lista de arraylist na pantalla):
para ordenalo desde o máis alto a menor, temos que crear un obxecto da clase de accións para comparar os elementos e poñelos en orde inversa .. Facemos isto do seguinte xeito:
Comparator<Integer> comparador = Collections.reverseOrder();Collections.sort(arrayListInt, comparador);
Executa esta parte do programa e imprimen a lista de Arraylist resultante na pantalla, temos O arraylist ordenou a partir de máis alto a menos:
Posicion(1) = 7Posicion(2) = 6Posicion(3) = 5Posicion(4) = 4Posicion(5) = 3Posicion(6) = 2Posicion(7) = 1
pero que pasa se o que temos é un arraylist de obxectos dun certa clase e que queremos ordenar ese arraylist polo valor dun determinado atributo?. Ben, hai unha solución sinxela que imos mostrar a continuación e que consiste en sobrescribir un método da clase de comparación.
Supoñamos que temos unha clase “persoa” da seguinte:
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();}}
Supoñamos que temos un arraylist chamado “persoas” cos seguintes obxectos da persoa:
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));
Esta arraylist queremos (de menos que a idade máis antiga) dependendo da idade das persoas, polo tanto, temos que escribir o método “comparar” da clase de comparación e Chama ao método “Ordenar” da clase de coleccións. Facemos isto do seguinte xeito:
Collections.sort(personas, new Comparator<Persona>() {@Overridepublic int compare(Persona p1, Persona p2) {return new Integer(p1.getEdad()).compareTo(new Integer(p2.getEdad()));}});
como vemos cal é o método “comparar” é comparar dúas idades dadas. Neste caso, estamos a comparar dous atributos do tipo “enteiro”. Se queremos facelo cunha cadea, dobre, etc. Só temos que cambiar o tipo de datos. Como saída a este código temos o seguinte:
Se agora queremos ordenalo de forma máis alta , só temos que cambiar o método “Comparar” establecendo a comparación ao revé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()));}});
como resultado de Esta xestión obtemos o seguinte:
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
Isto é resumido todo o necesario para solicitar a Arraylist, xa sexa por un atributo de Unha serie de obxectos ou con datos atómicos (en realidade son obxectos que representan datos atómicos, enteiro, dobre, etc.). Non entramos en detalle para explicar as clases de comparación e coleccións xa que en principio o propósito desta publicación é dar unha solución á ordenación de arraylist.