Java-Sammlungen sort()

Eine der häufigsten Funktionen, die wir als Entwickler benötigen, die mit Daten arbeiten, ist das Sortieren. Indem wir unsere Daten sortieren können, können wir unsere Algorithmen so optimieren, dass sie viel schneller laufen und die benötigten Daten in einem Bruchteil der Zeit finden, die sie benötigen Würde es sonst nehmen. In der heutigen Lektion sprechen wir über Java Collections sort(). Als kurzes Gedankenexperiment: Stellen Sie sich vor, Sie suchen im Verzeichnis einer Universität nach einem Namen. An dieser Schule können Zehntausende Schüler sein. Wenn die Liste, die Sie erhalten haben, nicht in alphabetischer Reihenfolge wäre, müssten Sie jede einzelne Seite durchblättern und sehr genau hinsehen, um sicherzustellen, dass Sie nirgendwo einen einzigen Namen überspringen, bis Sie schließlich den Namen finden, nach dem Sie suchen. Wenn die Liste hingegen alphabetisch geordnet ist, müssen Sie bei der Suche nicht nur weniger streng vorgehen, sondern Sie können jedoch problemlos zu dem Abschnitt in der Liste mit demselben Anfangsbuchstaben springen und in großen Sprüngen weiter durch die Seiten springen, bis Sie bei der gesuchten Person landen. Je mehr Daten Sie verarbeiten, desto wichtiger ist es, dass Sie diese so effektiv und effizient wie möglich nutzen. In diesem Artikel erfahren Sie, wie Sie jede List-Implementierung in Java (einschließlich ArrayList) mithilfe der Collections-Sortiermethode sortieren.

So sortieren Sie eine ArrayList in Java mithilfe der Sortiermethode „Java Collections“.

Lassen Sie uns über die Java Collections.sort-Methode sprechen. Das Paket java.util enthält viele nützliche Dienstprogramme und Pakete, die häufig von Entwicklern verwendet werden, einschließlich der ArrayList. Angenommen, Sie haben das folgende einfache Programm:

import java.util.*;
import java.io.*;
class Main{
     public static void main(String[] args){
          List<String> colors = new ArrayList<String>();
          colors.add("Red    ");
          colors.add("Orange");
          colors.add("Green");
          colors.add("Blue");
    }
}

Sie möchten die Farbliste ausdrucken können, jedoch in alphabetischer Reihenfolge. Wie könnten Sie das tun? Mit java.util.Collections ist das Sortieren so einfach wie ein Einzeiler:

Collections.sort(colors);

Ta-da! Ihre Farbliste wurde jetzt vor Ort sortiert. Wenn Sie die Liste als solche ausdrucken:

System.out.println(colors);

Dann würden Sie folgende Ausgabe erhalten:

[Blue, Green, Orange, Red]

Wie einfach war das?! Es wäre genauso einfach, Collections.sort() zu verwenden, um eine Liste von Ganzzahlen, Gleitkommazahlen oder anderen einfachen Datentypen in aufsteigender Reihenfolge zu sortieren. Aber was wäre, wenn Sie in absteigender Reihenfolge sortieren möchten? Es gibt definitiv Fälle, in denen dies sinnvoll ist – stellen Sie sich vor, Sie hätten eine Liste mit Testergebnissen für eine bestimmte Klasse und wollten herausfinden, wer die Schüler mit den besten Ergebnissen sind. Viel sinnvoller wäre es, die Liste absteigend zu sortieren (höchste Punktzahl zuerst), sodass die gesuchten Antworten ganz oben stehen. Zum Glück wird Collections.sort() mit einem optionalen zweiten Parameter überschrieben, der Ihnen genau dies ermöglicht:

sort(List l, Comparator c)

Aber was ist ein Komparator? Nun, ein Komparator ist einfach eine Funktion, die zwei Eingaben vergleicht und eine Zahl zurückgibt, die angibt, welche Eingabe zuerst kommt. Wenn Sie eine ArrayList mit primitiven Datentypen sortieren, stellt Ihnen Java Collections bereits einen ReverseOrder()-Komparator zur Verfügung. Es kann so heißen:

Collections.sort(colors, Collections.reverseOrder());

Jetzt wurden die Farben vor Ort umgekehrt sortiert, sodass Sie beim Ausdrucken die folgende Ausgabe erhalten würden:

[Red, Orange, Green, Blue]

So verwenden Sie Sammlungen zum Sortieren nicht-primitiver Datentypen in Java

