Arrays-klasse is een klasse die statische methoden bevat die worden gebruikt met arrays om elementen te zoeken, sorteren, vergelijken, invoegen of een tekenreeksrepresentatie van een array te retourneren. Laten we dus eerst de functies specificeren en later zullen we hetzelfde bespreken. Ze zijn als volgt aanwezig in java.util.Arrays klas. Hier zullen we verschillende plots bespreken met behulp van de sort() van de klasse Arrays .
De methode Arrays.sort() bestaat uit twee varianten: één waarin we geen argumenten doorgeven waarbij de volledige array wordt gesorteerd, of het nu een integer-array of een karakterarray is, maar als we een specifiek onderdeel moeten sorteren met behulp van deze methode van de klasse Arrays, dan we overbelasten het en geven de begin- en laatste index door aan de array.
Syntaxis: sort() Methode
Arrays.sort();>
Syntaxis: Overbelaste sort()-methode
public static void sort(int[] arr, int from_Index, int to_Index) ;>
Parameters: Er zijn drie parameters nodig, zoals blijkt uit de syntaxis die als volgt is:
- De array die moet worden gesorteerd
- De index van het eerste element, inclusief, dat moet worden gesorteerd (aangeduid als from_index)
- De index van het laatste element, exclusief, dat moet worden gesorteerd (ook wel last_index genoemd)
Retourtype: DAT
wanneer werd de school uitgevonden?
Complexiteitsanalyse:
Tijdcomplexiteit: O(N logboek N)
Hulpruimte: O(1)
Laten we nu de implementatie van de functie sort() in verschillende scenario's van de klasse Arrays als volgt bekijken:
Voorbeeld 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 +>' '>);> >}> >}> }> |
>
>Uitvoer
The original array is: 5 -2 23 7 87 -42 509 The sorted array is: -42 -2 5 7 23 87 509>
Tijdcomplexiteit: O(nlog(n)) vanwege de complexiteit van arrays.sort()
Hulpruimte: O(1)
Voorbeeld 2:
Java
Java-escape-teken
// 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));> >}> }> |
>
>Uitvoer
Modified arr[] : [6, 7, 9, 13, 21, 45, 101, 102]>
Complexiteit van de bovenstaande methode:
Tijdcomplexiteit: O(N logboek N)
Hulpruimte: O(1)
Voorbeeld 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));> >}> }> |
rhel versus centos
>
>Uitvoer
Modified arr[] : [13, 6, 7, 21, 45, 9, 2, 100]>
Complexiteit van de bovenstaande methode:
Tijdcomplexiteit: O(nlog(n)) vanwege de complexiteit van arrays.sort()
Hulpruimte: O(1)
Voorbeeld 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));> >}> }> |
>
>Uitvoer
Modified arr[] : [100, 45, 21, 13, 9, 7, 6, 2]>
Complexiteit van de bovenstaande methode:
Tijdcomplexiteit: O(nlog(n)) vanwege de complexiteit van arrays.sort()
Hulpruimte: O(1)
Voorbeeld 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));> >}> }> |
>
>Uitvoer
lees het csv-bestand in Java
Modified arr[] : Modified arr[] :[www.techcodeview.com, practice.techcodeview.com, code.techcodeview.com]>
Complexiteit van de bovenstaande methode:
Tijdcomplexiteit: O(nlog(n)) vanwege de complexiteit van arrays.sort()
Hulpruimte: O(1)
Nu zullen we ten slotte de methode sort() ten volle implementeren, omdat we hier onze eigen gedefinieerde criteria zullen declareren met behulp van de Vergelijkingsinterface .
Voorbeeld 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]); } }> |
>
>Uitvoer
Unsorted 111 bbbb london 131 aaaa nyc 121 cccc jaipur Sorted by rollno 111 bbbb london 121 cccc jaipur 131 aaaa nyc>
Complexiteit van de bovenstaande methode:
Tijdcomplexiteit: O(nlog(n)) vanwege de complexiteit van arrays.sort()
Hulpruimte: O(1)
Herinneren: Er is een klein verschil tussen Arrays.sort() en Arrays.sort() Collecties.sort() . Arrays.sort() werkt voor arrays die ook van een primitief gegevenstype kunnen zijn. Collecties .sort() werkt voor objecten Collecties zoals ArrayLijst , GelinkteLijst , enz.
Met behulp van de omgekeerde volgordemethode: Deze methode sorteert de array aflopend. De klasse Java Collections biedt ook de omgekeerde volgorde() methode om de array in omgekeerde lexicografische volgorde te sorteren. Het parseert geen enkele parameter vanwege de statische methode, dus we kunnen deze rechtstreeks aanroepen door de klassenaam te gebruiken. het zal arrays in oplopende volgorde sorteren met de sort() methode, daarna zal de reverse order() methode ons de natuurlijke volgorde geven en we zullen de gesorteerde array in aflopende volgorde krijgen.
Syntaxis:
Arrays.sort(a, Collections.reverseOrder());>
Voorbeeld 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));> >}> }> |
>
>Uitvoer
ssis-tutorial
Array in descending order: [121, 110, 99, 66, 34, 12, 12, 0, -8, -110]>
Complexiteit van de bovenstaande methode:
Tijdcomplexiteit: O(nlog(n)) vanwege de complexiteit van arrays.sort()
Hulpruimte: O(1)