java.util.Collections.sort() metoda jest obecna w klasie java.util.Collections. Służy do sortowania elementów występujących w określonym lista kolekcji w kolejności rosnącej. Działa podobnie java.util.Arrays.sort() metoda, ale jest lepsza niż ta, która może sortować elementy tablicy, a także kolejkę połączonych list i wiele innych w niej obecnych.
public static void sort(List myList)
myList : A List type object we want to sort.
This method doesn't return anything
Przykład:
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'}
Sortowanie listy ArrayList w kolejności rosnącej
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); } }
Wyjście
List after the use of Collection.sort() : [Dear Friends Geeks For Geeks Is Superb]
Złożoność czasu : O(N log N), ponieważ złożoność czasowa Collections.sort() wynosi O(nlog(n)).
Przestrzeń pomocnicza : O(1)
Sortowanie listy ArrayList w kolejności malejącej
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); } }
Wyjście
List after the use of Collection.sort() : [Superb Is Geeks For Geeks Friends Dear]
Złożoność czasowa: O(N log N), ponieważ złożoność czasowa Collections.sort() wynosi O(nlog(n)).
Przestrzeń pomocnicza: O(1)
Sortowanie ArrayList według kryteriów zdefiniowanych przez użytkownika. Możemy skorzystać Interfejs komparatora w tym celu.
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)); } }
Wyjście
Unsorted 111 bbbb london 131 aaaa nyc 121 cccc jaipur Sorted by rollno 111 bbbb london 121 cccc jaipur 131 aaaa nyc
Tablice.sort() vs Kolekcje.sort() Arrays.sort działa w przypadku tablic, które mogą być również prymitywnymi typami danych. Kolekcje .sort() działa dla kolekcji obiektów takich jak Lista tablic Połączona lista itp. Możemy użyć Collections.sort() do sortowania tablicy po utworzeniu ArrayList danych elementów tablicy.
// 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); } }
Wyjście
List after the use of Collection.sort() : [Code Geeks Practice Quiz]
Złożoność czasowa Arrays.sort() vs Collections.sort() :
Arrays.sort() wykorzystuje algorytm Quicksort Dual-Pivot, który daje złożoność czasową O(N.log N), która jest zazwyczaj szybsza niż tradycyjne algorytmy Quicksort. Z drugiej strony funkcja Collections.sort() tworzy tablicę elementów listy, sortuje je przy użyciu adaptacyjnego algorytmu Mergesort i wykonuje iterację po liście, aby umieścić każdy element we właściwym miejscu. Zatem w przypadku prymitywnych typów danych, takich jak int char double itp. metoda Arrays.sort() okazuje się znacznie bardziej wydajna czasowo niż Collections.sort(). Problemy związane z prymitywnymi typami danych należy próbować rozwiązać za pomocą Arrays.sort() w celu lepszej optymalizacji.
Poniżej znajduje się kod ilustrujący różnicę:
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
Wyjście
Time taken by Arrays.sort(): 29 Time taken by Collections.sort(): 42
Artykuł ma być przydatny dla cenionych Geeków. .