¿Cómo ordenar una ArrayList de objetos por propiedad en Java?

ArrayList en Java (equivalente a vector en C++ ) con un tamaño dinámico. Se puede encoger o expandir según el tamaño. ArrayList es parte del marco de la colección y está presente en el paquete java.util.

--> java.util Package
    --> ArrayList Class  

Sintaxis: Crear una ArrayList vacía 

ArrayList <E> list = new ArrayList <> ();

Diferentes formas de ordenar una ArrayList de objetos por propiedad

  1. Uso de la interfaz del comparador
  2. Uso de interfaz comparable

Enfoque 1: 

En este caso, el comparador es un lambda que define los siguientes parámetros de la siguiente manera: 

  • Toma dos objetos de la lista o1 y o2.
  • Compara la propiedad personalizada de los dos objetos usando el método compareTo() .
  • Y finalmente devuelve un número positivo si la propiedad de o1 es mayor que la de o2, negativo si la propiedad de o1 es menor que la de o2 y cero si son iguales.
  • En base a esto, la lista se ordena en función de la menor propiedad a la mayor y se almacena de nuevo en la lista.

Procedimiento:

  1. En el siguiente programa, hemos definido una clase CustomObject con una propiedad String, customProperty .
  2. También agregamos un constructor que inicializa la propiedad y una función de obtención getCustomProperty() que devuelve customProperty .
  3. En el método main() , hemos creado una lista de array de lista de objetos personalizados, inicializada con 5 objetos.
  4. Para ordenar la lista con la propiedad dada, usamos el método sort() de la lista .
  5. El método sort() toma la lista a ordenar (la lista ordenada final también es la misma) y un comparador .

Ejemplo

Java

// Java Program to Sort ArrayList of Objects by Property
  
// Importing required classes
import java.util.*;
  
// Class 1
// Custom class with custom property
// It takes and stores custom objects
class CustomObject {
  
     // Class data member 
    private String customProperty;
  
    // Method 
    public CustomObject(String property) {
        this.customProperty = property;
    }
  
    // Getter 
    public String getCustomProperty() {
        return this.customProperty;
    }
}
  
// Class 2
public class GFG {
  
    // Method 1
    // To print sorted ArrayList objects
    // using enchanced for loop
    public static void print(ArrayList<CustomObject> list) {
        
        for (CustomObject obj : list) {
            System.out.println(obj.getCustomProperty());
        }
    }
  
    // Method 2
    // Comparing two list
    // using compareTo() method
    public static void sort(ArrayList<CustomObject> list) {
  
        list.sort((o1, o2)
                  -> o1.getCustomProperty().compareTo(
                      o2.getCustomProperty()));
    }
  
    // Method 3
    // Adding custom objects
    public static void add(ArrayList<CustomObject> list) {
  
        // Adding elements to list
        // using add() method
        list.add(new CustomObject("Z"));
        list.add(new CustomObject("A"));
        list.add(new CustomObject("B"));
        list.add(new CustomObject("X"));
        list.add(new CustomObject("Aa"));
    }
  
    // Method 4
    // Main driver method
    public static void main(String[] args) {
  
        // Creating an empty ArrayList of custom class type
        ArrayList<CustomObject> list = new ArrayList<>();
  
        // Calling above methods defined inside class
        // in main() method
        add(list);
        sort(list);
        print(list);
    }
}
Producción

A
Aa
B
X
Z

Enfoque 2: Uso de Comparable y comparador

Cuando ArrayList es de un tipo de objeto personalizado, entonces, en este caso, usamos dos métodos de clasificación por Comparator o Comparable y en este caso Collections.sort() no se puede usar directamente ya que dará un error porque solo clasifica tipos de datos y tipos no definidos por el usuario.

2-A: Ordenar ArrayList con Comparable

  1. La clase de tipo de objeto personalizado que es Student aquí implementará la clase Comparable<Student>.
  2. Esto anulará el método compareTo() de la clase Comparable que toma el objeto de la clase Student como parámetro, y necesitamos comparar los valores/atributos por los que queremos ordenar la lista y regresar en consecuencia en la función compareTo().

Ejemplo:

Java

// Java program to sort ArrayList of Custom Object
// Using Comparable class
  
// Importing required classes
import java.util.*;
  
// Class 1
// Main class
// ArrayListSorting
class GFG {
  
    // Main driver method
    public static void main(String args[]) {
  
        // Creating an empty ArrayList of Student type
        ArrayList<Student> arraylist
            = new ArrayList<Student>();
  
        // Adding elements to above List
        arraylist.add(new Student(12, "Riya", 15));
        arraylist.add(new Student(14, "Mahima", 16));
        arraylist.add(new Student(13, "Shubhi", 15));
  
        // Sorting above list using sort() method
        // of Collections class
        Collections.sort(arraylist);
  
        // Iterating over list via for each loop and
        // printing all elements inside the List
        for (Student str : arraylist) {
            System.out.println(str);
        }
    }
}
  
// Class 2
// Implementing Comparable interface
public class Student implements Comparable<Student> {
  
    // Class data members
    private String studentname;
    private int rollno;
    private int studentage;
  
