Arrays klass är en klass som innehåller statiska metoder som används med arrayer för att söka, sortera, jämföra, infoga element eller returnera en strängrepresentation av en array. Så låt oss specificera funktionerna först och senare kommer vi att diskutera detsamma. De är som följer närvarande i java.util.Arrays klass. Här kommer vi att diskutera olika tomter med hjälp av sort()-metoden för klassen Arrays .
Metoden Arrays.sort() består av två varianter, en där vi inte skickar några argument där den sorterar ner hela arrayen, vare sig det är heltalsmatris eller teckenmatris, men om vi ska sortera en specifik del med den här metoden i klassen Arrays så vi överbelastar det och skickar start- och sista indexet till arrayen.
Syntax: sort() Metod
Arrays.sort();>
Syntax: Överbelastad sort()-metod
public static void sort(int[] arr, int from_Index, int to_Index) ;>
Parametrar: Det tar tre parametrar som kan uppfattas från syntaxen som är följande:
java konverterar heltal till sträng
- Arrayen som ska sorteras
- Indexet för det första elementet, inklusive, som ska sorteras (Refereras till från_index)
- Indexet för det sista elementet, exklusivt, som ska sorteras (kallas last_index)
Returtyp: DEN DÄR
Komplexitetsanalys:
Tidskomplexitet: O(N log N)
Hjälputrymme: O(1)
Låt oss nu se implementeringen av sort()-funktionen över olika scenarier av klassen Arrays enligt följande:
Exempel 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>
Tidskomplexitet: O(nlog(n)) eftersom det är komplexiteten hos arrays.sort()
Hjälputrymme: O(1)
Exempel 2:
Java
infoga i tangentbordet
// 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]>
Komplexiteten hos ovanstående metod:
Tidskomplexitet: O(N log N)
Hjälputrymme: O(1)
Exempel 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]>
Komplexiteten hos ovanstående metod:
Tidskomplexitet: O(nlog(n)) eftersom det är komplexiteten hos arrays.sort()
Hjälputrymme: O(1)
Exempel 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]>
Komplexiteten hos ovanstående metod:
Tidskomplexitet: O(nlog(n)) eftersom det är komplexiteten hos arrays.sort()
Hjälputrymme: O(1)
Exempel 5:
Java
mysql unik nyckel
// 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));> >}> }> |
>
strängen är tom
>Produktion
Modified arr[] : Modified arr[] :[www.techcodeview.com, practice.techcodeview.com, code.techcodeview.com]>
Komplexiteten hos ovanstående metod:
Tidskomplexitet: O(nlog(n)) eftersom det är komplexiteten hos arrays.sort()
Hjälputrymme: O(1)
Nu slutligen kommer vi att implementera sort()-metoden fullt ut eftersom vi här kommer att deklarera våra egna definierade kriterier med hjälp av Jämförelsegränssnitt .
Exempel 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>
Komplexiteten hos ovanstående metod:
Tidskomplexitet: O(nlog(n)) eftersom det är komplexiteten hos arrays.sort()
Hjälputrymme: O(1)
Kom ihåg: Det finns en liten skillnad mellan Arrays.sort() vs Collections.sort() . Arrays.sort() fungerar för arrayer som också kan vara av primitiv datatyp. Samlingar .sort() fungerar för objekt som samlingar som ArrayList , Länkad lista , etc.
Använd den omvända ordningen: Denna metod kommer att sortera arrayen i fallande. Klassen Java Collections tillhandahåller också omvänd ordning() metod för att sortera arrayen i omvänd lexikografisk ordning. Den analyserar inte någon parameter eftersom statisk metod, så vi kan anropa den direkt genom att använda klassnamnet. den kommer att sortera arrayer i stigande ordning med sort()-metoden efter att den omvända ordningen()-metoden ger oss den naturliga ordningen och vi kommer att få den sorterade arrayen i fallande ordning.
Syntax:
Arrays.sort(a, Collections.reverseOrder());>
Exempel 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));> >}> }> |
>
itererar en lista i java
>Produktion
Array in descending order: [121, 110, 99, 66, 34, 12, 12, 0, -8, -110]>
Komplexiteten hos ovanstående metod:
Tidskomplexitet: O(nlog(n)) eftersom det är komplexiteten hos arrays.sort()
Hjälputrymme: O(1)