Een van de meest voorkomende functies die we nodig hebben als ontwikkelaars die met gegevens omgaan, is sorteren. Door onze gegevens te kunnen sorteren, kunnen we onze algoritmen optimaliseren om veel sneller te werken en de gegevens te vinden die nodig zijn in een fractie van de tijd die het nodig heeft. anders zou nemen. In de les van vandaag zullen we het hebben over Java Collections sort(). Als snel gedachte-experiment: stel je voor dat je op zoek bent naar een naam in het rooster van een universiteit. Er kunnen tienduizenden studenten op deze school zitten. Als de lijst die je hebt gekregen niet in alfabetische volgorde was, zou je door elke pagina moeten bladeren en heel goed moeten kijken om er zeker van te zijn dat je nergens een enkele naam hebt overgeslagen, totdat je eindelijk de naam vindt die je zoekt. Aan de andere kant, als het rooster alfabetisch was, moet je niet alleen minder rigoureus zijn in je zoektocht, maar je zou gemakkelijk naar de sectie in het rooster kunnen springen met dezelfde eerste letter, en met grote sprongen door pagina's blijven springen totdat je terechtkomt bij de persoon die je zocht. Hoe meer data u gebruikt, hoe belangrijker het is dat u deze zo effectief en efficiënt mogelijk gebruikt. In dit artikel gaan we in op het sorteren van elke List-implementatie in Java (inclusief ArrayList) met behulp van de sorteermethode Collections.
Hoe een ArrayList in Java te sorteren met behulp van de sorteermethode Java Collections
Laten we het hebben over de methode Java Collections.sort. Het pakket java.util bevat veel handige hulpprogramma's en pakketten die vaak door ontwikkelaars worden gebruikt, waaronder de ArrayList. Stel je hebt het volgende eenvoudige programma:
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");
}
}
U wilt de kleurenlijst kunnen afdrukken, maar wel in alfabetische volgorde. Hoe zou je dit kunnen doen? Met behulp van java.util.Collections is sorteren net zo eenvoudig als een one-liner:
Collections.sort(colors);
Ta-da! Uw kleurenlijst is nu op zijn plaats gesorteerd. Als u de lijst als zodanig zou afdrukken:
System.out.println(colors);
Dan zou je de volgende uitvoer krijgen:
[Blue, Green, Orange, Red]
Hoe makkelijk was dat?! Het zou net zo gemakkelijk zijn om Collections.sort() te gebruiken om een lijst met Integers, Floats of een ander eenvoudig gegevenstype in oplopende volgorde te sorteren. Maar wat als u in aflopende volgorde wilt sorteren? Er zijn zeker gevallen waarin dit zinvol is -- stel je voor dat je een lijst met toetsscores voor een bepaalde klas had en je wilde weten wie de best scorende leerlingen zijn. Het zou veel logischer zijn om de lijst in aflopende volgorde te sorteren (hoogste scores eerst), zodat de antwoorden die u zoekt helemaal bovenaan staan. Gelukkig wordt Collections.sort() overschreven met een optionele 2e parameter, waarmee je precies dit kunt doen:
sort(List l, Comparator c)
Maar wat is een vergelijker? Welnu, een comparator is gewoon een functie die twee ingangen vergelijkt en een getal retourneert dat aangeeft welke ingang het eerst komt. Als u een ArrayList van primitieve gegevenstypen sorteert, biedt Java Collections u al een reverseOrder()-comparator. Het kan als volgt worden genoemd:
Nu zijn de kleuren op hun plaats omgekeerd gesorteerd, zodat als u het afdrukt, u de volgende uitvoer krijgt:
[Red, Orange, Green, Blue]
Collecties gebruiken om niet-primitieve gegevenstypen in Java te sorteren
Tot nu toe heb je gezien dat het sorteren van ArrayLists van strings of ints in Java met behulp van de methode Collections.sort() net zo eenvoudig is als één regel code. Maar vaak slaan uw ArrayLists niet-primitieve gegevenstypen op. Wanneer u met gegevens werkt die complexere attributen hebben, wilt u klassen schrijven om deze objecten weer te geven en hoe ze met elkaar worden vergeleken met behulp van hun attributen. Om een voorbeeld hiervan te onderzoeken, gaan we terug naar het voorbeeld van het sorteren van een lijst met kleuren, maar deze keer sorteren we in plaats van Strings, Color-objecten. Onze basiskleurklasse kan er ongeveer zo uitzien:
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;
}
}
Om onze Color-klasse compatibel te maken met Collections.sort(), zodat Collections kan begrijpen hoe Color-objecten moeten worden vergeleken en gesorteerd, moeten we twee kleine wijzigingen aanbrengen:
maak van Kleur een Vergelijkbaar object (voeg werktuigen toe Vergelijkbaar<Object>)
overschrijf de methode CompareTo in de klasse (overschrijf public int CompareTo(Object o))
Met deze aanpassingen ziet onze klas er nu zo uit:
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);
}
}
Merk op dat de methode CompareTo van de kleur gewoon de methode CompareTo van String aanroept; sorteren gebeurt op alfabetische volgorde. Als we bijvoorbeeld willen sorteren op rode waarde in oplopende volgorde, kunnen we de instructie return vervangen door return this.r - cr; (als we zouden willen sorteren op groene waarde in aflopende volgorde, zou dat return cg - this.g; zijn). Als we nu bellen
Collections.sort(colors);
op een ArrayList of Colors in plaats van alleen Strings, zou het werken omdat Collections begrijpt hoe Color-objecten moeten worden vergeleken. Als u niet wilt dat uw object Comparable<Object> implementeert, kunt u ook een comparator voor uw klasse schrijven en die doorgeven aan de methode Collections.sort() met 2 parameters. Een comparator vervangt een methode public int Compare(Object één, Object twee), en de methode Collections.sort() gebruikt deze om objecten tijdens het sorteren te vergelijken. Een voorbeeld van SortByName- en SortByRed-vergelijkers wordt hieronder geïmplementeerd:
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;
}
}
Hiermee kunt u nu bellen
Collections.sort(colors, new SortByName());
zonder dat de klasse Color daadwerkelijk Comparable implementeert, en het zal nog steeds werken. Soms zie je dat dit in-line wordt gedaan, met behulp van lambda-functies. Een lambda-functie is in wezen een naamloze functie die u kunt definiëren binnen de coderegel die deze aanroept. Ze zijn handig wanneer u een functie slechts voor één specifieke instantie hoeft aan te roepen en niet elders een hele afzonderlijke functie wilt definiëren. De SortByName-comparator kan in-line worden gedefinieerd met behulp van een lambda-functie, zoals deze:
Zoals je misschien al geraden hebt, vertegenwoordigt (a, b) de parameters van de lambda-functies (de twee te vergelijken objecten). De -> geeft aan dat wat volgt een lambda-functiedefinitie is. Dat is het zo'n beetje! U hebt nu de meest populaire methoden gezien voor het sorteren van ArrayLists in Java met behulp van het Collections-pakket.
GO TO FULL VERSION