Bevezetés a rendezésbe a Java-ban

  • A Java-ban történő válogatás alapvetően valahol egy adott sorrendben tárolt elemek csoportjának elrendezését szolgálja, ez lehet a növekvő vagy csökkenő sorrend is. A valós idejű programozás során sokféle forgatókönyv jön létre, ahol szükség van az elemek rendezésére, mivel ez a keresést is szükségessé teszi. egy adott elem könnyű, mivel az elemek a tömbök indexelésével egyszerűen beolvashatók, ha sorba rendezték őket. A rendezéshez szükséges elemeket tömbben vagy gyűjteményben is tárolhatjuk. A gyűjtemény sokféle típusú Java-stílusú készletekben, fában, térképen, halomban, listában stb., Bár vannak különféle rendezési algoritmusok, amelyeket az elemek sorolására használnak tömbszerű Bubble Sort, Heap Sort, Insertion Sort, Válogatás rendezése, Rendezés egyesítése stb.
  • A programozók különféle algoritmusokat használnak az elemek rendezésére az egyedi igények és az algoritmusok összetettsége alapján. Ezeket a rendezési algoritmusokat különféle hurkok és változók felhasználásával valósítják meg, hogy rajta iterálódjanak. Amellett, hogy a rendezési algoritmusokat használja a tömb elemeinek rendezésére, a Java biztosítja a beépített válogatás funkciót is, amely ugyanúgy segíthet, és a programozónak nem kell nagy hurkokba ragadnia és komplexitásra gondolni. Igen, jól hallotta, a Java-ban a sort () függvény tömbökben vagy gyűjteményekben tárolt elemek rendezésére szolgál, és az o (n (logn)) nagyon kevésbé összetett elemével. Bár a módszer végrehajtása mindkettőben kissé eltérő.

Tömbök szintaxisa:

Arrays.sort(array_name);

Gyűjteményekhez

Collections.sort(array_name_list);

  • Itt a tömb_neve és a tömb_neve lista a tömb vagy a gyűjtemény neve, amelyet rendezni kell.
  • A tömbök a Java osztályok neve.
  • A gyűjtemény Java keretrendszere.
  • a sort () a beépített válogatás funkció, amelyet a Java használ.

Hogyan történik a szortírozás a Java-ban?

A következő pontok a következők:

  • A rendezési algoritmusok használatával a rendezés elvégezhető olyan hatékonyságtól kezdve is változó algoritmussal, és minden algoritmusnak megvan a maga idő- és térbonyolultsága.
  • Ezek az algoritmusok néha nagyon bonyolultak, ezért nem használhatók valós forgatókönyvekben, ahol nagy mennyiségű adat kezelésére van szükség.
  • Mint fentebb említettük, a Java beépített függvényében a sort () egy tömb és gyűjtemény összes elemének rendezésére használják. A hivatalos Java DOC szerint az Array.sort a quicksortot használja, amely dupla pivot és viszonylag sokkal gyorsabb, mint az egypólusú gyors rendezés.
  • Ennek egyik legnagyobb előnye, hogy O (n (logn)) komplexet nyújt. A Merge Sort sor tömb objektumának nagyon stabil és iteratív megvalósítását használja. A Java egy módszert kínál a tömb fordított sorrendben történő rendezésére, annak megfelelően, hogy a programozó növekvő vagy csökkenő sorrendben rendezze. A Collections.reverseOrder () metódus az elemek fordított vagy csökkenő sorrendbe rendezésére szolgál.
  • A Java 8 lehetővé teszi a tömbök párhuzamos rendezését a Párhuzamos rendezés segítségével is, amely a Java többszálú koncepcióját használja, és a teljes tömböt részekre osztja, és a válogatás után összevonja azokat.

Rendezés típusai Java-ban

Az alábbiakban felsoroljuk a válogatás néhány módját a Java rendezése során:

1. rendezés (tömb_név)

Ez a teljes tömb növekvő rendezéséhez használható. Alapértelmezés szerint ez a módszer a tömb elemeit növekvő sorrendbe rendezi.

Kód:

import java.util.Arrays;
public class SimpleSort
(
public static void main(String() args)
(
//Unsorted array of numbers
Integer() arr = new Integer() (100, 20, 10, 30, 80, 70, 90, 40, 50, 60);
//Sort function to sort the above array
Arrays.sort(arr);
//Printing the sorted array on console
System.out.println(Arrays.toString(arr));
)
)

Kimenet:

2. Collection.reverseOrder ()

Ezt a Java módszert használják a tömb fordított vagy csökkenő sorrendbe történő rendezésére. Vannak forgatókönyvek, amikor az elemeket csökkenő sorrendbe kell rendezni, és a Java ezt a beépített módszerrel végzi el.

