java.util.Collections.sort() Il metodo è presente nella classe java.util.Collections. Viene utilizzato per ordinare gli elementi presenti nello specificato elenco della Collezione in ordine crescente. Funziona in modo simile a java.util.Arrays.sort() ma è migliore in quanto può ordinare gli elementi di Array così come l'elenco collegato, la coda 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
GIAVA
// 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 al =>new> ArrayList();> >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() :
'> + al);> >}> }> |
programma principale in Java
>
>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
GIAVA
// 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 al =>new> ArrayList();> >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() :
'> + al);> >}> }> |
>
>Produzione
Java fa mentre l'esempio
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 per questo scopo.
Giava
// 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> {> >// 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 ar =>new> ArrayList();> >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 System.out.println(ar.get(i)); Collections.sort(ar, new Sortbyroll()); System.out.println('
Sorted by rollno'); for (int i=0; i System.out.println(ar.get(i)); } }> |
>
espressione di regressione in Java
>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 Lista di array , Lista collegata , ecc. Possiamo usare Collections.sort() per ordinare un array dopo aver creato un ArrayList di determinati elementi dell'array.
GIAVA
// 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() :
'> +> >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'altro canto, 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 rispetto a Collections.sort(). I problemi che coinvolgono i tipi di dati primitivi dovrebbero essere tentati di risolvere utilizzando Arrays.sort() per una migliore ottimizzazione.
Javascript globale variabile
Di seguito è riportato il codice per dimostrare la differenza:
Giava
/*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 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. .