Un'interfaccia comparatrice viene utilizzata per ordinare gli oggetti delle classi definite dall'utente. Un oggetto comparatore è in grado di confrontare due oggetti della stessa classe . La seguente funzione confronta obj1 con obj2.
Sintassi:
public int compare(Object obj1, Object obj2):>
Supponiamo di avere un Array/ArrayList del nostro tipo di classe, contenente campi come roll no, nome, indirizzo, DOB, ecc., e dobbiamo ordinare l'array in base a Roll no o name?
Metodo 1 : Un approccio ovvio è scrivere la nostra funzione sort() utilizzando uno degli algoritmi standard. Questa soluzione richiede la riscrittura dell'intero codice di ordinamento per criteri diversi come il numero di rotolo e il nome.
array nei metodi Java
Metodo 2: Utilizzo dell'interfaccia comparatore: l'interfaccia comparatore viene utilizzata per ordinare gli oggetti di una classe definita dall'utente. Questa interfaccia è presente nel pacchetto java.util e contiene 2 metodi compare (oggetto obj1, oggetto obj2) ed equals (elemento oggetto). Utilizzando un comparatore, possiamo ordinare gli elementi in base ai membri dei dati. Ad esempio, potrebbe essere inserito nel registro il numero, il nome, l'età o qualsiasi altra cosa.
Il metodo della classe Collections per l'ordinamento degli elementi dell'elenco viene utilizzato per ordinare gli elementi di List in base al comparatore specificato.
public void sort(List list, ComparatorClass c)>
Per ordinare un determinato elenco, ComparatorClass deve implementare un'interfaccia Comparator.
Come funziona il metodo sort() della classe Collections?
Internamente il metodo Sort chiama il metodo Compare delle classi che sta ordinando. Per confrontare due elementi, si chiede: Quale è maggiore? Il metodo Confronta restituisce -1, 0 o 1 per indicare se è inferiore, uguale o maggiore rispetto all'altro. Utilizza questo risultato per determinare se devono essere scambiati per il loro ordinamento.
Esempio
Giava
// 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 {> >// 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 {> >// 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 ar =>new> ArrayList();> >// 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 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('
Sorted by rollno'); // Again iterating over entries to print them for (int i = 0; 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('
Sorted by name'); // // Again iterating over entries to print them for (int i = 0; i System.out.println(ar.get(i)); } }> |
>
>Produzione
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>
Modificando il valore restituito all'interno del metodo di confronto, puoi ordinare nell'ordine che desideri, ad esempio: per l'ordine discendente basta modificare le posizioni di 'a' e 'b' nel metodo di confronto sopra.
Ordina la raccolta in base a più di un campo
Nell'esempio precedente, abbiamo discusso come ordinare l'elenco di oggetti sulla base di un singolo campo utilizzando l'interfaccia Comparable e Comparator. Ma cosa succede se abbiamo l'esigenza di ordinare gli oggetti ArrayList in base a più di un campo come in primo luogo, ordinare in base al nome dello studente e, in secondo luogo, ordinare in base all'età dello studente.
Esempio
Giava
long per stringere 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> class> CustomerSortingComparator> >implements> Comparator {> >// 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> class> GFG {> >public> static> void> main(String[] args)> >{> >// Create an empty ArrayList> >// to store Student> >List 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 custIterator = al.iterator();> >// Display message> >System.out.println(>'Before Sorting:
'>);> >// 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(>'
After Sorting:
'>);> >// Iterating using enhanced for-loop> >// after Sorting ArrayList> >for> (Student customer : al) {> >System.out.println(customer);> >}> >}> }> |
>
>Produzione
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}>