java.util.Collections.sort() Il metodo è presente nella classe java.util.Collections. Viene utilizzato per ordinare gli elementi presenti nello specificato lista della Collezione in ordine crescente. Funziona in modo simile a java.util.Arrays.sort() ma è migliore in quanto può ordinare gli elementi di Array, nonché la coda dell'elenco collegato e molti altri presenti in esso.
public static void sort(List myList)
myList : A List type object we want to sort.
This method doesn't return anything
Esempio:
Let us suppose that our list contains
{'Geeks For Geeks' 'Friends' 'Dear' 'Is' 'Superb'}
After using Collection.sort() we obtain a sorted list as
{'Dear' 'Friends' 'Geeks For Geeks' 'Is' 'Superb'}
Ordinamento di un ArrayList in ordine crescente
JAVA
// Java program to demonstrate working of Collections.sort() import java.util.*; public class Collectionsorting { public static void main(String[] args) { // Create a list of strings ArrayList<String> al = new ArrayList<String>(); al.add('Geeks For Geeks'); al.add('Friends'); al.add('Dear'); al.add('Is'); al.add('Superb'); /* Collections.sort method is sorting the elements of ArrayList in ascending order. */ Collections.sort(al); // Let us print the sorted list System.out.println('List after the use of' + ' Collection.sort() :n' + al); } }
Produzione
List after the use of Collection.sort() : [Dear Friends Geeks For Geeks Is Superb]
Complessità temporale : O(N log N) poiché la complessità temporale di Collections.sort() è O(nlog(n)).
Spazio ausiliario : O(1)
Ordinamento di un ArrayList in ordine decrescente
JAVA// Java program to demonstrate working of Collections.sort() // to descending order. import java.util.*; public class Collectionsorting { public static void main(String[] args) { // Create a list of strings ArrayList<String> al = new ArrayList<String>(); al.add('Geeks For Geeks'); al.add('Friends'); al.add('Dear'); al.add('Is'); al.add('Superb'); /* Collections.sort method is sorting the elements of ArrayList in ascending order. */ Collections.sort(al Collections.reverseOrder()); // Let us print the sorted list System.out.println('List after the use of' + ' Collection.sort() :n' + al); } }
Produzione
List after the use of Collection.sort() : [Superb Is Geeks For Geeks Friends Dear]
Complessità temporale: O(N log N) poiché la complessità temporale di Collections.sort() è O(nlog(n)).
Spazio ausiliario: O(1)
Ordinamento di un ArrayList in base ai criteri definiti dall'utente. Possiamo usare Interfaccia comparatore a questo scopo.
Java// Java program to demonstrate working of Comparator // interface and Collections.sort() to sort according // to user defined criteria. import java.util.*; import java.lang.*; import java.io.*; // A class to represent a student. class Student { int rollno; String name address; // Constructor public Student(int rollno String name String address) { this.rollno = rollno; this.name = name; this.address = address; } // Used to print student details in main() public String toString() { return this.rollno + ' ' + this.name + ' ' + this.address; } } class Sortbyroll implements Comparator<Student> { // Used for sorting in ascending order of // roll number public int compare(Student a Student b) { return a.rollno - b.rollno; } } // Driver class class Main { public static void main (String[] args) { ArrayList<Student> ar = new ArrayList<Student>(); ar.add(new Student(111 'bbbb' 'london')); ar.add(new Student(131 'aaaa' 'nyc')); ar.add(new Student(121 'cccc' 'jaipur')); System.out.println('Unsorted'); for (int i=0; i<ar.size(); i++) System.out.println(ar.get(i)); Collections.sort(ar new Sortbyroll()); System.out.println('nSorted by rollno'); for (int i=0; i<ar.size(); i++) System.out.println(ar.get(i)); } }
Produzione
Unsorted 111 bbbb london 131 aaaa nyc 121 cccc jaipur Sorted by rollno 111 bbbb london 121 cccc jaipur 131 aaaa nyc
Array.sort() vs Collezioni.sort() Arrays.sort funziona anche per array che possono essere di tipo dati primitivo. Collezioni .sort() funziona per raccolte di oggetti come ArrayList Lista collegata ecc. Possiamo usare Collections.sort() per ordinare un array dopo aver creato un ArrayList di determinati elementi dell'array.
// Using Collections.sort() to sort an array import java.util.*; public class Collectionsort { public static void main(String[] args) { // create an array of string objs String domains[] = {'Practice' 'Geeks' 'Code' 'Quiz'}; // Here we are making a list named as Collist List colList = new ArrayList(Arrays.asList(domains)); // Collection.sort() method is used here // to sort the list elements. Collections.sort(colList); // Let us print the sorted list System.out.println('List after the use of' + ' Collection.sort() :n' + colList); } }
Produzione
List after the use of Collection.sort() : [Code Geeks Practice Quiz]
Complessità temporale di Arrays.sort() vs Collections.sort():
Arrays.sort() utilizza un algoritmo Quicksort Dual-Pivot che fornisce una complessità temporale di O(N.log N), che in genere è più veloce degli algoritmi Quicksort tradizionali. D'altra parte Collections.sort() crea un array di elementi dell'elenco, li ordina utilizzando un algoritmo Mergesort adattivo e scorre l'elenco per posizionare ciascun elemento nella posizione corretta. Pertanto, per tipi di dati primitivi come int char double ecc. Arrays.sort() si rivela molto più efficiente in termini di tempo di Collections.sort(). I problemi che coinvolgono i tipi di dati primitivi dovrebbero essere tentati di risolvere utilizzando Arrays.sort() per una migliore ottimizzazione.
Di seguito è riportato il codice per dimostrare la differenza:
Java/*package whatever //do not write package name here */ import java.io.*; import java.util.*; class GFG { public static void main (String[] args) { int len = 5000000; // creating a large test array int[] arr = new int[len]; for (int i = len; i > 0; i--) arr[len - i] = i; // creating a large test arraylist ArrayList<Integer> list = new ArrayList<>(); for (int i = len; i > 0; i--) list.add(i); // calculating time used by arrays.sort() long startA = System.currentTimeMillis(); Arrays.sort(arr); long stopA = System.currentTimeMillis(); // calculating time used by collections.sort() long startAL = System.currentTimeMillis(); Collections.sort(list); long stopAL = System.currentTimeMillis(); System.out.println('Time taken by Arrays.sort(): ' + (stopA - startA)); System.out.println('Time taken by Collections.sort(): ' + (stopAL - startAL)); } } // This code is contributed by godcoder28
Produzione
Time taken by Arrays.sort(): 29 Time taken by Collections.sort(): 42
Si desidera che l'articolo sia utile agli stimati Geek. .