Arrays-luokka on luokka, joka sisältää staattisia menetelmiä, joita käytetään taulukoiden kanssa etsimään, lajittelemaan, vertaamaan, lisäämään elementtejä tai palauttamaan taulukon merkkijonoesitys. Joten täsmennetään ensin toiminnot ja myöhemmin keskustelemme samasta. Ne ovat seuraavat, kun ne ovat läsnä java.util.Arrays luokkaa. Täällä keskustelemme erilaisista juoneista käyttämällä Arrays-luokan sort()-metodi .
Arrays.sort() -menetelmä koostuu kahdesta muunnelmasta, joista yksi, jossa emme välitä argumentteja, joissa se lajittelee koko taulukon, oli se sitten kokonaislukutaulukko tai merkkijono, mutta jos meidän on tarkoitus lajitella tietty osa tällä Arrays-luokan menetelmällä ylikuormitamme sen ja välitämme aloitus- ja viimeisen indeksin taulukkoon.
Syntaksi: sort() -menetelmä
Arrays.sort();>
Syntaksi: Overloaded sort() -menetelmä
public static void sort(int[] arr, int from_Index, int to_Index) ;>
Parametrit: Se vaatii kolme parametria, jotka voidaan havaita syntaksista, joka on seuraava:
- Lajiteltava taulukko
- Ensimmäisen lajiteltavan elementin indeksi (kutsutaan nimellä from_index)
- Viimeisen lajiteltavan elementin indeksi, poissulkeva (viitataan nimellä last_index)
Palautustyyppi: ETTÄ
Monimutkaisuusanalyysi:
Aika monimutkaisuus: O(N log N)
Aputila: O(1)
Katsotaanpa nyt sort()-funktion toteutusta Arrays-luokan eri skenaarioissa seuraavasti:
Esimerkki 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 +>' '>);> >}> >}> }> |
>
>Lähtö
The original array is: 5 -2 23 7 87 -42 509 The sorted array is: -42 -2 5 7 23 87 509>
Aika monimutkaisuus: O(nlog(n)), koska se on taulukoiden monimutkaisuus.sort()
Aputila: O(1)
Esimerkki 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));> >}> }> |
>
lajittele arraylist javassa
>Lähtö
Modified arr[] : [6, 7, 9, 13, 21, 45, 101, 102]>
Yllä olevan menetelmän monimutkaisuus:
Aika monimutkaisuus: O(N log N)
Aputila: O(1)
Esimerkki 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));> >}> }> |
>
>Lähtö
Modified arr[] : [13, 6, 7, 21, 45, 9, 2, 100]>
Yllä olevan menetelmän monimutkaisuus:
Aika monimutkaisuus: O(nlog(n)), koska se on taulukoiden monimutkaisuus.sort()
Aputila: O(1)
Esimerkki 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));> >}> }> |
>
>Lähtö
Modified arr[] : [100, 45, 21, 13, 9, 7, 6, 2]>
Yllä olevan menetelmän monimutkaisuus:
Aika monimutkaisuus: O(nlog(n)), koska se on taulukoiden monimutkaisuus.sort()
Aputila: O(1)
Esimerkki 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));> >}> }> |
>
>Lähtö
Modified arr[] : Modified arr[] :[www.techcodeview.com, practice.techcodeview.com, code.techcodeview.com]>
Yllä olevan menetelmän monimutkaisuus:
Aika monimutkaisuus: O(nlog(n)), koska se on taulukoiden monimutkaisuus.sort()
Aputila: O(1)
Nyt lopuksi toteutamme sort()-menetelmän täysimääräisesti, koska tässä ilmoitamme omat määritellyt kriteerimme Vertailun käyttöliittymä .
Esimerkki 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]); } }> |
>
>Lähtö
Unsorted 111 bbbb london 131 aaaa nyc 121 cccc jaipur Sorted by rollno 111 bbbb london 121 cccc jaipur 131 aaaa nyc>
Yllä olevan menetelmän monimutkaisuus:
Aika monimutkaisuus: O(nlog(n)), koska se on taulukoiden monimutkaisuus.sort()
Aputila: O(1)
Muistaa: Arrays.sort() vs. välillä on pieni ero Collections.sort() . Arrays.sort() toimii taulukoille, jotka voivat olla myös primitiivistä tietotyyppiä. Kokoelmat .sort() toimii objekteille Kokoelmat kuten ArrayList , LinkedList , jne.
Käänteisen järjestyksen menetelmällä: Tämä menetelmä lajittelee taulukon laskevaan järjestykseen. Java-kokoelmat luokka tarjoaa myös käänteinen järjestys() menetelmä lajitella taulukko käänteiseen leksikografiseen järjestykseen. Se ei jäsennä mitään parametria staattisen menetelmän vuoksi, joten voimme kutsua sen suoraan käyttämällä luokan nimeä. se lajittelee taulukot nousevaan järjestykseen sort()-metodilla, minkä jälkeen käänteinen järjestys()-menetelmä antaa meille luonnollisen järjestyksen ja saamme lajitellut taulukot laskevassa järjestyksessä.
Syntaksi:
Arrays.sort(a, Collections.reverseOrder());>
Esimerkki 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));> >}> }> |
>
>Lähtö
Array in descending order: [121, 110, 99, 66, 34, 12, 12, 0, -8, -110]>
Yllä olevan menetelmän monimutkaisuus:
Aika monimutkaisuus: O(nlog(n)), koska se on taulukoiden monimutkaisuus.sort()
Aputila: O(1)