Java Academy · Pelajaran

Interface Comparable

Implementasikan Comparable untuk memberikan urutan alami pada class dan gunakan bersama Collections.sort.

Interface Comparable adalah pelajaran Java Academy gratis di CoddyKit. Ini adalah pelajaran 1 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.

Antarmuka Comparable

Comparable<T> memberikan urutan alami kepada sebuah class. Implementasikan antarmuka ini agar instance dapat diurutkan dengan Collections.sort(), Arrays.sort(), dan koleksi terurut seperti TreeSet.

Mengimplementasikan Comparable

Implementasikan compareTo(T other) agar mengembalikan nilai negatif (this < other), nol (sama), atau positif (this > other).

class Product implements Comparable<Product> {
    private final String name;
    private final double price;

    Product(String name, double price) {
        this.name = name; this.price = price;
    }

    @Override
    public int compareTo(Product other) {
        return Double.compare(this.price, other.price); // ascending by price
    }

    @Override public String toString() { return name + "($" + price + ")"; }
}

List<Product> products = new ArrayList<>(List.of(
    new Product("Mouse", 29.99),
    new Product("Laptop", 999.0),
    new Product("Keyboard", 79.99)
));
Collections.sort(products);
System.out.println(products); // [Mouse($29.99), Keyboard($79.99), Laptop($999.0)]

Kontrak compareTo

Implementasi Comparable yang benar harus memenuhi suatu kontrak:

Antisimetri: sgn(a.compareTo(b)) == -sgn(b.compareTo(a))
Transitivitas: jika a > b dan b > c, maka a > c
Konsistensi: a.compareTo(b) == 0 berarti a.equals(b) — sangat disarankan

Membandingkan Tipe Primitif dengan Aman

Jangan pernah mengurangkan tipe primitif dalam compareTo — luapan bilangan bulat dapat menghasilkan hasil yang salah. Gunakan Integer.compare(), Double.compare(), dan sebagainya.

// WRONG: integer subtraction can overflow
int compareTo(Player other) {
    return this.score - other.score; // overflow if scores differ by > Integer.MAX_VALUE
}

// CORRECT: use Integer.compare
int compareTo(Player other) {
    return Integer.compare(this.score, other.score);
}

// For strings: delegate to String.compareTo
int compareTo(Player other) {
    return this.name.compareTo(other.name); // String handles it correctly
}

Urutan Alami dalam TreeSet

Class yang mengimplementasikan Comparable otomatis ditempatkan dalam koleksi terurut seperti TreeSet dan TreeMap.

class Priority implements Comparable<Priority> {
    enum Level { LOW, MEDIUM, HIGH, CRITICAL }
    final Level level;
    final String task;
    Priority(Level level, String task) { this.level = level; this.task = task; }
    @Override
    public int compareTo(Priority other) {
        return this.level.compareTo(other.level); // enum ordinal order
    }
    @Override public String toString() { return level + ": " + task; }
}

TreeSet<Priority> queue = new TreeSet<>();
queue.add(new Priority(Priority.Level.CRITICAL, "Fix prod crash"));
queue.add(new Priority(Priority.Level.LOW, "Update docs"));
queue.add(new Priority(Priority.Level.HIGH, "Deploy feature"));
queue.forEach(System.out::println);
// LOW: Update docs
// HIGH: Deploy feature
// CRITICAL: Fix prod crash

Comparable dengan Banyak Bidang

Untuk mengurutkan berdasarkan beberapa bidang, rangkai perbandingan: bidang utama, lalu bidang sekunder jika bidang utama sama.

class Employee implements Comparable<Employee> {
    final String dept, name;
    final double salary;

    Employee(String dept, String name, double salary) {
        this.dept = dept; this.name = name; this.salary = salary;
    }

    @Override
    public int compareTo(Employee other) {
        int deptCmp = this.dept.compareTo(other.dept);
        if (deptCmp != 0) return deptCmp;           // primary: by dept
        return this.name.compareTo(other.name);      // secondary: by name
    }
}

Konsistensi Comparable dan equals

