Třída pole je třída obsahující statické metody, které se používají s poli za účelem vyhledávání, řazení, porovnávání, vkládání prvků nebo vracení řetězcové reprezentace pole. Nejprve tedy specifikujme funkce a později o tom budeme diskutovat. Jsou přítomny následovně java.util.pole třída. Zde budeme diskutovat o různých grafech pomocí metoda sort() třídy Arrays .
Metoda Arrays.sort() se skládá ze dvou variant, z nichž jedna nepředává žádné argumenty, kde třídí celé pole, ať už je to pole celých čísel nebo pole znaků, ale pokud máme třídit konkrétní část pomocí této metody třídy Arrays, pak přetížíme jej a poli předáme počáteční a poslední index.
Syntax: metoda sort().
Arrays.sort();>
Syntax: Přetížená metoda sort().
public static void sort(int[] arr, int from_Index, int to_Index) ;>
Parametry: Vyžaduje tři parametry, jak je patrné ze syntaxe, která je následující:
- Pole, které se má seřadit
- Index prvního prvku, včetně, který má být seřazen (označovaný jako from_index)
- Index posledního prvku, exkluzivního, který má být seřazen (označovaný jako last_index)
Typ vrácení: ŽE
Analýza složitosti:
Časová náročnost: O(N log N)
Pomocný prostor: O(1)
char to int java
Nyní se podívejme na implementaci funkce sort() v různých scénářích třídy Arrays takto:
Příklad 1:
Jáva
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 +>);> >}> >}> }> |
>
>Výstup
The original array is: 5 -2 23 7 87 -42 509 The sorted array is: -42 -2 5 7 23 87 509>
Časová náročnost: O(nlog(n)) jako složitost polí.sort()
Pomocný prostor: O(1)
Příklad 2:
Jáva
Oracle sql se nerovná
// 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));> >}> }> |
>
>Výstup
Modified arr[] : [6, 7, 9, 13, 21, 45, 101, 102]>
Složitost výše uvedené metody:
Časová náročnost: O(N log N)
Pomocný prostor: O(1)
Příklad 3:
Jáva
// 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));> >}> }> |
>
vytváření instancí javy
>Výstup
Modified arr[] : [13, 6, 7, 21, 45, 9, 2, 100]>
Složitost výše uvedené metody:
Časová náročnost: O(nlog(n)) jako složitost polí.sort()
Pomocný prostor: O(1)
Příklad 4:
Jáva
// 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));> >}> }> |
>
>Výstup
Modified arr[] : [100, 45, 21, 13, 9, 7, 6, 2]>
Složitost výše uvedené metody:
Časová náročnost: O(nlog(n)) jako složitost polí.sort()
Pomocný prostor: O(1)
Příklad 5:
Jáva
// 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));> >}> }> |
>
>Výstup
Modified arr[] : Modified arr[] :[www.techcodeview.com, practice.techcodeview.com, code.techcodeview.com]>
Složitost výše uvedené metody:
Časová náročnost: O(nlog(n)) jako složitost polí.sort()
Pomocný prostor: O(1)
Nyní konečně zavedeme metodu sort() naplno, protože zde budeme deklarovat naše vlastní definovaná kritéria pomocí Rozhraní komparátoru .
Příklad 6:
Jáva
html tagy
// 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]); } }> |
>
>Výstup
Unsorted 111 bbbb london 131 aaaa nyc 121 cccc jaipur Sorted by rollno 111 bbbb london 121 cccc jaipur 131 aaaa nyc>
Složitost výše uvedené metody:
Časová náročnost: O(nlog(n)) jako složitost polí.sort()
Pomocný prostor: O(1)javatpoint java
Pamatovat si: Mezi Arrays.sort() vs Collections.sort() . Arrays.sort() funguje pro pole, která mohou být také primitivního datového typu. Sbírky .sort() funguje pro objekty jako jsou kolekce ArrayList , Spojový seznam , atd.
Použití metody obráceného pořadí: Tato metoda seřadí pole sestupně. V Java Collections třída také poskytuje obrácené pořadí() metoda k řazení pole v obráceném lexikografickém pořadí. Neanalyzuje žádný parametr z důvodu statické metody, takže jej můžeme vyvolat přímo pomocí názvu třídy. seřadí pole ve vzestupném pořadí metodou sort() a poté nám metoda obráceného pořadí() dá přirozené řazení a dostaneme seřazené pole v sestupném pořadí.
Syntax:
Arrays.sort(a, Collections.reverseOrder());>
Příklad 7:
Jáva
// 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));> >}> }> |
>
>Výstup
Array in descending order: [121, 110, 99, 66, 34, 12, 12, 0, -8, -110]>
Složitost výše uvedené metody:
Časová náročnost: O(nlog(n)) jako složitost polí.sort()
Pomocný prostor: O(1)