Introduktion till sortering i Java
- Att sortera i Java är i princip att ordna en grupp element lagrade någonstans i en viss ordning, denna ordning kan vara både stigande eller fallande. Det finns många scenarier i realtidsprogrammering där det blir nödvändigt att sortera elementen eftersom det också gör att man söker efter ett visst element enkelt eftersom elementen enkelt kan hämtas genom index av matriser direkt om de sorteras. Element som behöver sorteras kan lagras antingen i en matris eller i en samling. Samlingen är av många typer i Java-liknande uppsättningar, träd, karta, hög, lista osv. Även om det finns olika typer av sorteringsalgoritmer som används för att sortera elementen i en matrisliknande bubblasortering, högsortering, insättningssortering, Urvalssortering, Slåssortering etc.
- Programmerare använder olika algoritmer för att sortera elementen efter deras specifika krav och komplexitet av algoritmer. Dessa sorteringsalgoritmer implementeras genom användning av olika slingor och variabler för att iterera igenom den. Förutom att använda sorteringsalgoritmerna för att sortera elementen i en matris, tillhandahåller Java den inbyggda funktionen för sortering som kan hjälpa till med detsamma och programmeraren behöver inte fastna i stora slingor och tänka på komplexitet. Ja, du hörde rätt, i Java sort () används funktionen för att sortera elementen som är lagrade antingen i matriser eller samlingar och det med mycket mindre komplexitet av o (n (logn)). Även om implementeringen av metoden i båda är lite annorlunda.
Syntax för matriser:
Arrays.sort(array_name);
För samlingar
Collections.sort(array_name_list);
- Här är array_name och array_name_list namnet på matrisen eller den samling som måste sorteras.
- Matriser är namnet på klasser i Java.
- Samlingen är ett ramverk i Java.
- sort () är den inbyggda sorteringsfunktionen som används i Java.
Hur sortering utförs i Java?
Följande är följande:
- Genom att använda sorteringsalgoritmer kan sortering också utföras med algoritmer som varierar från ineffektiv till effektiv och varje algoritm har sin egen tid och rymdkomplexitet.
- Ibland har dessa algoritmer mycket hög komplexitet att de inte kan användas i verkliga scenarier där det finns ett behov av att hantera stora mängder data.
- Som nämnts ovan används sortering () i Java-inbyggd funktion för att sortera alla element i en array och en samling. Enligt den officiella Java DOC använder Array.sort quicksort som är den dubbla pivoten och jämförelsevis mycket snabbare än den enda pivoten Quick Sort.
- En av de största fördelarna med detta är att det ger en komplexitet av O (n (logn)). Den använder den mycket stabila och iterativa implementeringen av arrayobjektet Merge Sort. Java tillhandahåller en metod för att sortera matrisen i omvänd ordning också enligt programmerarens krav för att sortera antingen i stigande eller fallande ordning. Metoden Collections.reverseOrder () används för att sortera elementen i omvänd eller fallande ordning.
- Java 8 tillhandahåller också möjligheten att sortera matriserna parallellt med hjälp av Parallell-sortering som använder Java-multiträdningskonceptet och delar upp hela matrisen i delar och sammanfogar dem efter sortering.
Typer av sortering i Java
Nedan nämns några av de sätt på vilka sortering kan utföras i sortering i Java:
1. sortera (array_name)
Detta används för att sortera hela arrayen i stigande standard. Denna metod sorterar arrayelementen i stigande ordning.
Koda:
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));
)
)
Produktion:
2. Collection.reverseOrder ()
Denna metod i Java används för att sortera matrisen i omvänd ordning eller fallande ordning. Det finns scenarier där vi måste sortera elementen i fallande ordning och Java gör det genom den inbyggda metoden.
Koda:
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));
)
)
Produktion:
3. sortera (int () array_name, int findex, int lindex)
Om det finns ett behov av att sortera en del av en matris istället för hela matrisen, ger Java möjligheten att sortera denna typ av array genom att ange 3 parametrar, dvs arraynamn, första index från var sorteringen måste startas och den sista index till när sorteringen måste göras.
Koda:
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));
)
Produktion:
4. Arrays.parllelSort (array_name)
Från Java 8 har det nya API: et av parallellsorteringen släppts. I parallell sortering delas matrisen upp i två undermatriser och sedan utförs den grundläggande Array.sort-funktionen () med en separat tråd. De sorterade matriserna slås sedan samman i slutet för att bilda den helt sorterade matrisen. Detta görs för att utnyttja användningen av flertrådar.
Koda:
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));
)
)
Produktion:
Liksom en vanlig Array.sort () ger Arrays.parallelSort () också möjligheten att sortera ett visst sortiment av array eller sortera en matris i omvänd ordning.
Syntax:
// 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 ()
Den här metoden används för att sortera samlingarna som lista, karta, uppsättning etc. Den använder sammanslagningssorten och ger samma komplexitet som Array.sort (), dvs O (n (logn)).
1. Sortera en lista i stigande ordning
Koda:
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);
)
)
Produktion:
2. Sortera en matrislista i fallande ordning
Koda:
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);
)
)
Produktion:
3. Sortering av uppsättning
Det finns tre grundläggande regler när du sorterar en samling 'Set' med ovanstående metodsortering (array_name):
-
- Konvertera uppsättningen till listan.
- Sortera listan med metoden sortering (array_name).
- Konvertera den resulterande sorterade listan tillbaka till Set.
Koda:
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);
)
)
Produktion:
4. Sortera en karta
Samlingskarta i Java är en kombination av nyckel och värde Så sortering kan göras båda sätten antingen genom nyckel eller efter värde.
- Sortera en karta efter nyckel: Låt oss se nedanstående exempel på att sortera en karta efter nyckel.
Koda:
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);
)
)
Produktion:
Ett av de enklaste sätten att sortera elementen på kartan efter nycklar är genom att lägga till de osorterade kartelementen i TreeMap. TreeMap sorterar automatiskt elementen i stigande ordning för Hash Keys. Även om collection.sort () också kan användas för att göra samma sak är det något komplicerat och måste kodas bra.
- Sortera en karta efter värde: Nedan nämns ett exempel på hur sorteringen kan göras på en karta med hjälp av värde.
Koda:
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()));
Produktion:
I exemplet ovan med sortering av karta efter värde ställer vi först posten med hjälp av map.entrySet () och sedan strömmen av dessa poster med hjälp av metoden ström (), ring den sorterade matrisen med metoden sorterad () genom att jämföra med värde i par. för varje beställd () används för att korsa strömmen för att producera resultatet.
5. Jämförbar
Jämförbart är ett gränssnitt och det gör klasserna jämförbara med dess instanser.
För att jämföra de två förekomsten av samma klass måste Jämförbara gränssnitt implementeras och metoden CompareTo () måste åsidosättas. Klasserna som implementerar detta gränssnitt, dess lista över objekt sorteras automatiskt med metoden Collections.sort () och Arrays.sort ().
Koda:
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);
Produktion:
Slutsats
Förklarade ovan är metoderna Sortering i Java som används i Java för flera scenarier av arrayer och samlingar. En programmerare måste tänka på hur sorteringsmetoden ska användas för olika samlingstyper. Med Java 8 kan sortering också göras via Lambdas för att implementera Comparator-gränssnittet, vilket underlättar sorteringen. Även om det är lite svårt att lära sig alla kan det vara enkelt att arbeta med dem om alla grundläggande koncept för Java, särskilt dataströmning, Arrays och Collections, är tydliga. Även om sorteringsalgoritmer är vintergröna och enkelt kan implementeras på Java-liknande programmeringsspråk, har de varierande komplexitet och den inbyggda funktionssorteringen () för Java gör saker enklare om de grundläggande koncepten lär sig med hjärta.
Rekommenderade artiklar
Detta är en guide till sortering i Java. Här diskuterar vi hur sortering utförs i java och sortering i java med olika koder och utgångar. Du kan också gå igenom våra andra relaterade artiklar för att lära dig mer-
- JComboBox i Java
- Sorterar i C
- Heap Sort in C
- Bubble Sortera i JavaScript
- Vad är sortering i C ++?
- Introduktion till sortering i PHP
- Heap Sort i Python
- Insättning Sortera i JavaScript
- Hashmap i Java
- Jämförbart i Java-exempel | Samlingsgränssnitt i Java