java.util.Collections.sort() O método está presente na classe java.util.Collections. É usado para classificar os elementos presentes no especificado lista da Coleção em ordem crescente. Funciona de forma semelhante a java.util.Arrays.sort() método, mas é melhor do que porque pode classificar os elementos do Array, bem como a fila da lista vinculada e muitos outros presentes nele.
public static void sort(List myList)
myList : A List type object we want to sort.
This method doesn't return anything
Exemplo:
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'}
Classificando um ArrayList em ordem 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); } }
Saída
List after the use of Collection.sort() : [Dear Friends Geeks For Geeks Is Superb]
Complexidade de tempo : O(N log N) já que a complexidade de tempo de Collections.sort() é O(nlog(n)).
Espaço Auxiliar : O(1)
Classificando um ArrayList em ordem 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); } }
Saída
List after the use of Collection.sort() : [Superb Is Geeks For Geeks Friends Dear]
Complexidade de tempo: O(N log N) já que a complexidade de tempo de Collections.sort() é O(nlog(n)).
Espaço Auxiliar: O(1)
Classificando um ArrayList de acordo com critérios definidos pelo usuário. Podemos usar Interface do 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<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)); } }
Saída
Unsorted 111 bbbb london 131 aaaa nyc 121 cccc jaipur Sorted by rollno 111 bbbb london 121 cccc jaipur 131 aaaa nyc
Matrizes.sort() vs Coleções.sort() Arrays.sort funciona para arrays que também podem ser de tipos de dados primitivos. Coleções .sort() funciona para coleções de objetos como ListaArray Lista vinculada Podemos usar Collections.sort() para classificar um array após criar um ArrayList de determinados itens do 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); } }
Saída
List after the use of Collection.sort() : [Code Geeks Practice Quiz]
Complexidade de tempo Arrays.sort() vs Collections.sort():
Arrays.sort() usa um algoritmo Dual-Pivot Quicksort que fornece uma complexidade de tempo de O(N.log N), que normalmente é mais rápido do que os algoritmos Quicksort tradicionais. Por outro lado, Collections.sort() cria uma matriz de elementos de lista, classifica-os usando um algoritmo Mergesort adaptativo e itera sobre a lista para posicionar cada elemento em seu local correto. Assim, para tipos de dados primitivos como int char double etc. Arrays.sort() prova ser muito mais eficiente em termos de tempo do que Collections.sort(). Problemas envolvendo tipos de dados primitivos devem ser resolvidos usando Arrays.sort() para melhor otimização.
Abaixo está o código para demonstrar a diferença:
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
Saída
Time taken by Arrays.sort(): 29 Time taken by Collections.sort(): 42
O artigo pretende ser útil aos estimados Geeks. .