    // Constructor of Student class
    public Student(int rollno, String studentname,
                   int studentage) {
  
        // this keyword refers to current instance itself
        this.rollno = rollno;
        this.studentname = studentname;
        this.studentage = studentage;
    }
  
  
    // Getter and Setter methods
  
    public String getStudentname() { return studentname; }
    public void setStudentname(String studentname) {
        this.studentname = studentname;
    }
  
    public int getRollno() { return rollno; }
    public void setRollno(int rollno) {
        this.rollno = rollno;
    }
  
    public int getStudentage() { return studentage; }
    public void setStudentage(int studentage) {
        this.studentage = studentage;
    }
  
  
    // overriding the compareTo method of Comparable class
    @Override public int compareTo(Student comparestu) {
        int compareage
            = ((Student)comparestu).getStudentage();
  
        //  For Ascending order
        return this.studentage - compareage;
  
        // For Descending order do like this
        // return compareage-this.studentage;
    }
  
    @Override public String toString() {
        return "[ rollno=" + rollno + ", name="
               + studentname + ", age=" + studentage + "]";
    }
}
Producción

[ rollno=12, name=Riya, age=15]
[ rollno=13, name=Shubhi, age=15]
[ rollno=14, name=Mahima, age=16]

2-B: Ordenar ArrayList con Comparator

  1. Definiremos otra clase que implementará la clase Comparator del tipo de nuestro objeto personalizado. Por ejemplo, en el siguiente código, nuestra clase personalizada es Student, por lo que otra clase que hemos definido implementará Comparatot<Student>.
  2. Esta clase anulará el método de comparación de la clase Comparator que acepta dos objetos de la clase Student como parámetros y devuelve el valor de comparación de acuerdo con nuestros requisitos, ya sea que deseemos ordenar la array en orden ascendente o descendente y en qué atributo queremos ordenar la lista.

Ejemplo:

Java

// Java Program to Sort ArrayList of Custom Object 
// Using Comparator class
  
// Importing required classes
import java.util.*;
import java.util.Comparator;
  
// Class
public class Student {
  
    // Class data members
    private String studentname;
    private int rollno;
    private int studentage;
  
    // Constructor
    public Student(int rollno, String studentname,
                   int studentage) {
        // this keyword refers to current instance itself
        this.rollno = rollno;
        this.studentname = studentname;
        this.studentage = studentage;
    }
  
    // Getters and Setters method
  
    public String getStudentname() { return studentname; }
    public void setStudentname(String studentname) {
        this.studentname = studentname;
    }
  
    public int getRollno() { return rollno; }
    public void setRollno(int rollno) {
        this.rollno = rollno;
    }
  
    public int getStudentage() { return studentage; }
    public void setStudentage(int studentage) {
        this.studentage = studentage;
    }
  
    // Usage of comparator
    public static Comparator<Student> StuNameComparator = new Comparator<Student>() {
  
        // Comparing attributes of students
        public int compare(Student s1, Student s2) {
            String StudentName1
                = s1.getStudentname().toUpperCase();
            String StudentName2
                = s2.getStudentname().toUpperCase();
  
            // Returning in ascending order
            return StudentName1.compareTo(
                       StudentName2);
  
            // descending order
            // return
            // StudentName2.compareTo(StudentName1);
        }
    };
  
    // Comparator for sorting the list by roll no
    public static Comparator<Student> StuRollno = new Comparator<Student>() {
  
        // Method
        public int compare(Student s1, Student s2) {
  
            int rollno1 = s1.getRollno();
            int rollno2 = s2.getRollno();
  
            // For ascending order
            return rollno1 - rollno2;
  
            // For descending order
            // rollno2-rollno1;
        }
    };
  
    // Overriding toString() method to list out student details
    @Override public String toString() {
  
        return "[ rollno=" + rollno + ", name="
               + studentname + ", age=" + studentage + "]";
    }
}
  
// Class 2
// Main class
class Details {
  
    // Main driver method
    public static void main(String args[]) {
  
        // Creating an empty ArrayList of Student type
        ArrayList<Student> arraylist
            = new ArrayList<Student>();
  
        // Adding elements to ArrayList
        arraylist.add(new Student(101, "Zues", 26));
        arraylist.add(new Student(505, "Abey", 24));
        arraylist.add(new Student(809, "Vignesh", 32));
  
        // Sorting based on Student Name
        System.out.println("Student Name Sorting:");
  
        // Using sort() method of Collection class
        Collections.sort(arraylist,
                         Student.StuNameComparator);
  
        for (Student str : arraylist) {
              
            System.out.println(str);
        }
  
        // Now, sorting on Rollno property
        System.out.println("RollNum Sorting:");
  
        Collections.sort(arraylist, Student.StuRollno);
  
        // Iterating over list via for each and
        // printing the elements
        for (Student str : arraylist) {
            System.out.println(str);
        }
    }
}
Producción

Student Name Sorting:
[ rollno=505, name=Abey, age=24]
[ rollno=809, name=Vignesh, age=32]
[ rollno=101, name=Zues, age=26]
RollNum Sorting:
[ rollno=101, name=Zues, age=26]
[ rollno=505, name=Abey, age=24]
[ rollno=809, name=Vignesh, age=32]

Publicación traducida automáticamente

Artículo escrito por sparshgupta229 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *