Arrays-Klasse ist eine Klasse, die statische Methoden enthält, die mit Arrays verwendet werden, um Elemente zu suchen, zu sortieren, zu vergleichen, einzufügen oder eine Zeichenfolgendarstellung eines Arrays zurückzugeben. Lassen Sie uns also zuerst die Funktionen spezifizieren und später werden wir diese besprechen. Sie sind wie folgt vorhanden in java.util.Arrays Klasse. Hier werden wir verschiedene Plots mit dem diskutieren sort()-Methode der Arrays-Klasse .
Konvertierung einer Zeichenfolge in eine Ganzzahl in Java
Die Methode Arrays.sort() besteht aus zwei Varianten: Eine davon übergeben wir keine Argumente, wobei das gesamte Array sortiert wird, sei es ein Ganzzahl-Array oder ein Zeichen-Array. Wenn wir jedoch einen bestimmten Teil mit dieser Methode der Arrays-Klasse sortieren sollen, dann Wir überladen es und übergeben den Start- und Endindex an das Array.
Syntax: sort()-Methode
Arrays.sort();>
Syntax: Überladene sort()-Methode
public static void sort(int[] arr, int from_Index, int to_Index) ;>
Parameter: Es benötigt drei Parameter, wie aus der folgenden Syntax ersichtlich ist:
- Das zu sortierende Array
- Der Index des ersten zu sortierenden Elements (einschließlich from_index)
- Der Index des letzten exklusiven Elements, das sortiert werden soll (als last_index bezeichnet)
Rückgabetyp: DAS
Komplexitätsanalyse:
Zeitkomplexität: O(N log N)
Hilfsraum: O(1)
Sehen wir uns nun die Implementierung der Funktion sort() in verschiedenen Szenarien der Arrays-Klasse wie folgt an:
Beispiel 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 +>' '>);> >}> >}> }> |
>
>Ausgabe
The original array is: 5 -2 23 7 87 -42 509 The sorted array is: -42 -2 5 7 23 87 509>
Zeitkomplexität: O(nlog(n)) als Komplexität von arrays.sort()
Hilfsraum: O(1)
Beispiel 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));> >}> }> |
>
>Ausgabe
Rujira Banerjee
Modified arr[] : [6, 7, 9, 13, 21, 45, 101, 102]>
Komplexität der oben genannten Methode:
Zeitkomplexität: O(N log N)
Hilfsraum: O(1)
Beispiel 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));> >}> }> |
>
>Ausgabe
Modified arr[] : [13, 6, 7, 21, 45, 9, 2, 100]>
Komplexität der oben genannten Methode:
Zeitkomplexität: O(nlog(n)) als Komplexität von arrays.sort()
Hilfsraum: O(1)
Beispiel 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));> >}> }> |
>
>Ausgabe
Modified arr[] : [100, 45, 21, 13, 9, 7, 6, 2]>
Komplexität der oben genannten Methode:
Zeitkomplexität: O(nlog(n)) als Komplexität von arrays.sort()
Hilfsraum: O(1)Ganzzahl zum Verdoppeln von Java
Beispiel 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));> >}> }> |
>
>Ausgabe
Modified arr[] : Modified arr[] :[www.techcodeview.com, practice.techcodeview.com, code.techcodeview.com]>
Komplexität der oben genannten Methode:
Zeitkomplexität: O(nlog(n)) als Komplexität von arrays.sort()
Hilfsraum: O(1)
Zu guter Letzt werden wir die Methode sort() vollständig implementieren, da wir hier unsere eigenen definierten Kriterien mit Hilfe von deklarieren Komparatorschnittstelle .
Beispiel 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]); } }> |
>
Konvertieren Sie String in Int
>Ausgabe
Unsorted 111 bbbb london 131 aaaa nyc 121 cccc jaipur Sorted by rollno 111 bbbb london 121 cccc jaipur 131 aaaa nyc>
Komplexität der oben genannten Methode:
Zeitkomplexität: O(nlog(n)) als Komplexität von arrays.sort()
Hilfsraum: O(1)
Erinnern: Es gibt einen kleinen Unterschied zwischen Arrays.sort() vs Collections.sort() . Arrays.sort() funktioniert für Arrays, die auch einen primitiven Datentyp haben können. Sammlungen .sort() funktioniert für Objekte wie Sammlungen Anordnungsliste , LinkedList , usw.
Verwendung der Methode in umgekehrter Reihenfolge: Diese Methode sortiert das Array in absteigender Reihenfolge. In Java stellt die Collections-Klasse auch die bereit umgekehrte Reihenfolge() Methode zum Sortieren des Arrays in umgekehrter lexikografischer Reihenfolge. Da es sich um eine statische Methode handelt, werden keine Parameter analysiert, sodass wir sie direkt mithilfe des Klassennamens aufrufen können. Mit der Methode sort() werden Arrays in aufsteigender Reihenfolge sortiert. Danach gibt uns die Methode reverse order() die natürliche Reihenfolge und wir erhalten das sortierte Array in absteigender Reihenfolge.
Syntax:
Arrays.sort(a, Collections.reverseOrder());>
Beispiel 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));> >}> }> |
>
>Ausgabe
Array in descending order: [121, 110, 99, 66, 34, 12, 12, 0, -8, -110]>
Komplexität der oben genannten Methode:
Zeitkomplexität: O(nlog(n)) als Komplexität von arrays.sort()
Hilfsraum: O(1)