Sangat disarankan, meskipun tidak diwajibkan, bahwa a.compareTo(b) == 0 jika dan hanya jika a.equals(b). Pelanggaran terhadap aturan ini menyebabkan bug yang sulit terlihat pada set dan map terurut.

// BigDecimal violates this: new BigDecimal("2.0").compareTo(new BigDecimal("2.00")) == 0
// but new BigDecimal("2.0").equals(new BigDecimal("2.00")) == false

// This causes TreeSet to treat them as equal (only one stored)
TreeSet<java.math.BigDecimal> set = new TreeSet<>();
set.add(new java.math.BigDecimal("2.0"));
set.add(new java.math.BigDecimal("2.00"));
System.out.println(set.size()); // 1 — compareTo-equal → same element

Pengurutan dengan Collections.sort

Collections.sort() dan Arrays.sort() menggunakan urutan alami yang ditentukan oleh Comparable.

List<String> names = new ArrayList<>(List.of("Charlie", "Alice", "Bob"));
Collections.sort(names); // natural alphabetical order
System.out.println(names); // [Alice, Bob, Charlie]

String[] arr = {"banana", "apple", "cherry"};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr)); // [apple, banana, cherry]

// Stream sorted() uses natural order
names.stream().sorted().forEach(System.out::println);

Comparable dalam Pencarian Biner

Collections.binarySearch() mengharuskan list diurutkan berdasarkan urutan alami dan elemennya mengimplementasikan Comparable.

List<Integer> sorted = new ArrayList<>(List.of(1, 3, 5, 7, 9, 11));
int idx = Collections.binarySearch(sorted, 7);
System.out.println("Found 7 at index: " + idx); // 3

int missing = Collections.binarySearch(sorted, 4);
System.out.println("4 not found, insertion point: " + (-missing - 1)); // 2

Comparable vs Comparator

Perbedaan utama:

Comparable: menentukan urutan alami milik class itu sendiri — satu urutan per class
Comparator: menentukan urutan eksternal — jumlahnya tidak terbatas dan dapat dikomposisikan

Praktik: Papan Peringkat

Papan peringkat yang menggunakan Comparable untuk urutan alami berdasarkan skor dari terbesar ke terkecil.

class LeaderboardEntry implements Comparable<LeaderboardEntry> {
    final String player;
    final int score;
    final long timestamp;

    LeaderboardEntry(String player, int score) {
        this.player = player; this.score = score;
        this.timestamp = System.nanoTime();
    }

    @Override
    public int compareTo(LeaderboardEntry other) {
        int scoreCmp = Integer.compare(other.score, this.score); // descending
        if (scoreCmp != 0) return scoreCmp;
        return Long.compare(this.timestamp, other.timestamp); // earlier = higher
    }

    @Override public String toString() { return player + ": " + score; }
}

TreeSet<LeaderboardEntry> board = new TreeSet<>();
board.add(new LeaderboardEntry("Alice", 950));
board.add(new LeaderboardEntry("Bob", 1200));
board.add(new LeaderboardEntry("Carol", 950));
board.forEach(System.out::println);
// Bob: 1200 / Alice: 950 / Carol: 950

Pemeriksaan Singkat

Apa yang dikembalikan oleh compareTo() ketika objek saat ini lebih kecil daripada argumen?

Ringkasan: Antarmuka Comparable

Hal-hal penting:

Implementasikan Comparable<T> untuk menentukan urutan alami sebuah class
compareTo mengembalikan nilai negatif (lebih kecil), nol (sama), atau positif (lebih besar)
Gunakan Integer.compare()/Double.compare() — jangan pernah melakukan pengurangan (berisiko mengalami luapan)
Rangkai perbandingan untuk pengurutan berdasarkan beberapa bidang: utama → sekunder
Urutan alami digunakan oleh Collections.sort, Arrays.sort, TreeSet, TreeMap
Comparable menentukan SATU urutan; gunakan Comparator untuk beberapa urutan

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Interface Comparable” gratis?

Ya — teks lengkap “Interface Comparable” 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 “Interface Comparable”?

Implementasikan Comparable untuk memberikan urutan alami pada class dan gunakan bersama Collections.sort. 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 1 dari 4.

Berapa lama pelajaran “Interface Comparable” 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

← Kembali ke Java Academy