Sortieren in Java

• Sortieren in Java bedeutet im Grunde das Anordnen einer Gruppe von Elementen, die irgendwo gespeichert sind, in einer bestimmten Reihenfolge; diese Reihenfolge kann sowohl aufsteigend als auch absteigend sein; In der Echtzeitprogrammierung gibt es viele Szenarien, in denen es notwendig wird, die Elemente zu sortieren, da dies auch die Suche nach einem bestimmten Element vereinfacht, da die Elemente bei Sortierung einfach über einen Index von Arrays direkt abgerufen werden können. Elemente, die sortiert werden müssen, können entweder in einem Array oder einer Sammlung gespeichert werden. Die Sammlung besteht aus vielen Arten in Java-ähnlichen Mengen, Baum, Karte, Heap, Liste usw. Es gibt jedoch verschiedene Arten von Sortieralgorithmen, die zum Sortieren der Elemente in einer Array-ähnlichen Blasensortierung, Heap-Sortierung, Einfügungssortierung verwendet werden , Auswahlsortierung, Zusammenführungssortierung usw.
• Programmierer verwenden unterschiedliche Algorithmen, um die Elemente entsprechend ihren spezifischen Anforderungen und der Komplexität der Algorithmen zu sortieren. Diese Sortieralgorithmen werden durch die Verwendung verschiedener Schleifen und Variablen implementiert, um sie zu durchlaufen. Abgesehen von der Verwendung der Sortieralgorithmen zum Sortieren der Elemente in einem Array bietet Java die eingebaute Sortierfunktion, die dabei helfen kann, und der Programmierer muss nicht in großen Schleifen stecken bleiben und über Komplexität nachdenken. Ja, Sie haben richtig gehört, in Java wird die Funktion sort() verwendet, um die entweder in Arrays oder Sammlungen gespeicherten Elemente zu sortieren, und das mit einer sehr geringeren Komplexität von o(n(logn)). Allerdings ist die Implementierung der Methode in beiden Fällen etwas unterschiedlich.

Syntax für Arrays:

Arrays.sort(array_name);

Für Sammlungen

Starten Sie Ihren kostenlosen Softwareentwicklungskurs

Webentwicklung, Programmiersprachen, Softwaretests und andere

Collections.sort(array_name_list);

• Hier ist array_name und array_name_list der Name des Arrays oder der Sammlung, die sortiert werden muss.
• Arrays sind die Namen von Java-Klassen.
• Die Sammlung ist ein Framework in Java.
• sort() ist die integrierte Sortierfunktion, die in Java verwendet wird.

Wie wird die Sortierung in Java durchgeführt?

Im Folgenden sind die Punkte aufgeführt:

• Durch die Verwendung von Sortieralgorithmen kann die Sortierung auch mit Algorithmen durchgeführt werden, die von ineffizient bis effizient variieren, und jeder Algorithmus hat seine eigene zeitliche und räumliche Komplexität.
• Manchmal sind diese Algorithmen sehr komplex, sodass sie nicht in realen Szenarien verwendet werden können, in denen große Datenmengen verarbeitet werden müssen.
• Wie oben erwähnt, wird sort() in der in Java integrierten Funktion verwendet, um alle Elemente eines Arrays und einer Sammlung zu sortieren. Laut dem offiziellen Java DOC verwendet Array.sort die Quicksortierung, bei der es sich um die Doppel-Pivot-Sortierung handelt und die vergleichsweise viel schneller ist als die Single-Pivot-Schnellsortierung.
• Einer der größten Vorteile davon ist, dass es eine Komplexität von O(n(logn)) bietet. Es verwendet die sehr stabile und iterative Implementierung des Array-Objekts von Merge Sort. Java bietet eine Methode, um das Array auch in umgekehrter Reihenfolge zu sortieren, je nach Anforderung des Programmierers, entweder in aufsteigender oder absteigender Reihenfolge zu sortieren. Die Methode Collections.reverseOrder() wird verwendet, um die Elemente in umgekehrter oder absteigender Reihenfolge zu sortieren.
• Java 8 bietet außerdem die Möglichkeit, die Arrays parallel mithilfe der parallelen Sortierung zu sortieren, die das Multithreading-Konzept von Java nutzt und das gesamte Array in Teile aufteilt und diese nach dem Sortieren zusammenführt.

Arten der Sortierung in Java

Im Folgenden sind einige Möglichkeiten aufgeführt, mit denen die Sortierung beim Sortieren in Java durchgeführt werden kann:

1. sort(array_name)

Dies wird verwendet, um das gesamte Array aufsteigend zu sortieren. Standardmäßig sortiert diese Methode die Array-Elemente in aufsteigender Reihenfolge.

