java.util.Collections.sort() El método está presente en la clase java.util.Collections. Se utiliza para ordenar los elementos presentes en el especificado. lista de Recaudación en orden ascendente. Funciona similar a java.util.Arrays.sort() método, pero es mejor, ya que puede ordenar los elementos de Array, así como la lista vinculada, la cola y muchos más presentes en él.
public static void sort(List myList) myList : A List type object we want to sort. This method doesn't return anything>
Ejemplo:
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'}> Ordenar un ArrayList en orden ascendente
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 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);> >}> }> |
pseudocódigo java
>
>Producción
List after the use of Collection.sort() : [Dear, Friends, Geeks For Geeks, Is, Superb]>
Complejidad del tiempo : O(N log N) ya que la complejidad temporal de Collections.sort() es O(nlog(n)).
Espacio Auxiliar :O(1)
Ordenar un ArrayList en orden descendente
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 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);> >}> }> |
>
>
tamaño de pitónProducción
List after the use of Collection.sort() : [Superb, Is, Geeks For Geeks, Friends, Dear]>
Complejidad del tiempo: O(N log N) ya que la complejidad temporal de Collections.sort() es O(nlog(n)).
Espacio Auxiliar: O(1)
Ordenar un ArrayList según criterios definidos por el usuario. Nosotros podemos usar Interfaz del comparador para este propósito.
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> {> >// 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)); } }> |
pitón o
>
>Producción
Unsorted 111 bbbb london 131 aaaa nyc 121 cccc jaipur Sorted by rollno 111 bbbb london 121 cccc jaipur 131 aaaa nyc>
matrices.sort() vs Colecciones.sort() Arrays.sort funciona para matrices que también pueden ser de tipos de datos primitivos. Colecciones .sort() funciona para colecciones de objetos como Lista de arreglo , Lista enlazada , etc. Podemos usar Collections.sort() para ordenar una matriz después de crear una ArrayList de elementos de matriz determinados.
JAVA
// 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);> >}> }> |
>
>Producción
List after the use of Collection.sort() : [Code, Geeks, Practice, Quiz]>
Complejidad temporal de Arrays.sort() vs Collections.sort():
Arrays.sort() utiliza un algoritmo Quicksort de doble pivote que proporciona una complejidad temporal de O(N.log N) que suele ser más rápida que los algoritmos Quicksort tradicionales. Por otro lado, Collections.sort() crea una matriz de elementos de la lista, los ordena utilizando un algoritmo Mergesort adaptativo e itera sobre la lista para colocar cada elemento en su ubicación correcta. Por lo tanto, para tipos de datos primitivos como int, char, double, etc. Arrays.sort() demuestra ser mucho más eficiente en cuanto a tiempo que Collections.sort(). Los problemas que involucran tipos de datos primitivos se deben intentar resolver usando Arrays.sort() para una mejor optimización.
eres empalme
A continuación se muestra el código para demostrar la diferencia:
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 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> |
>
>Producción
Time taken by Arrays.sort(): 29 Time taken by Collections.sort(): 42>
Se desea que el artículo sea útil para los estimados Geeks. .