En av de vanligste funksjonene vi trenger som utviklere som arbeider med data er sortering – ved å kunne sortere dataene våre kan vi optimere algoritmene våre til å kjøre mye raskere og finne dataene de trenger på en brøkdel av tiden den ville tatt til ellers. I dagens leksjon skal vi snakke om Java Collections sort(). Som et raskt tankeeksperiment: forestill deg at du søker etter et navn gjennom et universitets vaktliste. Det kan være titusenvis av elever ved denne skolen. Hvis vaktlisten du fikk ikke var i alfabetisk rekkefølge, må du bla gjennom hver eneste side og se veldig nøye for å være sikker på at du ikke hopper over et enkelt navn hvor som helst, før du endelig finner navnet du leter etter. På den annen side, hvis vaktlisten ble alfabetisert, må du ikke bare være mindre streng i søket ditt, men du kan enkelt hoppe til seksjonen i listen med den samme første bokstaven, og fortsette å hoppe rundt sider i store sprang til du lander på personen du lette etter. Jo mer data du jobber med, jo viktigere er det at du bruker dem så effektivt og effektivt som mulig. I denne artikkelen vil vi gå over hvordan du sorterer en listeimplementering i Java (inkludert ArrayList) ved å bruke sorteringsmetoden Collections.
Slik sorterer du en ArrayList i Java ved hjelp av sorteringsmetoden Java Collections
La oss snakke om metoden Java Collections.sort. Java.util-pakken inneholder mange nyttige verktøy og pakker som ofte brukes av utviklere, inkludert ArrayList. Anta at du har følgende enkle 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 å kunne skrive ut fargelisten, men i alfabetisk rekkefølge. Hvordan kan du gjøre dette? Ved å bruke java.util.Collections er sortering like enkelt som en enlinje:
Collections.sort(colors);
Ta-da! Fargelisten din er nå sortert på plass. Hvis du skulle skrive ut listen, som sådan:
System.out.println(colors);
Da får du følgende utgang:
[Blue, Green, Orange, Red]
Hvor lett var det?! Det ville være like enkelt å bruke Collections.sort() til å sortere i stigende rekkefølge en liste over heltall, flyter eller en hvilken som helst annen enkel datatype for den saks skyld. Men hva om du ville sortere i synkende rekkefølge? Det er definitivt tilfeller der dette gir mening - forestill deg at du hadde en liste over testresultater for en bestemt klasse, og du ønsket å finne ut hvem de best scorende studentene er. Det ville være mye mer fornuftig å sortere listen i synkende rekkefølge (høyest score først), slik at svarene du leter etter er rett øverst. Heldigvis er Collections.sort() overskrevet med en valgfri andre parameter, som lar deg gjøre nettopp dette:
sort(List l, Comparator c)
Men hva er en komparator? Vel, en komparator er ganske enkelt en funksjon som sammenligner to innganger og returnerer et tall som representerer hvilken inngang som kommer først. Hvis du sorterer en ArrayList med primitive datatyper, gir Java Collections deg allerede en reverseOrder()-komparator. Det kan kalles slik:
Nå er farger omvendt sortert på plass, slik at hvis du skrev det ut, ville du få følgende utdata:
[Red, Orange, Green, Blue]
Hvordan bruke samlinger til å sortere ikke-primitive datatyper i Java
Så langt har du sett at sortering av ArrayLists av strenger eller ints i Java ved hjelp av Collections.sort()- metoden er like enkelt som én kodelinje. Men ofte vil ArrayLists lagre ikke-primitive datatyper. Når du arbeider med data som har mer komplekse attributter, vil du skrive klasser for å representere disse objektene og hvordan de vil bli sammenlignet med hverandre ved å bruke attributtene deres. For å utforske et eksempel på dette, la oss se på eksemplet med sortering av en liste over farger, men denne gangen, i stedet for å sortere strenger, skal vi sortere fargeobjekter. Vår grunnleggende fargeklasse kan se omtrent slik ut:
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 å gjøre Color-klassen vår kompatibel med Collections.sort(), slik at Collections kan forstå hvordan man sammenligner og sorterer Color-objekter, må vi gjøre to små modifikasjoner:
gjør Color til et sammenlignbart objekt (legg til verktøy Sammenlignbar<Objekt>)
overstyr compareTo-metoden i klassen (overstyr public int compareTo(Objekt o))
Med disse modifikasjonene ser klassen vår nå slik ut:
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);
}
}
Legg merke til at Color's compareTo-metoden bare kaller String's compareTo-metoden; sortering vil skje i alfabetisk rekkefølge. Hvis vi for eksempel ønsket å sortere etter rød verdi i stigende rekkefølge, kunne vi erstatte retursetningen med return this.r - cr; (hvis vi ønsket å sortere etter grønn verdi i synkende rekkefølge, ville det vært retur cg - this.g;). Nå, hvis vi ringer
Collections.sort(colors);
på en ArrayList of Colors i stedet for bare Strings, ville det fungere fordi Collections forstår hvordan man sammenligner Color-objekter. Hvis du ikke ønsker å få objektet ditt til å implementere Comparable<Object>, kan du alternativt skrive en komparator for klassen din, og overføre den til 2-parameter Collections.sort()-metoden. En komparator overstyrer en metode public int compare(Objekt en, Objekt to), og metoden Collections.sort() bruker denne til å sammenligne objekter mens de sorteres. Et eksempel på SortByName og SortByRed komparatorer er implementert 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 nå ringe
Collections.sort(colors, new SortByName());
uten at Color-klassen faktisk implementerer Comparable, og den vil fortsatt fungere. Noen ganger vil du se at dette gjøres in-line ved å bruke lambda-funksjoner. En lambda-funksjon er egentlig en navnløs funksjon som du kan definere innenfor kodelinjen, som kaller den. De er nyttige når du bare trenger å kalle en funksjon for én spesifikk forekomst og ikke vil definere en hel separat funksjon andre steder. SortByName-komparatoren kan defineres in-line ved å bruke en lambda-funksjon, slik:
Som du kanskje har gjettet, representerer (a, b) parametrene til lambda-funksjonene (de to objektene som skal sammenlignes). -> betyr at det som følger er en lambda-funksjonsdefinisjon. Det er omtrent det! Du har nå sett de mest populære metodene for å sortere ArrayLists i Java ved å bruke pakken Samlinger.
GO TO FULL VERSION