En av de vanligaste funktionerna som vi behöver som utvecklare som hanterar data är sortering – genom att kunna sortera vår data kan vi optimera våra algoritmer för att köras mycket snabbare och hitta den data den behöver på en bråkdel av tiden som den skulle ta till annars. I dagens lektion kommer vi att prata om Java Collections sort(). Som ett snabbt tankeexperiment: föreställ dig att du söker efter ett namn genom ett universitets förteckning. Det kan finnas tiotusentals elever på den här skolan. Om förteckningen du fick inte var i alfabetisk ordning, skulle du behöva bläddra igenom varenda sida och titta mycket noga för att se till att du inte hoppade över ett enda namn någonstans, tills du äntligen hittar det namn du letar efter. Å andra sidan, om listan var alfabetisk, måste du inte bara vara mindre noggrann i din sökning, men du kan enkelt hoppa till avsnittet i förteckningen med samma första bokstav och fortsätta att hoppa runt sidor i stora språng tills du landar på personen du letade efter. Ju mer data du arbetar med, desto viktigare är det att du använder den så effektivt och effektivt som möjligt. I den här artikeln kommer vi att gå igenom hur man sorterar valfri listimplementering i Java (inklusive ArrayList) med hjälp av sorteringsmetoden Collections.
Hur man sorterar en ArrayList i Java med hjälp av sorteringsmetoden Java Collections
Låt oss prata om metoden Java Collections.sort. Paketet java.util innehåller många användbara verktyg och paket som ofta används av utvecklare, inklusive ArrayList. Anta att du har följande enkla 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 vill kunna skriva ut färglistan, men i alfabetisk ordning. Hur kan du göra detta? Genom att använda java.util.Collections är sorteringen lika enkel som en enkel rad:
Collections.sort(colors);
Ta-da! Din färglista har nu sorterats på plats. Om du skulle skriva ut listan, som sådan:
System.out.println(colors);
Då får du följande utdata:
[Blue, Green, Orange, Red]
Hur lätt var det?! Det skulle vara lika enkelt att använda Collections.sort() för att sortera i stigande ordning en lista med heltal, flytande eller någon annan enkel datatyp för den delen. Men tänk om du ville sortera i fallande ordning? Det finns definitivt fall där detta är vettigt - tänk dig att du hade en lista med testresultat för en viss klass och du ville ta reda på vilka eleverna som fick högsta poäng. Det skulle vara mycket mer meningsfullt att sortera listan i fallande ordning (högsta poängen först), så att svaren du letar efter är högst upp. Tack och lov skrivs Collections.sort() över med en valfri andra parameter, som låter dig göra just detta:
sort(List l, Comparator c)
Men vad är en komparator? Tja, en komparator är helt enkelt en funktion som jämför två ingångar och returnerar ett tal som representerar vilken ingång som kommer först. Om du sorterar en ArrayList med primitiva datatyper, ger Java Collections dig redan en reverseOrder()-jämförare. Det kan kallas så här:
Nu har färgerna omvänt sorterats på plats så att om du skrev ut det skulle du få följande utdata:
[Red, Orange, Green, Blue]
Hur man använder samlingar för att sortera icke-primitiva datatyper i Java
Hittills har du sett att sortering av ArrayLists av strängar eller ints i Java med metoden Collections.sort() är lika enkelt som en rad kod. Men ofta kommer dina ArrayLists att lagra icke-primitiva datatyper. När du arbetar med data som har mer komplexa attribut, kommer du att vilja skriva klasser för att representera dessa objekt och hur de kommer att jämföras med varandra med hjälp av deras attribut. För att utforska ett exempel på detta, låt oss återgå till exemplet med att sortera en lista med färger, men den här gången, istället för att sortera strängar, kommer vi att sortera färgobjekt. Vår grundläggande färgklass kan se ut ungefär så här:
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;
}
}
För att göra vår Color-klass kompatibel med Collections.sort(), så att Collections kan förstå hur man jämför och sorterar Color-objekt, måste vi göra två små modifieringar:
gör Färg till ett jämförbart objekt (lägg till redskap Comparable<Object>)
åsidosätt compareTo-metoden i klassen (åsidosätt public int compareTo(Object o))
Med dessa ändringar ser vår klass nu ut så här:
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);
}
}
Lägg märke till att färgens compareTo-metod helt enkelt anropar Stringens compareTo-metod; sortering kommer att ske i alfabetisk ordning. Om vi till exempel ville sortera efter rött värde i stigande ordning, skulle vi kunna ersätta retursatsen med return this.r - cr; (om vi ville sortera efter grönt värde i fallande ordning skulle det vara retur cg - this.g;). Nu, om vi ringer
Collections.sort(colors);
på en ArrayList of Colors snarare än bara Strings, skulle det fungera eftersom Collections förstår hur man jämför Color-objekt. Om du inte vill få ditt objekt att implementera Comparable<Object>, kan du alternativt skriva en komparator för din klass och skicka in den i metoden 2-parameter Collections.sort(). En komparator åsidosätter en metod public int compare(Objekt ett, Objekt två), och metoden Collections.sort() använder detta för att jämföra objekt under sortering. Ett exempel på SortByName och SortByRed-jämförare implementeras nedan:
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 detta kan du nu ringa
Collections.sort(colors, new SortByName());
utan att Color-klassen faktiskt implementerar Comparable, och den kommer fortfarande att fungera. Ibland kommer du att se att detta görs in-line, med hjälp av lambda-funktioner. En lambda-funktion är i huvudsak en namnlös funktion som du kan definiera inom kodraden som kallar den. De är användbara när du bara behöver anropa en funktion för en specifik instans och inte vill definiera en hel separat funktion någon annanstans. SortByName-jämföraren kan definieras in-line, med hjälp av en lambda-funktion, så här:
Som du kanske har gissat representerar (a, b) parametrarna för lambdafunktionerna (de två objekt som ska jämföras). -> anger att det som följer är en definition av lambdafunktion. Det är ungefär det! Du har nu sett de mest populära metoderna för att sortera ArrayLists i Java med hjälp av paketet Collections.
GO TO FULL VERSION