Java Academy · Oppitunti

Comparator ja lajittelu lambdoilla

Luo Comparator-olioita lambda-lausekkeilla ja Comparator.comparing-factory-metodeilla.

Oppitunti 2/413 vaihetta

Comparator ja lajittelu lambdoilla on ilmainen Java Academy-oppitunti CoddyKitissä. Tämä on oppitunti 2/4. Voit lukea koko oppitunnin alta ilmaiseksi ja harjoitella sen jälkeen käytännössä selaimessa sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla. Oppitunti kuuluu Java Academy-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Java Academy-kurssilla on yhteensä 4 oppituntia.

Comparator ja lambdajärjestäminen

Comparator<T> määrittää olioille ulkoisen järjestyksen. Toisin kuin Comparablea, sitä voidaan luoda niin monta kuin tarvitaan ilman luokan muuttamista.

Comparatorien luominen

Luokaa Comparator lambda-lausekkeella tai metodiviittauksella ja välittäkää se järjestämismenetelmille.

import java.util.*;

record Product(String name, double price, int stock) {}

List<Product> products = new ArrayList<>(List.of(
    new Product("Mouse",    29.99, 50),
    new Product("Laptop",  999.00, 5),
    new Product("USB Hub",  24.99, 100)
));

// Lambda comparator
products.sort((a, b) -> Double.compare(a.price(), b.price()));
System.out.println(products);
// [USB Hub, Mouse, Laptop] (by price ascending)

Comparator.comparing-tehdasmenetelmä

Comparator.comparing(keyExtractor) luo Comparatorin avaimen poimivasta funktiosta. Se on selkeämpi kuin suorat lambda-lausekkeet.

import java.util.Comparator;

Comparator<Product> byPrice = Comparator.comparingDouble(Product::price);
Comparator<Product> byName  = Comparator.comparing(Product::name);
Comparator<Product> byStock = Comparator.comparingInt(Product::stock);

products.sort(byPrice);
System.out.println(products); // sorted by price ascending

products.sort(byName);
System.out.println(products); // sorted alphabetically

reversed()

reversed() kääntää minkä tahansa Comparatorin järjestyksen.

import java.util.Comparator;

Comparator<Product> mostExpensiveFirst =
    Comparator.comparingDouble(Product::price).reversed();

products.sort(mostExpensiveFirst);
System.out.println(products);
// [Laptop($999.0), Mouse($29.99), USB Hub($24.99)]

naturalOrder ja reverseOrder

Comparator.naturalOrder() käyttää luokan Comparable-järjestystä. reverseOrder() kääntää sen.

List<String> names = new ArrayList<>(List.of("Charlie", "Alice", "Bob"));

names.sort(Comparator.naturalOrder());
System.out.println(names); // [Alice, Bob, Charlie]

names.sort(Comparator.reverseOrder());
System.out.println(names); // [Charlie, Bob, Alice]

// Sort integers descending
List<Integer> nums = new ArrayList<>(List.of(5, 2, 8, 1, 9));
nums.sort(Comparator.reverseOrder());
System.out.println(nums); // [9, 8, 5, 2, 1]

Null-arvot turvallisesti käsittelevät Comparatorit

Comparator.nullsFirst() ja nullsLast() käsittelevät null-alkiot ilman NPE-poikkeusta.

import java.util.*;

List<String> withNulls = new ArrayList<>(Arrays.asList("Charlie", null, "Alice", null, "Bob"));

withNulls.sort(Comparator.nullsLast(Comparator.naturalOrder()));
System.out.println(withNulls); // [Alice, Bob, Charlie, null, null]

withNulls.sort(Comparator.nullsFirst(Comparator.naturalOrder()));
System.out.println(withNulls); // [null, null, Alice, Bob, Charlie]

Streamin sorted() Comparatorin kanssa

Käyttäkää sorted()-välivaiheoperaatiota Comparatorin kanssa funktionaaliseen tyyliin tapahtuvaan järjestämiseen.

import java.util.stream.*;

record Employee(String name, String dept, double salary) {}

List<Employee> employees = List.of(
    new Employee("Alice",   "Engineering", 95000),
    new Employee("Bob",     "Marketing",   72000),
    new Employee("Charlie", "Engineering", 105000)
);

// Sort by salary descending in a stream pipeline
employees.stream()
    .sorted(Comparator.comparingDouble(Employee::salary).reversed())
    .forEach(e -> System.out.println(e.name() + ": $" + e.salary()));
// Charlie: $105000.0 / Alice: $95000.0 / Bob: $72000.0

Comparator lambda-lausekkeena tai metodiviittauksena

Metodiviittauksilla Comparatorit voidaan kirjoittaa vielä tiiviimmin, kun avaimen poimija on yksinkertainen getter.

// Lambda
Comparator<String> c1 = (a, b) -> a.length() - b.length();

// Comparator.comparing with lambda
Comparator<String> c2 = Comparator.comparing(s -> s.length());

// Comparator.comparingInt with method reference (cleanest)
Comparator<String> c3 = Comparator.comparingInt(String::length);

List<String> words = new ArrayList<>(List.of("banana", "fig", "apple", "kiwi"));
words.sort(c3);
System.out.println(words); // [fig, kiwi, apple, banana]

Tilallinen Comparator

Vaikka Comparatorien pitäisi yleensä olla tilattomia, konfiguraation voi välittää niille konstruktoriparametrien avulla.

class DistanceComparator implements Comparator<String> {
    private final String target;
    DistanceComparator(String target) { this.target = target; }

    @Override
    public int compare(String a, String b) {
        return Integer.compare(distance(a), distance(b));
    }

    private int distance(String s) { return Math.abs(s.length() - target.length()); }
}

List<String> words = new ArrayList<>(List.of("Java", "Go", "Python", "C", "Kotlin"));
words.sort(new DistanceComparator("Java"));
System.out.println(words); // closest length to "Java" first

Tuotekatalogin mukautettu järjestäminen

Tuotekatalogi järjestetään ensin saatavuuden, sitten hinnan ja lopuksi nimen perusteella.

import java.util.*;

record Item(String name, double price, boolean inStock) {}

List<Item> catalog = List.of(
    new Item("Laptop",  999.0,  true),
    new Item("Case",     19.99, false),
    new Item("Mouse",    29.99, true),
    new Item("Monitor", 349.0,  true)
);

Comparator<Item> catalogSort =
    Comparator.comparing(Item::inStock).reversed()     // in-stock first
    .thenComparingDouble(Item::price)                  // then cheapest
    .thenComparing(Item::name);                        // then alphabetical

catalog.stream().sorted(catalogSort)
    .forEach(i -> System.out.printf("%s %-15s $%.2f%n",
        i.inStock() ? "[Y]" : "[N]", i.name(), i.price()));

Arrays.sort Comparatorin kanssa

Arrays.sort(array, comparator) järjestää oliotaulukot mukautetun Comparatorin avulla.

String[] words = {"banana", "fig", "apple", "kiwi", "cherry"};

// Sort by length, then alphabetically for same length
Arrays.sort(words,
    Comparator.comparingInt(String::length)
              .thenComparing(Comparator.naturalOrder()));

System.out.println(Arrays.toString(words));
// [fig, kiwi, apple, banana, cherry]

Pikatarkistus

Mitä Comparator.comparingDouble(Product::price).reversed() tuottaa?

Vastaa interaktiivisessa oppitunnissa

Kertaus: Comparator ja lambdajärjestäminen

Tärkeimmät asiat:

Comparator<T> määrittää ulkoisen järjestyksen – käyttäkää niitä tarpeen mukaan niin monta kuin tarvitaan
Comparator.comparing(keyExtractor) luo Comparatoreja getter-menetelmistä
reversed() kääntää minkä tahansa Comparatorin; naturalOrder() ja reverseOrder() ovat Comparable-tyypeille
nullsFirst() ja nullsLast() käsittelevät null-alkiot turvallisesti
Käyttäkää sorted(comparator)-menetelmää Stream-ketjuissa funktionaaliseen järjestämiseen
Comparatoreja voidaan välittää menetelmille sort(), Arrays.sort(), TreeSetille ja TreeMapille

Aloita maksutta

Opi Java tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 104
Oppitunnit: 374

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”Comparator ja lajittelu lambdoilla” ilmainen?

Kyllä – oppitunnin ”Comparator ja lajittelu lambdoilla” koko tekstin voi lukea täällä verkossa ilmaiseksi. Jos haluat harjoitella interaktiivisesti sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla sekä avata koko Java Academy-kurssin, päivitä CoddyKit PROhon. Java Academy-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”Comparator ja lajittelu lambdoilla”?

Luo Comparator-olioita lambda-lausekkeilla ja Comparator.comparing-factory-metodeilla. Harjoittelet Java Academy-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni Java Academy-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin Java Academy-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 2/4.

Kuinka kauan ”Comparator ja lajittelu lambdoilla”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä Java Academy-oppitunnilla?

Kyllä. Jokainen Java Academy-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

Comparable-rajapinta
Comparator ja lajittelu lambdoilla
Monikenttälajittelu thenComparing-metodilla
Taulukoiden ja kokoelmien lajittelu käytännössä

← Takaisin: Java Academy