Classe de matrius és una classe que conté mètodes estàtics que s'utilitzen amb matrius per cercar, ordenar, comparar, inserir elements o retornar una representació de cadena d'una matriu. Per tant, especifiquem les funcions primer i després parlarem del mateix. Estan presents de la següent manera java.util.Arrays classe. Aquí parlarem de diferents trames utilitzant el mètode sort() de la classe Arrays .

El mètode Arrays.sort() consta de dues variacions, una en què no passem cap argument on ordena la matriu completa, ja sigui una matriu entera o una matriu de caràcters, però si se suposa que hem d'ordenar una part específica mitjançant aquest mètode de la classe Arrays, aleshores el sobrecarreguem i passem l'índex inicial i l'últim a la matriu.

Sintaxi: Mètode sort().

Arrays.sort(); 

Sintaxi: Mètode sort() sobrecarregat

public static void sort(int[] arr, int from_Index, int to_Index) ; 

Paràmetres: Pren tres paràmetres com es pot percebre de la sintaxi que és la següent:

• La matriu que s'ha d'ordenar
• L'índex del primer element, inclòs, que s'ha d'ordenar (anomenat from_index)
• L'índex de l'últim element, exclusiu, a ordenar (anomenat last_index)

Tipus de retorn: AIXÒ

Anàlisi de complexitat:

Complexitat temporal: O(N log N)
Espai auxiliar: O(1)

Ara vegem la implementació de la funció sort() en diferents escenaris de la classe Arrays de la següent manera:

Exemple 1:

Java

import> java.util.Arrays;> class> GFG {> > public> static> void> main(String args[])> > {> > int> [] arr = {> 5> , -> 2> ,> 23> ,> 7> ,> 87> , -> 42> ,> 509> };> > System.out.println(> 'The original array is: '> );> > for> (> int> num : arr) {> > System.out.print(num +> ' '> );> > }> > Arrays.sort(arr);> > System.out.println(> ' The sorted array is: '> );> > for> (> int> num : arr) {> > System.out.print(num +> ' '> );> > }> > }> }>

Sortida

The original array is: 5 -2 23 7 87 -42 509 The sorted array is: -42 -2 5 7 23 87 509 

Complexitat temporal: O(nlog(n)) com a complexitat de arrays.sort()
Espai auxiliar: O(1)

Exemple 2:

Java

// Java Program to Sort Array of Integers> // by Default Sorts in an Ascending Order> // using Arrays.sort() Method> // Importing Arrays class from the utility class> import> java.util.Arrays;> // Main class> public> class> GFG {> > // Main driver method> > public> static> void> main(String[] args)> > {> > // Custom input array> > int> [] arr = {> 13> ,> 7> ,> 6> ,> 45> ,> 21> ,> 9> ,> 101> ,> 102> };> > // Applying sort() method over to above array> > // by passing the array as an argument> > Arrays.sort(arr);> > // Printing the array after sorting> > System.out.println(> 'Modified arr[] : '> > + Arrays.toString(arr));> > }> }>

Sortida

Modified arr[] : [6, 7, 9, 13, 21, 45, 101, 102] 

Complexitat del mètode anterior:

Complexitat temporal: O(N log N)
Espai auxiliar: O(1)

Exemple 3:

Java

// Java program to Sort a Subarray in Array> // Using Arrays.sort() method> // Importing Arrays class from java.util package> import> java.util.Arrays;> // Main class> public> class> GFG {> > // Main driver method> > public> static> void> main(String[] args)> > {> > // Custom input array> > // It contains 8 elements as follows> > int> [] arr = {> 13> ,> 7> ,> 6> ,> 45> ,> 21> ,> 9> ,> 2> ,> 100> };> > // Sort subarray from index 1 to 4, i.e.,> > // only sort subarray {7, 6, 45, 21} and> > // keep other elements as it is.> > Arrays.sort(arr,> 1> ,> 5> );> > // Printing the updated array which is> > // sorted after 2 index inclusive till 5th index> > System.out.println(> 'Modified arr[] : '> > + Arrays.toString(arr));> > }> }>

Sortida

Modified arr[] : [13, 6, 7, 21, 45, 9, 2, 100] 

Complexitat del mètode anterior:

Complexitat temporal: O(nlog(n)) com a complexitat de arrays.sort()
Espai auxiliar: O(1)

Exemple 4:

Java

// Java program to Sort a Subarray in Descending order> // Using Arrays.sort()> // Importing Collections class and arrays classes> // from java.util package> import> java.util.Arrays;> import> java.util.Collections;> // Main class> public> class> GFG {> > // Main driver method> > public> static> void> main(String[] args)> > {> > // Note that we have Integer here instead of> > // int[] as Collections.reverseOrder doesn't> > // work for primitive types.> > Integer[] arr = {> 13> ,> 7> ,> 6> ,> 45> ,> 21> ,> 9> ,> 2> ,> 100> };> > // Sorts arr[] in descending order using> > // reverseOrder() method of Collections class> > // in Array.sort() as an argument to it> > Arrays.sort(arr, Collections.reverseOrder());> > // Printing the array as generated above> > System.out.println(> 'Modified arr[] : '> > + Arrays.toString(arr));> > }> }>

