En af de mest almindelige funktioner, vi har brug for som udviklere, der beskæftiger sig med data, er sortering - ved at være i stand til at sortere vores data kan vi optimere vores algoritmer til at køre meget hurtigere og finde de data, de skal bruge på en brøkdel af den tid, den ville tage til ellers. I dagens lektion vil vi tale om Java Collections sort(). Som et hurtigt tankeeksperiment: Forestil dig, at du søger efter et navn gennem et universitets vagtplan. Der kan være titusindvis af elever på denne skole. Hvis den liste, du fik, ikke var i alfabetisk rækkefølge, ville du skulle bladre gennem hver enkelt side og kigge meget omhyggeligt for at sikre, at du ikke springer et enkelt navn over nogen steder, indtil du endelig finder det navn, du leder efter. På den anden side, hvis vagtlisten var alfabetiseret, skal du ikke kun være mindre streng i din søgning, men du kan nemt springe til sektionen i listen med det samme første bogstav og fortsætte med at hoppe rundt på siderne i store spring, indtil du lander på den person, du ledte efter. Jo flere data du arbejder med, jo vigtigere er det, at du bruger dem så effektivt og effektivt som muligt. I denne artikel vil vi gennemgå, hvordan man sorterer enhver listeimplementering i Java (inklusive ArrayList) ved hjælp af sorteringsmetoden Collections.
Sådan sorteres en ArrayList i Java ved hjælp af sorteringsmetoden Java Collections
Lad os tale om metoden Java Collections.sort. Java.util-pakken indeholder mange nyttige værktøjer og pakker, som ofte bruges af udviklere, inklusive ArrayList. Antag, at du har følgende simple program:
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");
}
}
Du ønsker at kunne printe farvelisten ud, men i alfabetisk rækkefølge. Hvordan kan du gøre dette? Ved at bruge java.util.Collections er sortering lige så let som en one-liner:
Collections.sort(colors);
Ta-da! Din farveliste er nu sorteret på plads. Hvis du skulle udskrive listen, som sådan:
System.out.println(colors);
Så får du følgende output:
[Blue, Green, Orange, Red]
Hvor nemt var det?! Det ville være lige så nemt at bruge Collections.sort() til at sortere i stigende rækkefølge en liste over heltal, flydende eller enhver anden simpel datatype for den sags skyld. Men hvad nu hvis du ville sortere i faldende rækkefølge? Der er helt sikkert tilfælde, hvor dette giver mening - forestil dig, at du havde en liste over testresultater for en bestemt klasse, og du ville finde ud af, hvem de mest scorende elever er. Det ville give meget mere mening at sortere listen i faldende rækkefølge (højeste score først), så de svar, du leder efter, er lige øverst. Heldigvis er Collections.sort() overskrevet med en valgfri 2. parameter, som giver dig mulighed for at gøre netop dette:
sort(List l, Comparator c)
Men hvad er en komparator? Nå, en komparator er simpelthen en funktion, der sammenligner to input og returnerer et tal, der repræsenterer, hvilket input der kommer først. Hvis du sorterer en ArrayList af primitive datatyper, så giver Java Collections dig allerede en reverseOrder() komparator. Det kan kaldes sådan:
Nu er farverne blevet omvendt sorteret på plads, så hvis du printede det ud, ville du få følgende output:
[Red, Orange, Green, Blue]
Sådan bruger du samlinger til at sortere ikke-primitive datatyper i Java
Indtil videre har du set, at sortering af ArrayLists af strenge eller ints i Java ved hjælp af Collections.sort()- metoden er lige så let som en linje kode. Men ofte vil dine ArrayLists gemme ikke-primitive datatyper. Når du arbejder med data, der har mere komplekse attributter, vil du gerne skrive klasser for at repræsentere disse objekter, og hvordan de vil blive sammenlignet med hinanden ved hjælp af deres attributter. For at udforske et eksempel på dette, lad os gense eksemplet med sortering af en liste over farver, men denne gang, i stedet for at sortere strenge, vil vi sortere farveobjekter. Vores grundlæggende farveklasse kan se sådan ud:
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;
}
}
For at gøre vores farveklasse kompatibel med Collections.sort(), så samlinger kan forstå, hvordan man sammenligner og sorterer farveobjekter, skal vi lave to små ændringer:
gør Farve til et sammenligneligt objekt (tilføj redskaber Comparable<Object>)
tilsidesætte compareTo-metoden i klassen (tilsidesæt public int compareTo(Object o))
Med disse ændringer ser vores klasse nu sådan ud:
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);
}
}
Bemærk, at Color's compareTo-metoden blot kalder String's compareTo-metoden; sortering vil foregå i alfabetisk rækkefølge. Hvis vi for eksempel ville sortere efter rød værdi i stigende rækkefølge, kunne vi erstatte return-sætningen med return this.r - cr; (hvis vi ville sortere efter grøn værdi i faldende rækkefølge, ville det være retur cg - this.g;). Nu, hvis vi ringer
Collections.sort(colors);
på en ArrayList of Colors i stedet for blot Strings, ville det fungere, fordi Collections forstår, hvordan man sammenligner Color-objekter. Hvis du ikke ønsker at få dit objekt til at implementere Comparable<Object>, kan du alternativt skrive en komparator for din klasse og overføre den til 2-parameter Collections.sort() metoden. En komparator tilsidesætter en metode public int compare(Objekt et, Objekt to), og metoden Collections.sort() bruger dette til at sammenligne objekter under sortering. Et eksempel på SortByName og SortByRed komparatorer er implementeret nedenfor:
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;
}
}
Med dette kan du nu ringe
Collections.sort(colors, new SortByName());
uden at Color-klassen faktisk implementerer Comparable, og den vil stadig fungere. Nogle gange vil du se, at dette gøres in-line ved hjælp af lambda-funktioner. En lambda-funktion er i bund og grund en navnløs funktion, som du kan definere inden for den kodelinje, som kalder den. De er nyttige, når du kun skal kalde en funktion for en bestemt instans og ikke ønsker at definere en hel separat funktion andre steder. SortByName-komparatoren kunne defineres in-line ved hjælp af en lambda-funktion, som denne:
Som du måske har gættet, repræsenterer (a, b) parametrene for lambda-funktionerne (de to objekter, der skal sammenlignes). -> betyder, at det følgende er en lambda-funktionsdefinition. Det handler om det! Du har nu set de mest populære metoder til at sortere ArrayLists i Java ved hjælp af Collections-pakken.
GO TO FULL VERSION