Kód:

import java.util.Arrays;
public class ReverseSort
(
public static void main(String() args)
(
//Unsorted array of numbers
Integer() arr = new Integer() ( 100, 20, 10, 30, 80, 70, 90, 40, 50, 60);
//Sort function to sort the above array
Arrays.sort(arr, Collections.reverseOrder());
//Printing the sorted array on console
System.out.println(Arrays.toString(arr));
)
)

Kimenet:

3. rendezés (int () tömb_név, int findex, int lindex)

Ha szükség van egy tömb egy részének rendezésére a teljes tömb helyett, akkor a Java lehetővé teszi az ilyen tömb típusának rendezését 3 paraméter megadásával, azaz a tömb nevével, az első mutatóval, ahonnan a válogatást el kell indítani, és az utolsó index, amíg a válogatást el kell végezni.

Kód:

import java.util.Arrays;
public class ReverseSort
(
public static void main(String() args)
(
//Unsorted array of numbers
Integer() arr = new Integer() ( 100, 20, 10, 30, 80, 70, 90, 40, 50, 60);
//Sort function to sort the above array
Arrays.sort(arr, 1, 5);
//Printing the sorted array on console
System.out.println(Arrays.toString(arr));
)

Kimenet:

4. Arrays.parllelSort (tömb_neve)

A Java 8-ból megjelenik a párhuzamos rendezés új API-ja. Alapvetően Párhuzamos rendezésben a tömb két részmátrixra oszlik, majd az Array.sort () alapvető funkciót egy külön szál hajtja végre. A rendezett tömböket ezután a végén egyesítik, hogy a teljesen rendezett tömb legyen. Ennek célja a többszálú menet felhasználásának ösztönzése.

Kód:

import java.util.Arrays;
public class ParallelSort
(
public static void main(String() args)
(
//Unsorted array of numbers
Integer() arr = new Integer() ( 100, 20, 10, 30, 80, 70, 90, 40, 50, 60);
//parallel Sort function to sort the above array
Arrays.parallelSort(arr);
//Printing the sorted array on console
System.out.println(Arrays.toString(arr));
)
)

Kimenet:

Mint a normál Array.sort (), az Arrays.parallelSort () lehetővé teszi a tömb adott tartományának rendezését vagy a tömb fordított sorrendben történő rendezését.

Szintaxis:

// to Sort a range of array by parallelsort
Arrays.parallelSort(array_name, findex, lindex);
// to sort an array in reverse order using parallelSort
Arrays.parallelSort(array_name, Collections.reverseOder());

5. Collection.sort ()

Ezt a módszert használják a gyűjtemények rendezésére, például lista, térkép, készlet stb. Az összevonási rendezést használja, és ugyanolyan összetettséget ad, mint az Array.sort (), azaz O (n (logn)).

1. A lista rendezése növekvő sorrendben

Kód:

import java.util.Arrays;
import java.util.Collections;
public class ListSort
(
public static void main(String() args)
(
//Unsorted list
Integer() arr = new Integer() ( 100, 20, 10, 30, 80, 70, 90, 40, 50, 60 );
List arrList = Arrays.asList(arr);
//Sorting of list using the method
Collections.sort(arrList);
//Printing the list sorted above
System.out.println(arrList);
)
)

Kimenet:

2. A tömblista rendezése csökkenő sorrendben

Kód:

import java.util.Arrays;
import java.util.Collections;
public class ListSortRev
(
public static void main(String() args)
(
//Unsorted array list of Integers
Integer() arr = new Integer() (100, 20, 10, 30, 80, 70, 90, 40, 50, 60 );
List arrList = Arrays.asList(arr);
//Sorting of list using the method
Collections.sort(arrList);
//Printing the list sorted above
System.out.println(arrList);
)
)

Kimenet:

3. A készlet rendezése

Három alapvető szabály létezik a „Set” gyűjteménynek a fenti módszer (tömb_neve) módszerével történő rendezésekor:

    1. Konvertálja a készletet a listába.
    2. Rendeld a listát a sort rendezési módszerrel (array_name).
    3. Konvertálja a kapott rendezett listát Set-re.

Kód:

List numList = new ArrayList(num) ;
//Sorting the list retrieved above
Collections.sort(numList);
// Converting sorted List into Set
num = new LinkedHashSet(numList);
//Printing the Resulting Set on console
System.out.println(num);
)
)

Kimenet:

4. Rendezzen egy térképet

A Java Java gyűjteménytérképe a kulcs és az érték kombinációja, tehát a szortírozás mindkét módon megtörténhet, akár kulcs, akár érték alapján.

  • Térkép rendezése kulcs szerint: Lásd az alábbi példát a Térkép rendezése kulcs alapján.