Sortida

Modified arr[] : [100, 45, 21, 13, 9, 7, 6, 2] 

Complexitat del mètode anterior:

Complexitat temporal: O(nlog(n)) com a complexitat de arrays.sort()
Espai auxiliar: O(1)

Exemple 5:

Java

// Java program to sort an array of strings> // in ascending and descending alphabetical order> // Using Arrays.sort()> // Importing arrays and Collections class> // from java.util class> import> java.util.Arrays;> import> java.util.Collections;> // Main class> public> class> GFG {> > // Main driver method> > public> static> void> main(String[] args)> > {> > // Custom input string> > String arr[] = {> 'practice .techcodeview.com> ,> > 'www .techcodeview.com> ,> > 'code .techcodeview.com> };> > // Sorts arr[] in ascending order> > Arrays.sort(arr);> > System.out.println(> 'Modified arr[] : '> > + Arrays.toString(arr));> > // Sorts arr[] in descending order> > Arrays.sort(arr, Collections.reverseOrder());> > // Lastly printing the above array> > System.out.println(> 'Modified arr[] :'> > + Arrays.toString(arr));> > }> }>

Sortida

Modified arr[] : Modified arr[] :[www.techcodeview.com, practice.techcodeview.com, code.techcodeview.com] 

Complexitat del mètode anterior:

Complexitat temporal: O(nlog(n)) com a complexitat de arrays.sort()
Espai auxiliar: O(1)

Ara, finalment, implementarem el mètode sort() al màxim perquè aquí declararem els nostres propis criteris definits amb l'ajuda del Interfície de comparació .

Exemple 6:

Java

// Java program to demonstrate Working of> // Comparator interface> // Importing required classes> import> java.io.*;> import> java.lang.*;> import> java.util.*;> // Class 1> // A class to represent a student.> class> Student {> > int> rollno;> > String name, address;> > // Constructor> > public> Student(> int> rollno, String name, String address)> > {> > // This keyword refers to current object itself> > 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 2> // Helper class extending Comparator interface> 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;> > }> }> // Class 3> // Main class> class> GFG {> > // Main driver method> > public> static> void> main(String[] args)> > {> > Student[] arr> > = {> new> Student(> 111> ,> 'bbbb'> ,> 'london'> ),> > new> Student(> 131> ,> 'aaaa'> ,> 'nyc'> ),> > new> Student(> 121> ,> 'cccc'> ,> 'jaipur'> ) };> > System.out.println(> 'Unsorted'> );> > for> (> int> i => 0> ; i System.out.println(arr[i]); // Sorting on basic as per class 1 created // (user-defined) Arrays.sort(arr, new Sortbyroll()); System.out.println(' Sorted by rollno'); for (int i = 0; i System.out.println(arr[i]); } }>

Sortida

Unsorted 111 bbbb london 131 aaaa nyc 121 cccc jaipur Sorted by rollno 111 bbbb london 121 cccc jaipur 131 aaaa nyc 

Complexitat del mètode anterior:

Complexitat temporal: O(nlog(n)) com a complexitat de arrays.sort()
Espai auxiliar: O(1)

Recordeu: Hi ha una lleugera diferència entre Arrays.sort() vs Collections.sort() . Arrays.sort() funciona per a matrius que també poden ser de tipus de dades primitives. Col·leccions .sort() funciona per a objectes com Col·leccions ArrayList , LinkedList , etc.

Utilitzant el mètode d'ordre invers: Aquest mètode ordenarà la matriu de forma descendent. A les col·leccions de Java, la classe també proporciona ordre invers() mètode per ordenar la matriu en ordre lexicogràfic invers. No analitza cap paràmetre a causa del mètode estàtic, de manera que podem invocar-lo directament utilitzant el nom de la classe. ordenarà les matrius en ordre ascendent pel mètode sort() després d'això, el mètode d'ordre invers () ens donarà l'ordre natural i obtindrem la matriu ordenada en ordre descendent.

Sintaxi:

Arrays.sort(a, Collections.reverseOrder()); 

Exemple 7:

Java

// This will sort the array in the descending order> /*package whatever //do not write package name here */> import> java.util.Arrays;> import> java.util.Collections;> public> class> GFG {> > public> static> void> main(String[] args)> > {> > Integer[] array> > = {> 99> ,> 12> , -> 8> ,> 12> ,> 34> ,> 110> ,> 0> ,> 121> ,> 66> , -> 110> };> > Arrays.sort(array, Collections.reverseOrder());> > System.out.println(> > 'Array in descending order: '> > + Arrays.toString(array));> > }> }>

Sortida

Array in descending order: [121, 110, 99, 66, 34, 12, 12, 0, -8, -110] 

Complexitat del mètode anterior:

Complexitat temporal: O(nlog(n)) com a complexitat de arrays.sort()
Espai auxiliar: O(1)