Classe degli array è una classe contenente metodi statici utilizzati con gli array per cercare, ordinare, confrontare, inserire elementi o restituire una rappresentazione di stringa di un array. Quindi specifichiamo prima le funzioni e poi discuteremo dello stesso. Sono i seguenti essendo presenti in java.util.Arrays classe. Qui discuteremo diversi grafici utilizzando il file metodo sort() della classe Arrays .
Il metodo Arrays.sort() consiste di due varianti, una in cui non passiamo alcun argomento in cui ordina l'array completo, sia esso un array di numeri interi o un array di caratteri, ma se dobbiamo ordinare una parte specifica utilizzando questo metodo della classe Arrays, allora lo sovraccarichiamo e passiamo l'indice iniziale e l'ultimo all'array.
Sintassi: metodo sort()
Arrays.sort();>
Sintassi: Metodo sort() sovraccaricato
public static void sort(int[] arr, int from_Index, int to_Index) ;>
parametri: Prende tre parametri come si può percepire dalla sintassi che è la seguente:
- L'array da ordinare
- L'indice del primo elemento, compreso, da ordinare (denominato from_index)
- L'indice dell'ultimo elemento, esclusivo, da ordinare (denominato last_index)
Tipo di reso: QUELLO
Analisi della complessità:
Complessità temporale: O(N logN)
Spazio ausiliario: O(1)confronto di stringhe C#
Vediamo ora l'implementazione della funzione sort() nei diversi scenari della classe Arrays come segue:
Esempio 1:
Giava
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 +>' '>);> >}> >}> }> |
>
>Produzione
The original array is: 5 -2 23 7 87 -42 509 The sorted array is: -42 -2 5 7 23 87 509>
Complessità temporale: O(nlog(n)) in quanto è la complessità di arrays.sort()
Spazio ausiliario: O(1)
Esempio 2:
Giava
// 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));> >}> }> |
>
>Produzione
Modified arr[] : [6, 7, 9, 13, 21, 45, 101, 102]>
Complessità del metodo sopra:
Complessità temporale: O(N logN)
Spazio ausiliario: O(1)
Esempio 3:
Giava
// 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));> >}> }> |
>
>Produzione
Modified arr[] : [13, 6, 7, 21, 45, 9, 2, 100]>
Complessità del metodo sopra:
Complessità temporale: O(nlog(n)) in quanto è la complessità di arrays.sort()
Spazio ausiliario: O(1)
Esempio 4:
salva il video di YouTube vlc
Giava
// 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));> >}> }> |
>
>Produzione
Modified arr[] : [100, 45, 21, 13, 9, 7, 6, 2]>
Complessità del metodo sopra:
Complessità temporale: O(nlog(n)) in quanto è la complessità di arrays.sort()
Spazio ausiliario: O(1)
Esempio 5:
Giava
// 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));> >}> }> |
>
>Produzione
lancia int su string
Modified arr[] : Modified arr[] :[www.techcodeview.com, practice.techcodeview.com, code.techcodeview.com]>
Complessità del metodo sopra:
Complessità temporale: O(nlog(n)) in quanto è la complessità di arrays.sort()
Spazio ausiliario: O(1)
Ora finalmente implementeremo il metodo sort() al massimo perché qui dichiareremo i nostri criteri definiti con l'aiuto del Interfaccia comparatore .
Esempio 6:
Giava
// 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]); } }> |
>
>Produzione
Unsorted 111 bbbb london 131 aaaa nyc 121 cccc jaipur Sorted by rollno 111 bbbb london 121 cccc jaipur 131 aaaa nyc>
Complessità del metodo sopra:
Complessità temporale: O(nlog(n)) in quanto è la complessità di arrays.sort()
Spazio ausiliario: O(1)
Ricordare: C'è una leggera differenza tra Arrays.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 , eccetera.
Utilizzando il metodo dell'ordine inverso: Questo metodo ordinerà l'array in ordine discendente. Nella classe Collezioni Java fornisce anche il file ordine inverso() metodo per ordinare l'array in ordine lessicografico inverso. Non analizza alcun parametro perché metodo statico, quindi possiamo invocarlo direttamente utilizzando il nome della classe. ordinerà gli array in ordine crescente con il metodo sort(), dopodiché il metodo reverse order() ci fornirà l'ordinamento naturale e otterremo l'array ordinato in ordine decrescente.
Sintassi:
Arrays.sort(a, Collections.reverseOrder());>
Esempio 7:
Giava
// 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));> >}> }> |
>
>Produzione
Array in descending order: [121, 110, 99, 66, 34, 12, 12, 0, -8, -110]>
Complessità del metodo sopra:
Complessità temporale: O(nlog(n)) in quanto complessità di arrays.sort()
Spazio ausiliario: O(1)