Az adatokkal foglalkozó fejlesztők számára az egyik leggyakoribb funkció a szortírozás – ha tudjuk rendezni adatainkat, optimalizálhatjuk algoritmusainkat, hogy sokkal gyorsabban fussanak, és az idő töredéke alatt megtaláljuk a szükséges adatokat. másként vállalná. A mai leckében a Java Collections sort()-ról fogunk beszélni. Gyors gondolatkísérletként: képzelje el, hogy egy egyetem névsorán keresztül keres egy nevet. Több tízezer diák lehet ebben az iskolában. Ha a kapott névsor nem ábécé sorrendben volt, akkor minden egyes oldalt át kell lapoznia, és nagyon alaposan meg kell néznie, hogy egyetlen nevet se hagyjon ki sehol, amíg végül meg nem találja a keresett nevet. Másrészt, ha a névsort ábécé szerint rendezték, nem csak a keresés során kell kevésbé szigorúnak lennie, de könnyen átugorhat a névsor azon részéhez, ahol ugyanaz az első betű, és továbbra is nagy ugrásokkal ugrálhat az oldalakon, amíg meg nem találja a keresett személyt. Minél több adattal dolgozik, annál fontosabb, hogy azokat a lehető leghatékonyabban és leghatékonyabban használja fel. Ebben a cikkben áttekintjük, hogyan lehet rendezni bármely List implementációt Java nyelven (beleértve az ArrayList-et is) a Collections rendezési módszerrel.
ArrayList rendezése Java nyelven a Java Collections rendezési módszerrel
Beszéljünk a Java Collections.sort metódusáról. A java.util csomag számos hasznos segédprogramot és csomagot tartalmaz, amelyeket a fejlesztők gyakran használnak, beleértve az ArrayList-et is. Tegyük fel, hogy a következő egyszerű programod van:
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");
}
}
Szeretné kinyomtatni a színlistát, de ábécé sorrendben. Hogyan tehetné ezt meg? A java.util.Collections használatával a rendezés olyan egyszerű, mint az egysoros:
Collections.sort(colors);
Ta-da! A színlistát a helyére rendeztük. Ha kinyomtatná a listát, akkor:
System.out.println(colors);
Akkor a következő kimenetet kapod:
[Blue, Green, Orange, Red]
Milyen könnyű volt?! Ugyanilyen egyszerű lenne a Collections.sort() segítségével növekvő sorrendbe rendezni egész számok, lebegőpontok vagy bármilyen más egyszerű adattípus listáját. De mi van akkor, ha csökkenő sorrendbe szeretne rendezni? Minden bizonnyal vannak olyan esetek, amikor ennek van értelme – képzelje el, hogy van egy listája egy bizonyos osztály teszteredményeiről, és ki akarta deríteni, kik a legjobb pontszámot elérő tanulók. Sokkal ésszerűbb lenne a listát csökkenő sorrendbe rendezni (a legmagasabb pontszámok először), hogy a keresett válaszok a legfelül legyenek. Szerencsére a Collections.sort() felül van írva egy opcionális 2. paraméterrel, amely lehetővé teszi, hogy ezt tegye:
sort(List l, Comparator c)
De mi az a komparátor? Nos, az összehasonlító egyszerűen egy függvény, amely összehasonlít két bemenetet, és egy számot ad vissza, amely azt jelzi, hogy melyik bemenet van előbb. Ha primitív adattípusok ArrayListjét rendezi, akkor a Java Collections már rendelkezik egy reverseOrder() összehasonlítóval. Ezt így lehet nevezni:
Most a színeket a helyükön fordított sorrendbe rendeztük, így ha kinyomtatja, a következő kimenetet kapja:
[Red, Orange, Green, Blue]
A gyűjtemények használata a nem primitív adattípusok rendezésére Java nyelven
Eddig azt tapasztalta, hogy a karakterláncok vagy int-ek ArrayListjei rendezése Java nyelven a Collections.sort() metódussal olyan egyszerű, mint egy sor kód. De gyakran az ArrayLists nem primitív adattípusokat tárol. Ha összetettebb attribútumokkal rendelkező adatokkal dolgozik, akkor osztályokat kell írnia, amelyek ábrázolják ezeket az objektumokat, és hogyan fogják őket összehasonlítani egymással az attribútumok használatával. Egy példa feltárásához nézzük meg újra a színlista rendezésének példáját, de ezúttal a karakterláncok rendezése helyett a színobjektumokat fogjuk rendezni. Az alapszín osztályunk valahogy így nézhet ki:
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;
}
}
Annak érdekében, hogy Color osztályunkat kompatibilissé tegyük a Collections.sort() paraméterrel, hogy a gyűjtemények megértsék a Color objektumok összehasonlítását és rendezését, két apró módosítást kell végrehajtanunk:
a Color készítése összehasonlítható objektummá (összehasonlítható <Object> eszköz hozzáadása)
felülírja az Összehasonlítás metódusát az osztályban (a public int Összehasonlítás(Object o) felülbírálása)
Ezekkel a módosításokkal az osztályunk most így néz ki:
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);
}
}
Figyeljük meg, hogy a Color's Összehasonlítás Metódus egyszerűen meghívja a String Összehasonlítás Metódusát; A rendezés ábécé sorrendben történik. Ha például piros érték szerint szeretnénk növekvő sorrendben rendezni, akkor a return utasítást helyettesíthetjük a return this.r - cr-re; (ha zöld érték szerint szeretnénk rendezni csökkenő sorrendben, akkor return cg lenne - ez.g;). Most, ha hívjuk
Collections.sort(colors);
a színek tömblistáján, nem csak a karakterláncokon, ez működne, mert a Collections megérti, hogyan kell összehasonlítani a Color objektumokat. Ha nem szeretné megvalósítani az objektumot Comparable<Object>, akkor írhat egy összehasonlítót az osztályához, és átadhatja azt a 2 paraméteres Collections.sort() metódusnak. A komparátor felülírja a public int összehasonlítás metódust (egyes objektum, kettes objektum), és a Collections.sort() metódus ezt használja az objektumok összehasonlítására rendezés közben. A SortByName és a SortByRed összehasonlítók példája az alábbiakban látható:
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;
}
}
Ezzel most már hívhat
Collections.sort(colors, new SortByName());
anélkül, hogy a Color osztály ténylegesen megvalósítaná a Comparable-t, és továbbra is működni fog. Néha látni fogja, hogy ez soron belül történik, lambda függvények használatával. A lambda függvény lényegében egy névtelen függvény, amelyet a kódsoron belül definiálhat, amely meghívja. Akkor hasznosak, ha egy függvényt csak egy adott példányhoz kell meghívnia, és nem akar egy egész külön függvényt máshol definiálni. A SortByName összehasonlító soron belül definiálható egy lambda függvény segítségével, például:
Ahogy azt sejteni lehetett, (a, b) a lambda függvények (a két összehasonlítandó objektum) paramétereit jelöli. A -> azt jelenti, hogy a következő egy lambda függvény definíció. Nagyjából ennyi! Most már láthatta a legnépszerűbb módszereket az ArrayLists osztályozására Java nyelven a Collections csomag használatával.
GO TO FULL VERSION