Code:

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));
}
}

Ausgabe:

2. Collection.reverseOrder()

Diese Methode in Java wird verwendet, um das Array in umgekehrter oder absteigender Reihenfolge zu sortieren. Es gibt Szenarien, in denen wir die Elemente in absteigender Reihenfolge sortieren müssen, und Java erledigt dies über die integrierte Methode.

Code:

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));
}
}

Ausgabe:

3. sort(int[ ] array_name, int findex, int lindex)

Wenn ein Teil eines Arrays anstelle des gesamten Arrays sortiert werden muss, bietet Java die Möglichkeit, diesen Array-Typ zu sortieren, indem drei Parameter angegeben werden, d. h. Array-Name und erster Index, ab dem die Sortierung gestartet werden muss und der letzte Index bis wann die Sortierung durchgeführt werden muss.

Code:

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));
}
}

Ausgabe:

4. Arrays.parllelSort(array_name)

From Java 8, the new API of the parallel sort has been released. Basically, in Parallel sort, the array is divided into 2 sub-arrays, and then the basic Array.sort() function is performed by a separate thread. The sorted arrays are then merged in the end to form the fully sorted array. This is done to leverage the use of multi-threading.

Code:

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));
}
}

Output:

Like a normal Array.sort(), Arrays.parallelSort() also provides the facility to sort a particular range of array or sorting an array in reverse order.

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()

This method is used to sort the collections like list, map, Set, etc. It uses the merge sort and gives the same complexity as Array.sort(), i.e. O(n(logn)).

1. Sorting a List in ascending order

Code:

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<Integer> arrList = Arrays.asList(arr);
//Sorting of list using the method
Collections.sort(arrList);
//Printing the list sorted above
System.out.println(arrList);
}
}

Output:

2. Sorting an Array List in descending order

Code:

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<Integer> arrList = Arrays.asList(arr);
//Sorting of list using the method
Collections.sort(arrList);
//Printing the list sorted above
System.out.println(arrList);
}
}

Output:

3. Sorting of Set

There are 3 basic rules while sorting a collection ‘Set’ using the above method sort(array_name):

1. 1. Convert the Set into the list.
   2. Sort the list using the method sort(array_name).
   3. Convert the resulting sorted List back to Set.

Code:

List<Integer> numList = new ArrayList<Integer>(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);
}
}

Output:

4. Sort a Map

Collection Map in Java is a combination of key and value So sorting can be done both ways, either through key or by value.

• Sort a Map by Key: Let’s see the below example of Sorting a Map by Key.

Code:

import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;
public class SortHashKey
{
public static void main(String[] args)
{
HashMap<Integer, String> 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<Integer, String> treeMap = new TreeMap<>(map);
System.out.println(treeMap);
}
}

Output:

One of the easiest ways to sort the elements of the Map by Keys is by adding the unsorted map elements in the TreeMap. TreeMap automatically sorts the elements in the ascending order of Hash Keys. Though collection.sort() can also be used to do the same, it is somewhat complex and needs to be coded well.

• Sort a Map by Value: Below mentioned is an example of how the sorting can be done in a Map using value.

Code: 

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<Integer, String> 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<Integer, String> sorted = new LinkedHashMap<>(); map.entrySet()
.stream()
.sorted(Map.Entry.comparingByValue())
.forEachOrdered(x -> sorted.put(x.getKey(), x.getValue()));

Output:

In the above example of sorting of Map by value, firstly we set the entries using the map.entrySet() and then stream of those entries using stream() method, call the sorted array using sorted() method by comparing by value in the pair. for each ordered() is used to traverse the stream to produce the result.

5. Comparable

Comparable is an Interface, and it makes the classes comparable to its instances.

To compare the two instances of the same class, Comparable interface needs to be implemented, and the method compareTo() needs to be overridden. The classes that implement this interface, its list of objects are sorted automatically using the method Collections.sort() and Arrays.sort().

Code:

ArrayList<Employee> 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);

Output:

Conclusion

The Sorting in Java methods used in Java for multiple scenarios of Arrays and Collections are explained above. A programmer needs to keep in mind how the sort() method should be used for different Collection types. With Java 8, sorting can also be done through Lambdas to implement the Comparator interface, which makes the sorting easier. Though it is a bit difficult to learn all of them, it can be easy working with them if all the basic concepts of Java, especially data streaming, Arrays, and Collections, are clear. Though sorting Algorithms are evergreen and can be easily implemented in Java-like other programming languages, they have varying complexity, and the in-built function sort() of Java makes things easier if the basic concepts are learned by heart.

Das obige ist der detaillierte Inhalt vonSortieren in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!