Bisher haben Sie gesehen, dass das Sortieren von ArrayLists von Strings oder Ints in Java mit der Methode Collections.sort() so einfach ist wie eine Codezeile. Aber oft speichern Ihre ArrayLists nicht-primitive Datentypen. Wenn Sie mit Daten arbeiten, die über komplexere Attribute verfügen, möchten Sie möglicherweise Klassen schreiben, um diese Objekte darzustellen und wie sie anhand ihrer Attribute miteinander verglichen werden. Um ein Beispiel hierfür zu untersuchen, schauen wir uns noch einmal das Beispiel des Sortierens einer Liste von Farben an, aber dieses Mal werden wir anstelle von Strings Farbobjekte sortieren. Unsere grundlegende Farbklasse könnte etwa so aussehen:

public class Color{
	private int r;
	private int g;
	private int b;
	private String name;

	Color(String name, int red, int green, int blue){
   	this.name = name;
    	this.r = red;
   	this.g = green;
   	this.b = blue;
	}
}

Um unsere Color-Klasse mit Collections.sort() kompatibel zu machen, damit Collections verstehen kann, wie Color-Objekte verglichen und sortiert werden, müssen wir zwei kleine Änderungen vornehmen:

1. Machen Sie Color zu einem Comparable-Objekt (fügen Sie Comparable<Object> hinzu)
2. Überschreiben Sie die Methode „compareTo“ in der Klasse (überschreiben Sie public int „compareTo(Object o)“).

Mit diesen Modifikationen sieht unsere Klasse nun so aus:

public class Color implements Comparable<Object>{
	private int r;
	private int g;
	private int b;
	private String name;

	Color(int red int green, int blue, String name){
    	this.r = red;
   	this.g = green;
   	this.b = blue;
   	this.name = name;
	}

	@Override
	public int compareTo(Object o) {
    	Color c = (Color) o;
    	return this.name.compareTo(c.name);
	}
}

Beachten Sie, dass die Methode „compareTo“ der Farbe einfach die Methode „compareTo“ des Strings aufruft. Die Sortierung erfolgt in alphabetischer Reihenfolge. Wenn wir beispielsweise in aufsteigender Reihenfolge nach dem roten Wert sortieren wollten, könnten wir die return-Anweisung durch return this.r - cr; (Wenn wir in absteigender Reihenfolge nach grünem Wert sortieren wollten, wäre es cg - this.g;). Wenn wir jetzt anrufen

Collections.sort(colors);

Auf einer ArrayList von Farben statt nur auf Strings würde es funktionieren, weil Collections versteht, wie Farbobjekte verglichen werden. Wenn Sie nicht möchten, dass Ihr Objekt Comparable<Object> implementiert, können Sie alternativ einen Komparator für Ihre Klasse schreiben und diesen an die 2-Parameter-Methode Collections.sort() übergeben. Ein Komparator überschreibt eine Methode public int vergleichen(Objekt eins, Objekt zwei), und die Methode Collections.sort() verwendet diese, um Objekte beim Sortieren zu vergleichen. Ein Beispiel für die Komparatoren SortByName und SortByRed ist unten implementiert:

class SortByName implements Comparator<Color>
{
	public int compare(Color a, Color b)
	{
    	return a.name.compareTo(b.name);
	}
}

class SortByRGB implements Comparator<Color>
{
	public int compare(Color a, Color b)
	{
    	return a.r - b.r;
	}
}

Damit können Sie nun anrufen

Collections.sort(colors, new SortByName());

ohne dass die Color-Klasse tatsächlich Comparable implementiert, und es wird trotzdem funktionieren. Manchmal geschieht dies inline mithilfe von Lambda-Funktionen. Eine Lambda-Funktion ist im Wesentlichen eine namenlose Funktion, die Sie in der Codezeile definieren können, die sie aufruft. Sie sind nützlich, wenn Sie eine Funktion nur für eine bestimmte Instanz aufrufen müssen und nicht an anderer Stelle eine ganz separate Funktion definieren möchten. Der SortByName-Komparator könnte mithilfe einer Lambda-Funktion wie folgt inline definiert werden:

Collections.sort(colors, (a, b)-> {
          return a.name.compareTo(b.name)});

Wie Sie vielleicht erraten haben, stellt (a, b) die Parameter der Lambda-Funktionen (der beiden zu vergleichenden Objekte) dar. Das -> bedeutet, dass es sich bei dem Folgenden um eine Lambda-Funktionsdefinition handelt. Das ist alles! Sie haben jetzt die beliebtesten Methoden zum Sortieren von ArrayLists in Java mithilfe des Collections-Pakets kennengelernt.