Arrays klasse er en klasse, der indeholder statiske metoder, der bruges sammen med arrays for at søge, sortere, sammenligne, indsætte elementer eller returnere en strengrepræsentation af et array. Så lad os specificere funktionerne først og senere vil vi diskutere det samme. De er som følger til stede i java.util.Arrays klasse. Her vil vi diskutere forskellige plots ved hjælp af sort() metode for Arrays-klassen .
Arrays.sort()-metoden består af to variationer, hvor vi ikke sender nogen argumenter, hvor den sorterer hele arrayet ned, hvad enten det er heltalsarray eller karakterarray, men hvis vi formodes at sortere en specifik del ved hjælp af denne metode af Arrays-klassen, vi overbelaster det og sender start- og sidste indeks til arrayet.
Syntaks: sort() metode
Arrays.sort();>
Syntaks: Overbelastet sort() metode
public static void sort(int[] arr, int from_Index, int to_Index) ;>
Parametre: Det kræver tre parametre, som det kan opfattes fra syntaksen, som er som følger:
- Det array, der skal sorteres
- Indekset for det første element, inklusive, der skal sorteres (Benævnt fra_indeks)
- Indekset for det sidste element, eksklusivt, der skal sorteres (Benævnt last_index)
Returtype: AT
Kompleksitetsanalyse:
Tidskompleksitet: O(N log N)
Hjælpeplads: O(1)
Lad os nu se implementeringen af sort()-funktionen på tværs af forskellige scenarier i Arrays-klassen som følger:
Eksempel 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 +>' '>);> >}> >}> }> |
>
>Produktion
The original array is: 5 -2 23 7 87 -42 509 The sorted array is: -42 -2 5 7 23 87 509>
Tidskompleksitet: O(nlog(n)) som kompleksiteten af arrays.sort()
Hjælpeplads: O(1)
Eksempel 2:
Java
vijay filmskuespiller
// 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));> >}> }> |
>
>Produktion
Modified arr[] : [6, 7, 9, 13, 21, 45, 101, 102]>
Kompleksiteten af ovenstående metode:
Tidskompleksitet: O(N log N)
Hjælpeplads: O(1)
Eksempel 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));> >}> }> |
>
>Produktion
Modified arr[] : [13, 6, 7, 21, 45, 9, 2, 100]>
Kompleksiteten af ovenstående metode:
Tidskompleksitet: O(nlog(n)) som kompleksiteten af arrays.sort()
Hjælpeplads: O(1)
Eksempel 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));> >}> }> |
>
>Produktion
Modified arr[] : [100, 45, 21, 13, 9, 7, 6, 2]>
Kompleksiteten af ovenstående metode:
Tidskompleksitet: O(nlog(n)) som kompleksiteten af arrays.sort()
Hjælpeplads: O(1)
Eksempel 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));> >}> }> |
int til det dobbelte
>
>Produktion
Modified arr[] : Modified arr[] :[www.techcodeview.com, practice.techcodeview.com, code.techcodeview.com]>
Kompleksiteten af ovenstående metode:
Tidskompleksitet: O(nlog(n)) som kompleksiteten af arrays.sort()
Hjælpeplads: O(1)
Til sidst vil vi implementere sort() metoden fuldt ud, fordi vi her vil erklære vores egne definerede kriterier ved hjælp af Komparator interface .
Eksempel 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]); } }> |
>
>Produktion
Unsorted 111 bbbb london 131 aaaa nyc 121 cccc jaipur Sorted by rollno 111 bbbb london 121 cccc jaipur 131 aaaa nyc>
Kompleksiteten af ovenstående metode:
Tidskompleksitet: O(nlog(n)) som kompleksiteten af arrays.sort()
Hjælpeplads: O(1)
Husk: Der er en lille forskel mellem Arrays.sort() vs Collections.sort() . Arrays.sort() virker for arrays, som også kan være af primitiv datatype. Samlinger .sort() virker for objekter som samlinger ArrayList , LinkedList , etc.
Brug af metoden i omvendt rækkefølge: Denne metode vil sortere arrayet i faldende. I Java Collections klassen giver også omvendt rækkefølge() metode til at sortere arrayet i omvendt leksikografisk rækkefølge. Den analyserer ikke nogen parameter, fordi den statiske metode, så vi kan kalde den direkte ved at bruge klassenavnet. den vil sortere arrays i stigende rækkefølge efter sort()-metoden, efter at den omvendte rækkefølge()-metoden vil give os den naturlige rækkefølge, og vi vil få den sorterede array i faldende rækkefølge.
Syntaks:
Arrays.sort(a, Collections.reverseOrder());>
Eksempel 7:
Java
t ff
// 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));> >}> }> |
>
>Produktion
Array in descending order: [121, 110, 99, 66, 34, 12, 12, 0, -8, -110]>
Kompleksiteten af ovenstående metode:
Tidskompleksitet: O(nlog(n)) som kompleksiteten af arrays.sort()
Hjælpeplads: O(1)