Kód:

import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;
public class SortHashKey
(
public static void main(String() args)
(
HashMap map = new HashMap();
map.put(80, "Akshay");
map.put(20, "Akash");
map.put(10, "Bob");
map.put(30, “Nitika");
map.put(90, "Yashi");
map.put(100, "Dragisa");
TreeMap treeMap = new TreeMap(map);
System.out.println(treeMap);
)
)

Kimenet:

Az egyik legegyszerűbb módszer a Térkép elemeinek kulcsok szerinti rendezéséhez a nem rendezett térkép elemek hozzáadása a TreeMap-be. A TreeMap automatikusan rendezi az elemeket a hasítógombok növekvő sorrendjében. Bár a collection.sort () ugyanezen műveletek elvégzésére is használható, kissé összetett, ezért jól kódolni kell.

  • Térkép rendezése érték szerint: Az alábbiakban bemutatunk egy példát arra, hogyan lehet a térképben rendezni az értéket.

Kód:

import java.util.HashMap;
import java.util.Map;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.Map;
public class SortHashValue
(
public static void main(String() args)
(
HashMap map = new HashMap(); map.put(80, "Akshay");
map.put(20, "Akash");
map.put(10, "Bob");
map.put(30, “Nitika");
map.put(90, "Yashi");
map.put(100, "Dragisa");
LinkedHashMap sorted = new LinkedHashMap(); map.entrySet()
.stream()
.sorted(Map.Entry.comparingByValue())
.forEachOrdered(x -> sorted.put(x.getKey(), x.getValue()));

Kimenet:

A Térkép érték szerinti rendezésének fenti példájában először a bejegyzéseket a map.entrySet () használatával állítottuk be, majd ezeknek a bejegyzéseknek a stream () módszerrel történő folyamát állítottuk elő, majd a rendezett tömböt rendezett () módszerrel hívjuk meg, összehasonlítva az értékkel a pár. mindegyik megrendelt () -et arra használjuk, hogy az eredményt megkapjuk az adatfolyamon.

5. Összehasonlítható

Összehasonlítható egy interfész, és az osztályokat összehasonlítja azok példányaival.

Ugyanazon osztály két példányának összehasonlításához összehasonlítandó felületet kell megvalósítani, és felül kell vizsgálni az összehasonlítás () módszerét. Az ezt a felületet megvalósító osztályok és az objektumlista automatikusan rendezésre kerül a Collections.sort () és az Arrays.sort () metódusok segítségével.

Kód:

ArrayList list = new ArrayList();
// Adding the instance objects of class Employee in list
list.add(new Employee(10, "Akshay")));
list.add(new Employee(40, "Bob")));
list.add(new Employee(20, "Priyansh")));
list.add(new Employee(50, "Chandni")));
list.add(new Employee(70, "Yashi")));
Collections.sort(list);
// Printing the sorted list on Console
System.out.println(list);

Kimenet:

Következtetés

A fentiekben a Java rendezés módszereit ismertetjük, amelyeket a Java a tömbök és gyűjtemények több forgatókönyve esetén használ. A programozónak szem előtt kell tartania, hogy a sort () módszert hogyan kell használni a különféle gyűjteménytípusokhoz. A Java 8 esetén a rendezés a Lambdason keresztül is elvégezhető a Comparator felület megvalósításához, ami megkönnyíti a válogatást. Bár egy kicsit nehéz megtanulni mindet, mégis könnyű velük együtt dolgozni, ha a Java minden alapfogalma, különösen az adatfolyam, a tömbök és a gyűjtemények világos. Bár a rendezési algoritmusok örökzöldek és könnyen megvalósíthatók Java-szerű programozási nyelvekhez hasonlóan, különbözõ bonyolultságúak, és a Java beépített függvénytípusa () megkönnyíti a dolgokat, ha az alapfogalmakat szívükön tanuljuk.

Ajánlott cikkek

Ez egy útmutató a Java rendezéshez. Itt megvitatjuk, hogy a válogatás miként működik a Java-ban, és a válogatás típusait a Java-ban, különböző kódokkal és kimenetekkel. Megnézheti más kapcsolódó cikkeinket, hogy többet megtudjon-

  1. JComboBox Java
  2. Rendezés C-ben
  3. Halom C sorrendben
  4. Bubble Rendezés a JavaScript-ben
  5. Mi a rendezés a C ++ kategóriában?
  6. Bevezetés a rendezésbe a PHP-ben
  7. Halom Rendezés Pythonban
  8. Beszúrás Rendezés a JavaScript-ben
  9. Hasperemtérkép a Java-ban
  10. Hasonlítható össze a Java példában Gyűjtemény interfész Java-ban

Kategória: