streamalism.org

1. Prehľad

Java 8 priniesla do servera niekoľko vylepšení Komparátor rozhranie, vrátane niekoľkých statických funkcií, ktoré sú veľmi užitočné pri navrhovaní zoradenia zbierok.

Java 8 lambdas je možné efektívne využiť pomocou Komparátor rozhranie. Podrobné vysvetlenie lambd a Komparátor nájdete tu a kroniku o triedení a aplikáciách Komparátor nájdete tu.

V tomto návode preskúmame niekoľko funkcií zavedených pre Windows 7 Komparátor rozhranie v Jave 8.

2. Začíname

2.1. Ukážka triedy Bean

Pre príklady v tomto článku vytvorme Zamestnanec fazuľa a používať jej polia na účely porovnávania a triedenia:

verejná trieda Zamestnanec {Názov reťazca; int vek; dvojnásobný plat; dlhý mobil; // konštruktéri, zakladatelia a zakladatelia}

2.2. Naše testovacie údaje

Vytvorme tiež pole zamestnancov, ktorí sa použijú na ukladanie výsledkov nášho typu do rôznych testovacích prípadov v celom článku:

zamestnanci = nový zamestnanec [] {...};

Počiatočné poradie prvkov zamestnancov bude:

[Zamestnanec (meno = John, vek = 25, plat = 3000,0, mobil = 9922001), zamestnanec (meno = eso, vek = 22, plat = 2000,0, mobil = 5924001), zamestnanec (meno = Keith, vek = 35, plat = 4000,0, mobil = 3924401)]

V celom článku sa budeme radiť vyššie Zamestnanec pole využívajúce rôzne funkcie.

Pre testovacie tvrdenia použijeme množinu vopred vytriedených polí, ktoré porovnáme s našimi výsledkami triedenia (t. J. zamestnancov pole) pre rôzne scenáre.

Vyhlásime niekoľko z týchto polí:

@Before public void initData () {sortEmployeesByName = nový zamestnanec [] {...}; sortEmployeesByNameDesc = nový zamestnanec [] {...}; sortEmployeesByAge = nový zamestnanec [] {...}; // ...}

Ako vždy, kompletný kód môžete odkázať na náš odkaz na GitHub.

3. Používanie Comparator.comparing

Táto časť obsahuje varianty Comparator.comparing statická funkcia.

3.1. Variant výberu kľúča

The Comparator.comparing statická funkcia prijíma kľúč triedenia Funkcia a vráti a Komparátor pre typ, ktorý obsahuje kľúč triedenia:

statický  Porovnávanie komparátora (Function keyExtractor)

Ak to chcete vidieť v akcii, použite názov pole v Zamestnanec ako kľúč triedenia a odovzdať odkaz na jeho metódu ako argument typu Funkcia. The Komparátor vrátený z toho istého sa používa na triedenie:

@Test public void whenComparing_thenSortedByName () {Comparator employeeNameComparator = Comparator.comparing (Employee :: getName); Arrays.sort (zamestnanci, employeeNameComparator); assertTrue (Arrays.equals (zamestnanci, seřazenéEmployeeByName)); }

Ako vidíte, zamestnancov hodnoty poľa sú zoradené podľa názvu ako výsledok zoradenia:

[Zamestnanec (meno = eso, vek = 22, plat = 2000,0, mobil = 5924001), zamestnanec (meno = John, vek = 25, plat = 3000,0, mobil = 9922001), zamestnanec (meno = Keith, vek = 35, plat = 4000,0, mobil = 3924401)] 

3.2. Výber kľúča a Komparátor Varianta

Existuje ešte jedna možnosť, ktorá pomáha prekonať prirodzené usporiadanie kľúča triedenia poskytnutím Komparátor ktorý vytvorí vlastné zoradenie pre kľúč triedenia:

statické porovnávanie komparátorov (Function keyExtractor, Comparator keyComparator)

Upravme vyššie uvedený test tak, že prepíšeme prirodzené poradie triedenia podľa názov pole poskytnutím a Komparátor pre zoradenie mien v zostupnom poradí ako druhý argument pre Comparator.comparing:

@Test public void whenComparingWithComparator_thenSortedByNameDesc () {Comparator employeeNameComparator = Comparator.comparing (Employee :: getName, (s1, s2) -> {return s2.compareTo (s1);}); Arrays.sort (zamestnanci, employeeNameComparator); assertTrue (Arrays.equals (zamestnanci, triedenéEmployeesByNameDesc)); }

Ako vidíte, výsledky sú zoradené zostupne podľa názov:

[Zamestnanec (meno = Keith, vek = 35, plat = 4000,0, mobil = 3924401), zamestnanec (meno = John, vek = 25, plat = 3000,0, mobil = 9922001), zamestnanec (meno = eso, vek = 22, plat = 2000,0, mobil = 5924001)]

3.3. Použitím Komparátor. Obrátený

Pri vyvolaní existujúceho Komparátor, inštančná metóda Komparátor. Obrátený vracia nový Komparátor ktorý obráti poradie zoradenia originálu.

Použime Komparátor podľa ktorých sú zamestnanci zoradení podľa názov a obrátiť to tak, aby boli zamestnanci zoradení zostupne podľa názov:

@Test public void whenReversed_thenSortedByNameDesc () {Comparator employeeNameComparator = Comparator.comparing (Employee :: getName); Komparátor employeeNameComparatorReversed = employeeNameComparator.reversed (); Arrays.sort (zamestnanci, employeeNameComparatorReversed); assertTrue (Arrays.equals (zamestnanci, triedenéEmployeesByNameDesc)); }

Výsledky sú zoradené zostupne podľa názov:

[Zamestnanec (meno = Keith, vek = 35, plat = 4000,0, mobil = 3924401), zamestnanec (meno = John, vek = 25, plat = 3000,0, mobil = 9922001), zamestnanec (meno = eso, vek = 22, plat = 2000,0, mobil = 5924001)]

3.4. Použitím Comparator.comparingInt

K dispozícii je aj funkcia Comparator.comparingInt čo robí to isté ako Comparator.comparing, ale stačí to int selektory. Skúsme to na príklade, kde si objednávame zamestnancov od Vek:

@Test public void whenComparingInt_thenSortedByAge () {Comparator employeeAgeComparator = Comparator.comparingInt (Employee :: getAge); Arrays.sort (zamestnanci, employeeAgeComparator); assertTrue (Arrays.equals (zamestnanci, seřazenéEmployeesByAge)); }

Pozrime sa, ako zamestnancov hodnoty poľa sú zoradené po zoradení:

[Zamestnanec (meno = eso, vek = 22, plat = 2000,0, mobil = 5924001), zamestnanec (meno = John, vek = 25, plat = 3000,0, mobil = 9922001), zamestnanec (meno = Keith, vek = 35, plat = 4000,0, mobil = 3924401)]

3.5. Použitím Comparator.comparingDlhé

Podobné tomu, pre čo sme robili int klávesov, pozrime sa na príklad použitia Comparator.comparingDlhé zvážiť typový kľúč typu dlho objednaním zamestnancov pole podľa mobilné lúka:

@Test public void whenComparingLong_thenSortedByMobile () {Comparator employeeMobileComparator = Comparator.comparingLong (Employee :: getMobile); Arrays.sort (zamestnanci, employeeMobileComparator); assertTrue (Arrays.equals (zamestnanci, seřazenéEmployeesByMobile)); }

Pozrime sa, ako zamestnancov hodnoty poľa sú zoradené po zoradení pomocou mobilné ako kľúč:

[Zamestnanec (meno = Keith, vek = 35, plat = 4000,0, mobil = 3924401), zamestnanec (meno = eso, vek = 22, plat = 2000,0, mobil = 5924001), zamestnanec (meno = John, vek = 25, plat) = 3000,0, mobil = 9922001)]

3.6. Použitím Comparator.comparingDouble

Opäť podobné tomu, pre čo sme robili int a dlho klávesov, pozrime sa na príklad použitia Comparator.comparingDouble zvážiť typový kľúč typu dvojitý objednaním zamestnancov pole podľa plat lúka:

@Test public void whenComparingDouble_thenSortedBySalary () {Comparator employeeSalaryComparator = Comparator.comparingDouble (Employee :: getSalary); Arrays.sort (zamestnanci, employeeSalaryComparator); assertTrue (Arrays.equals (zamestnanci, seřazenéEmployeesBySalary)); }

Pozrime sa, ako zamestnancov hodnoty poľa sú zoradené po zoradení pomocou plat ako kľúč triedenia:

[Zamestnanec (meno = eso, vek = 22, plat = 2000,0, mobil = 5924001), zamestnanec (meno = John, vek = 25, plat = 3000,0, mobil = 9922001), zamestnanec (meno = Keith, vek = 35, plat = 4000,0, mobil = 3924401)]

4. Vzhľadom na prirodzený poriadok v Komparátor

Prirodzený poriadok je definovaný správaním Porovnateľné implementácia rozhrania. Viac informácií o rozdiele medzi Komparátor a použitie Porovnateľné rozhranie nájdete v tomto článku.

Poďme realizovať Porovnateľné v našom Zamestnanec triedy, aby sme mohli vyskúšať naturalObjednávka a reverseOrder funkcie Komparátor rozhranie:

public class Employee implements Comparable {// ... @Override public int compareTo (Employee argEmployee) {return name.compareTo (argEmployee.getName ()); }}

4.1. Pomocou prirodzeného poriadku

The naturalObjednávka funkcia vracia Komparátor pre návratový typ uvedený v podpise:

statický  Komparátor naturalOrder ()

Vzhľadom na vyššie uvedenú logiku je porovnanie zamestnancov založené na názov poľa, použijeme túto funkciu na získanie a Komparátor ktorý triedi zamestnancov pole v prirodzenom poradí:

@ Test public void whenNaturalOrder_thenSortedByName () {Comparator employeeNameComparator = Porovnávač. naturalOrder (); Arrays.sort (zamestnanci, employeeNameComparator); assertTrue (Arrays.equals (zamestnanci, seřazenéEmployeeByName)); }

Pozrime sa, ako zamestnancov hodnoty poľa sú zoradené po zoradení:

[Zamestnanec (meno = eso, vek = 22, plat = 2000,0, mobil = 5924001), zamestnanec (meno = John, vek = 25, plat = 3000,0, mobil = 9922001), zamestnanec (meno = Keith, vek = 35, plat = 4000,0, mobil = 3924401)]

4.2. Použitie obráteného prirodzeného poradia

Podobný naturalObjednávka, použijeme reverseOrder metóda na vygenerovanie a Komparátor , ktorá spôsobí opačné poradie zamestnancov k tomu v naturalObjednávka príklad:

@Test public void whenReverseOrder_thenSortedByNameDesc () {Comparator employeeNameComparator = komparátor. reverseOrder (); Arrays.sort (zamestnanci, employeeNameComparator); assertTrue (Arrays.equals (zamestnanci, triedenéEmployeesByNameDesc)); }

Pozrime sa, ako zamestnancov hodnoty poľa sú zoradené po zoradení:

[Zamestnanec (meno = Keith, vek = 35, plat = 4000,0, mobil = 3924401), zamestnanec (meno = John, vek = 25, plat = 3000,0, mobil = 9922001), zamestnanec (meno = eso, vek = 22, plat = 2000,0, mobil = 5924001)]

5. Zváženie nulových hodnôt v komparátore

Táto časť sa týka funkcií nullsFirst a nullPosledné, ktoré zvažujú nulový hodnoty pri objednávaní a uchovaní nulový hodnoty na začiatku alebo na konci poradia objednávok.

5.1. Najprv zvážime Null

Náhodne vložíme nulový hodnoty v zamestnancov pole:

[Zamestnanec (meno = John, vek = 25, plat = 3000,0, mobil = 9922001), null, zamestnanec (meno = eso, vek = 22, plat = 2000,0, mobil = 5924001), null, zamestnanec (meno = Keith, vek = 35, plat = 4000,0, mobil = 3924401)]

The nullsFirst funkcia vráti a Komparátor to drží všetko nuly na začiatku objednávacej sekvencie:

@ Test public void whenNullsFirst_thenSortedByNameWithNullsFirst () {Comparator employeeNameComparator = Comparator.comparing (Employee :: getName); Comparator employeeNameComparator_nullFirst = Comparator.nullsFirst (employeeNameComparator); Arrays.sort (zamestnanciArrayWithNulls, employeeNameComparator_nullFirst); assertTrue (Arrays.equals (zamestnanciArrayWithNulls, triedenéEmployeesArray_WithNullsFirst)); }

Pozrime sa, ako zamestnancov hodnoty poľa sú zoradené po zoradení:

[null, null, zamestnanec (meno = eso, vek = 22, plat = 2000,0, mobil = 5924001), zamestnanec (meno = John, vek = 25, plat = 3000,0, mobil = 9922001), zamestnanec (meno = Keith, vek = 35, plat = 4000,0, mobil = 3924401)]

5.2. Vzhľadom na Null posledný

The nullPosledné funkcia vráti a Komparátor to drží všetko nuly na konci poradia objednávky:

@Test public void whenNullsLast_thenSortedByNameWithNullsLast () {Comparator employeeNameComparator = Comparator.comparing (Employee :: getName); Comparator employeeNameComparator_nullLast = Comparator.nullsLast (employeeNameComparator); Arrays.sort (zamestnanciArrayWithNulls, employeeNameComparator_nullLast); assertTrue (Arrays.equals (zamestnanciArrayWithNulls, triedenéEmployeesArray_WithNullsLast)); }

Pozrime sa, ako zamestnancov hodnoty poľa sú zoradené po zoradení:

[Zamestnanec (meno = eso, vek = 22, plat = 2000,0, mobil = 5924001), zamestnanec (meno = John, vek = 25, plat = 3000,0, mobil = 9922001), zamestnanec (meno = Keith, vek = 35, plat = 4000,0, mobil = 3924401), null, null]

6. Používanie Comparator.thenPorovnanie

The potom porovnanie Táto funkcia umožňuje nastaviť lexikografické usporiadanie hodnôt poskytnutím viacerých kľúčov triedenia v konkrétnej sekvencii.

Uvažujme o ďalšom poli Zamestnanec trieda:

someMoreEmployees = new Employee [] {...};

Zvážte nasledujúcu postupnosť prvkov vo vyššie uvedenom poli:

[Zamestnanec (meno = Jake, vek = 25, plat = 3000,0, mobil = 9922001), zamestnanec (meno = Jake, vek = 22, plat = 2000,0, mobil = 5924001), zamestnanec (meno = eso, vek = 22, plat = 3000,0, mobil = 6423001), zamestnanec (meno = Keith, vek = 35, plat = 4000,0, mobil = 3924401)]

Napíšme postupnosť porovnaní ako Vek nasledované názov a pozrite si poradie tohto poľa:

@ Test public void whenThenComparing_thenSortedByAgeName () {Comparator employee_Age_Name_Comparator = Comparator.comparing (Employee :: getAge) .thComComing (Employee :: getName); Arrays.sort (someMoreEmployees, employee_Age_Name_Comparator); assertTrue (Arrays.equals (someMoreEmployees, orderedEmployeesByAgeName)); }

Tu bude objednávka vykonaná do Veka pre hodnoty s rovnakými Vek, objednávka sa uskutoční do názov. Pozrime sa na to v poradí, ktoré dostaneme po zoradení:

[Zamestnanec (meno = eso, vek = 22, plat = 3000,0, mobil = 6423001), zamestnanec (meno = Jake, vek = 22, plat = 2000,0, mobil = 5924001), zamestnanec (meno = Jake, vek = 25, plat = 3000,0, mobil = 9922001), zamestnanec (meno = Keith, vek = 35, plat = 4000,0, mobil = 3924401)]

Použime druhú verziu aplikácie potom porovnanie to je thenComparingInt, zmenou lexikografickej postupnosti na názov nasledovaný Vek:

@ Test public void whenThenComparing_thenSortedByNameAge () {Comparator employee_Name_Age_Comparator = Comparator.comparing (Employee :: getName) .thenComparingInt (Employee :: getAge); Arrays.sort (someMoreEmployees, employee_Name_Age_Comparator); assertTrue (Arrays.equals (someMoreEmployees, orderedEmployeesByNameAge)); }

Pozrime sa, ako zamestnancov hodnoty poľa sú zoradené po zoradení:

[Zamestnanec (meno = eso, vek = 22, plat = 3000,0, mobil = 6423001), zamestnanec (meno = Jake, vek = 22, plat = 2000,0, mobil = 5924001), zamestnanec (meno = Jake, vek = 25, plat = 3000,0, mobil = 9922001), zamestnanec (meno = Keith, vek = 35, plat = 4000,0, mobil = 3924401)]

Podobne sú na tom aj funkcie thenComparingLong a thenComparingDouble na použitie dlho a dvojitý triediace kľúče.

7. Záver

Tento článok je sprievodcom po niekoľkých funkciách zavedených v prostredí Java 8 pre server Komparátor rozhranie.

Ako obvykle, zdrojový kód nájdete na Githube.