Se utiliza una interfaz de comparación para ordenar los objetos de las clases definidas por el usuario. Un objeto comparador es capaz de comparar dos objetos de la misma clase . La siguiente función compara obj1 con obj2.
Sintaxis:
public int compare(Object obj1, Object obj2):
Supongamos que tenemos un Array/ArrayList de nuestro propio tipo de clase, que contiene campos como número de lista, nombre, dirección, fecha de nacimiento, etc., y necesitamos ordenar la array según el número de lista o el nombre.
Método 1 : un enfoque obvio es escribir nuestra propia función sort() usando uno de los algoritmos estándar. Esta solución requiere reescribir todo el código de clasificación para diferentes criterios, como el número de rollo y el nombre.
Método 2: Usar la interfaz del comparador: la interfaz del comparador se usa para ordenar los objetos de una clase definida por el usuario. Esta interfaz está presente en el paquete java.util y contiene 2 métodos compare(Object obj1, Object obj2) y equals(Object element). Usando un comparador, podemos ordenar los elementos en función de los miembros de datos. Por ejemplo, puede estar en el número de lista, el nombre, la edad o cualquier otra cosa.
El método de la clase Colecciones para ordenar los elementos de la Lista se utiliza para ordenar los elementos de la Lista por el comparador dado.
public void sort(List list, ComparatorClass c)
Para ordenar una lista dada, ComparatorClass debe implementar una interfaz Comparator.
¿Cómo funciona el método sort() de la clase Collections?
Internamente, el método Ordenar llama al método Comparar de las clases que está ordenando. Para comparar dos elementos, pregunta «¿Cuál es mayor?» El método de comparación devuelve -1, 0 o 1 para decir si es menor, igual o mayor que el otro. Utiliza este resultado para determinar si deben intercambiarse por su tipo.
Ejemplo
Java
// Java Program to Demonstrate Working of
// Comparator Interface
// Importing required classes
import java.io.*;
import java.lang.*;
import java.util.*;
// Class 1
// A class to represent a Student
class Student {
// Attributes of a student
int rollno;
String name, address;
// Constructor
public Student(int rollno, String name, String address)
{
// This keyword refers to current instance itself
this.rollno = rollno;
this.name = name;
this.address = address;
}
// Method of Student class
// To print student details in main()
public String toString()
{
// Returning attributes of Student
return this.rollno + " " + this.name + " "
+ this.address;
}
}
// Class 2
// Helper class implementing Comparator interface
class Sortbyroll implements Comparator<Student> {
// Method
// Sorting in ascending order of roll number
public int compare(Student a, Student b)
{
return a.rollno - b.rollno;
}
}
// Class 3
// Helper class implementing Comparator interface
class Sortbyname implements Comparator<Student> {
// Method
// Sorting in ascending order of name
public int compare(Student a, Student b)
{
return a.name.compareTo(b.name);
}
}
// Class 4
// Main class
class GFG {
// Main driver method
public static void main(String[] args)
{
// Creating an empty ArrayList of Student type
ArrayList<Student> ar = new ArrayList<Student>();
// Adding entries in above List
// using add() method
ar.add(new Student(111, "Mayank", "london"));
ar.add(new Student(131, "Anshul", "nyc"));
ar.add(new Student(121, "Solanki", "jaipur"));
ar.add(new Student(101, "Aggarwal", "Hongkong"));
// Display message on console for better readability
System.out.println("Unsorted");
// Iterating over entries to print them
for (int i = 0; i < ar.size(); i++)
System.out.println(ar.get(i));
// Sorting student entries by roll number
Collections.sort(ar, new Sortbyroll());
// Display message on console for better readability
System.out.println("\nSorted by rollno");
// Again iterating over entries to print them
for (int i = 0; i < ar.size(); i++)
System.out.println(ar.get(i));
// Sorting student entries by name
Collections.sort(ar, new Sortbyname());
// Display message on console for better readability
System.out.println("\nSorted by name");
// // Again iterating over entries to print them
for (int i = 0; i < ar.size(); i++)
System.out.println(ar.get(i));
}
}
Unsorted 111 Mayank london 131 Anshul nyc 121 Solanki jaipur 101 Aggarwal Hongkong Sorted by rollno 101 Aggarwal Hongkong 111 Mayank london 121 Solanki jaipur 131 Anshul nyc Sorted by name 101 Aggarwal Hongkong 131 Anshul nyc 111 Mayank london 121 Solanki jaipur
Al cambiar el valor devuelto dentro del método de comparación, puede ordenar en el orden que desee, por ejemplo: Para el orden descendente, simplemente cambie las posiciones de ‘a’ y ‘b’ en el método de comparación anterior.
Ordenar colección por más de un campo
En el ejemplo anterior, hemos discutido cómo ordenar la lista de objetos sobre la base de un solo campo usando la interfaz Comparable y Comparator. Pero, ¿qué sucede si tenemos el requisito de ordenar los objetos ArrayList de acuerdo con más de un campo como, en primer lugar, ordenar según el nombre del estudiante y en segundo lugar, ordenar según la edad del estudiante.
Ejemplo
Java
// Java Program to Demonstrate Working of
// Comparator Interface Via More than One Field
// Importing required classes
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
// Class 1
// Helper class representing a Student
class Student {
// Attributes of student
String Name;
int Age;
// Parameterized constructor
public Student(String Name, Integer Age)
{
// This keyword refers to current instance itself
this.Name = Name;
this.Age = Age;
}
// Getter setter methods
public String getName() { return Name; }
public void setName(String Name) { this.Name = Name; }
public Integer getAge() { return Age; }
public void setAge(Integer Age) { this.Age = Age; }
// Method
// Overriding toString() method
@Override public String toString()
{
return "Customer{"
+ "Name=" + Name + ", Age=" + Age + '}';
}
// Class 2
// Helper class implementing Comparator interface
static class CustomerSortingComparator
implements Comparator<Student> {
// Method 1
// To compare customers
@Override
public int compare(Student customer1,
Student customer2)
{
// Comparing customers
int NameCompare = customer1.getName().compareTo(
customer2.getName());
int AgeCompare = customer1.getAge().compareTo(
customer2.getAge());
// 2nd level comparison
return (NameCompare == 0) ? AgeCompare
: NameCompare;
}
}
// Method 2
// Main driver method
public static void main(String[] args)
{
// Create an empty ArrayList
// to store Student
List<Student> al = new ArrayList<>();
// Create customer objects
// using constructor initialization
Student obj1 = new Student("Ajay", 27);
Student obj2 = new Student("Sneha", 23);
Student obj3 = new Student("Simran", 37);
Student obj4 = new Student("Ajay", 22);
Student obj5 = new Student("Ajay", 29);
Student obj6 = new Student("Sneha", 22);
// Adding customer objects to ArrayList
// using add() method
al.add(obj1);
al.add(obj2);
al.add(obj3);
al.add(obj4);
al.add(obj5);
al.add(obj6);
// Iterating using Iterator
// before Sorting ArrayList
Iterator<Student> custIterator = al.iterator();
// Display message
System.out.println("Before Sorting:\n");
// Holds true till there is single element
// remaining in List
while (custIterator.hasNext()) {
// Iterating using next() method
System.out.println(custIterator.next());
}
// Sorting using sort method of Collections class
Collections.sort(al,
new CustomerSortingComparator());
// Display message only
System.out.println("\n\nAfter Sorting:\n");
// Iterating using enhanced for-loop
// after Sorting ArrayList
for (Student customer : al) {
System.out.println(customer);
}
}
}
Before Sorting:
Customer{Name=Ajay, Age=27}
Customer{Name=Sneha, Age=23}
Customer{Name=Simran, Age=37}
Customer{Name=Ajay, Age=22}
Customer{Name=Ajay, Age=29}
Customer{Name=Sneha, Age=22}
After Sorting:
Customer{Name=Ajay, Age=22}
Customer{Name=Ajay, Age=27}
Customer{Name=Ajay, Age=29}
Customer{Name=Simran, Age=37}
Customer{Name=Sneha, Age=22}
Customer{Name=Sneha, Age=23}
Este artículo es una contribución de Rishabh Mahrsee . Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo y enviarlo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks. Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA