Java Academy · Pelajaran

Pengurutan dengan Comparator dan Lambda

Buat instans Comparator dengan ekspresi lambda dan metode pabrik Comparator.comparing.

Pengurutan dengan Comparator dan Lambda adalah pelajaran Java Academy gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Java Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Java Academy mencakup 4 pelajaran total.

Pengurutan dengan Comparator dan Lambda

Comparator<T> menentukan urutan eksternal untuk objek. Berbeda dari Comparable, Anda dapat membuat sebanyak mungkin Comparator yang diperlukan tanpa mengubah class.

Membuat Comparator

Buat Comparator dengan lambda atau referensi metode, lalu teruskan ke metode pengurutan.

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)

Pabrik Comparator.comparing

Comparator.comparing(keyExtractor) membuat Comparator dari fungsi pengekstrak kunci — lebih bersih daripada lambda mentah.

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() membalik urutan comparator apa pun.

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 dan reverseOrder

Comparator.naturalOrder() menggunakan Comparable milik class. reverseOrder() membalik urutan tersebut.

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]

Comparator Aman terhadap Null

Comparator.nullsFirst() dan nullsLast() menangani elemen null tanpa NPE.

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]

sorted() pada Stream dengan Comparator

Gunakan operasi aliran perantara sorted() dengan Comparator untuk pengurutan bergaya fungsional.

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 sebagai Lambda vs Referensi Metode

Referensi metode membuat comparator menjadi lebih ringkas ketika pengekstrak kunci berupa pengambil sederhana.

// 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]

Comparator dengan Keadaan

Meskipun comparator biasanya sebaiknya tidak memiliki keadaan, Anda dapat menyuntikkan konfigurasi melalui parameter konstruktor.

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

Pengurutan Kustom untuk Katalog Produk

Mengurutkan katalog produk berdasarkan ketersediaan terlebih dahulu, kemudian harga, lalu nama.

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 dengan Comparator

Arrays.sort(array, comparator) mengurutkan array objek dengan comparator kustom.

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]

Pemeriksaan Singkat

Apa yang dihasilkan oleh Comparator.comparingDouble(Product::price).reversed()?

Ringkasan: Pengurutan dengan Comparator dan Lambda

Hal-hal penting:

Comparator<T> menentukan urutan eksternal — gunakan sebanyak yang diperlukan
Comparator.comparing(keyExtractor) membuat comparator dari metode pengambil
reversed() membalik comparator apa pun; naturalOrder()/reverseOrder() untuk tipe yang Comparable
nullsFirst() dan nullsLast() menangani elemen null dengan aman
Gunakan sorted(comparator) dalam alur Stream untuk pengurutan bergaya fungsional
Comparator dapat diteruskan ke sort(), Arrays.sort(), TreeSet, TreeMap

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Pengurutan dengan Comparator dan Lambda” gratis?

Ya — teks lengkap “Pengurutan dengan Comparator dan Lambda” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Java Academy, upgrade ke CoddyKit PRO. Kursus Java Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Pengurutan dengan Comparator dan Lambda”?

Buat instans Comparator dengan ekspresi lambda dan metode pabrik Comparator.comparing. Kamu berlatih Java Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Java Academy?

Tidak diperlukan pengalaman sebelumnya. Java Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “Pengurutan dengan Comparator dan Lambda” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Java Academy ini?

Ya. Setiap pelajaran Java Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

Interface Comparable
Pengurutan dengan Comparator dan Lambda
Pengurutan Berdasarkan Banyak Kunci dengan thenComparing
Mempraktikkan Pengurutan Array dan Koleksi

← Kembali ke Java Academy