C# Academy · Pelajaran

Mengimplementasikan IComparable

Definisikan urutan pengurutan alami dengan CompareTo.

Mengimplementasikan IComparable adalah pelajaran C# Academy gratis di CoddyKit. Ini adalah pelajaran 3 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 C# Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus C# Academy mencakup 4 pelajaran total.

Pengurutan dengan IComparable<T>

IComparable<T> menetapkan urutan alami untuk suatu tipe melalui satu metode, yaitu CompareTo. Setelah diterapkan, tipe Anda dapat diurutkan oleh Array.Sort, List.Sort, dan koleksi terurut.

Kontrak CompareTo

CompareTo mengembalikan bilangan negatif jika instans ini lebih kecil daripada yang lain, nol jika sama, dan bilangan positif jika lebih besar. Membandingkan nilai yang mendasarinya sering kali dapat menerapkan perilaku ini secara langsung.

using System;

public struct Weight : IComparable<Weight>
{
    public int Grams;
    public Weight(int g) { Grams = g; }

    public int CompareTo(Weight other) => Grams.CompareTo(other.Grams);

    public override string ToString() => Grams + "g";
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine(new Weight(100).CompareTo(new Weight(200)));
        Console.WriteLine(new Weight(200).CompareTo(new Weight(200)));
        Console.WriteLine(new Weight(300).CompareTo(new Weight(200)));
    }
}

Mengurutkan Daftar

Setelah suatu tipe dapat dibandingkan, List<T>.Sort() mengurutkannya menggunakan CompareTo tanpa argumen tambahan.

using System;
using System.Collections.Generic;

public struct Weight : IComparable<Weight>
{
    public int Grams;
    public Weight(int g) { Grams = g; }
    public int CompareTo(Weight other) => Grams.CompareTo(other.Grams);
    public override string ToString() => Grams + "g";
}

public class Program
{
    public static void Main()
    {
        var list = new List<Weight> { new Weight(300), new Weight(100), new Weight(200) };
        list.Sort();
        Console.WriteLine(string.Join(", ", list));
    }
}

Membandingkan Berdasarkan Bidang Utama

Untuk sebuah kelas, pilih bidang yang menentukan urutan alaminya. Di sini, people diurutkan berdasarkan usia dengan mendelegasikan perbandingan kepada int.CompareTo.

using System;
using System.Collections.Generic;

public class Person : IComparable<Person>
{
    public string Name;
    public int Age;
    public Person(string name, int age) { Name = name; Age = age; }
    public int CompareTo(Person other) => Age.CompareTo(other.Age);
    public override string ToString() => Name + "(" + Age + ")";
}

public class Program
{
    public static void Main()
    {
        var people = new List<Person> { new Person("Ann", 30), new Person("Bo", 20) };
        people.Sort();
        Console.WriteLine(string.Join(", ", people));
    }
}

Memecahkan Seri pada Beberapa Bidang

Jika kunci utama sama, bandingkan bidang sekunder. Hitung perbandingan pertama dan, hanya jika hasilnya nol, beralih ke bidang berikutnya.

using System;
using System.Collections.Generic;

public class Person : IComparable<Person>
{
    public string Name;
    public int Age;
    public Person(string name, int age) { Name = name; Age = age; }
    public int CompareTo(Person other)
    {
        int byAge = Age.CompareTo(other.Age);
        return byAge != 0 ? byAge : string.Compare(Name, other.Name, StringComparison.Ordinal);
    }
    public override string ToString() => Name + "(" + Age + ")";
}

public class Program
{
    public static void Main()
    {
        var people = new List<Person> { new Person("Zoe", 30), new Person("Ann", 30) };
        people.Sort();
        Console.WriteLine(string.Join(", ", people));
    }
}

Mengurutkan Larik

Array.Sort juga mengandalkan IComparable<T>. Logika perbandingan yang sama mendukung larik, daftar, dan struktur terurut.

using System;

public struct Score : IComparable<Score>
{
    public int Points;
    public Score(int p) { Points = p; }
    public int CompareTo(Score other) => Points.CompareTo(other.Points);
    public override string ToString() => Points.ToString();
}

public class Program
{
    public static void Main()
    {
        var scores = new[] { new Score(50), new Score(10), new Score(30) };
        Array.Sort(scores);
        Console.WriteLine(string.Join(", ", (object[])scores));
    }
}

Urutan Menurun

Untuk membalikkan urutan, balikkan perbandingan dengan menukar operan CompareTo. Ini adalah cara yang rapi untuk mengurutkan dari nilai tinggi ke rendah tanpa pembanding terpisah.

using System;
using System.Collections.Generic;

public struct Score : IComparable<Score>
{
    public int Points;
    public Score(int p) { Points = p; }
    // Reversed: higher points come first
    public int CompareTo(Score other) => other.Points.CompareTo(Points);
    public override string ToString() => Points.ToString();
}

public class Program
{
    public static void Main()
    {
        var list = new List<Score> { new Score(10), new Score(50), new Score(30) };
        list.Sort();
        Console.WriteLine(string.Join(", ", list));
    }
}

Tipe yang Dapat Dibandingkan dan Disetarakan

Jika CompareTo mengembalikan nol, item dianggap sama dalam pengurutan. Jaga agar hal ini konsisten dengan Equals sehingga pengurutan dan pemeriksaan kesamaan memberikan hasil yang sama.

using System;

public struct Version : IComparable<Version>, IEquatable<Version>
{
    public int Major, Minor;
    public Version(int major, int minor) { Major = major; Minor = minor; }
    public int CompareTo(Version other)
    {
        int byMajor = Major.CompareTo(other.Major);
        return byMajor != 0 ? byMajor : Minor.CompareTo(other.Minor);
    }
    public bool Equals(Version other) => CompareTo(other) == 0;
    public override bool Equals(object obj) => obj is Version v && Equals(v);
    public override int GetHashCode() => HashCode.Combine(Major, Minor);
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine(new Version(1, 2).CompareTo(new Version(1, 5)));
        Console.WriteLine(new Version(2, 0).Equals(new Version(2, 0)));
    }
}

Menggunakan Perbandingan dalam LINQ OrderBy

Bahkan tanpa mengurutkan di tempat, LINQ OrderBy dapat menggunakan tipe Anda yang dapat dibandingkan melalui pemilih kunci, sehingga menghasilkan tampilan terurut secara malas.

using System;
using System.Collections.Generic;
using System.Linq;

public struct Weight : IComparable<Weight>
{
    public int Grams;
    public Weight(int g) { Grams = g; }
    public int CompareTo(Weight other) => Grams.CompareTo(other.Grams);
    public override string ToString() => Grams + "g";
}

public class Program
{
    public static void Main()
    {
        var items = new List<Weight> { new Weight(300), new Weight(100) };
        foreach (var w in items.OrderBy(x => x))
            Console.WriteLine(w);
    }
}

Tipe Domain yang Dapat Diurutkan

Mengimplementasikan IComparable<T> mengubah konsep domain menjadi sesuatu yang dapat diurutkan oleh seluruh kerangka kerja. Di sini, tasks diurutkan berdasarkan prioritas, lalu nama.

using System;
using System.Collections.Generic;

public class TaskItem : IComparable<TaskItem>
{
    public string Name;
    public int Priority;
    public TaskItem(string name, int priority) { Name = name; Priority = priority; }
    public int CompareTo(TaskItem other)
    {
        int byPriority = Priority.CompareTo(other.Priority);
        return byPriority != 0 ? byPriority : string.Compare(Name, other.Name, StringComparison.Ordinal);
    }
    public override string ToString() => Priority + ":" + Name;
}

public class Program
{
    public static void Main()
    {
        var tasks = new List<TaskItem>
        {
            new TaskItem("deploy", 2), new TaskItem("build", 1), new TaskItem("test", 1)
        };
        tasks.Sort();
        Console.WriteLine(string.Join(", ", tasks));
    }
}

Coba Sendiri

Buat tipe yang dapat dibandingkan dengan beberapa bidang, lalu urutkan daftarnya. Urutan alami diperoleh dari CompareTo tanpa argumen tambahan.

using System;
using System.Collections.Generic;

public class Card : IComparable<Card>
{
    public int Rank;
    public string Suit;
    public Card(int rank, string suit) { Rank = rank; Suit = suit; }
    public int CompareTo(Card other)
    {
        int byRank = Rank.CompareTo(other.Rank);
        return byRank != 0 ? byRank : string.Compare(Suit, other.Suit, StringComparison.Ordinal);
    }
    public override string ToString() => Rank + Suit;
}

public class Program
{
    public static void Main()
    {
        var hand = new List<Card>
        {
            new Card(10, "H"), new Card(2, "S"), new Card(10, "C")
        };
        hand.Sort();
        Console.WriteLine(string.Join(", ", hand));
    }
}

Pemeriksaan Singkat

Ingat kembali kontrak CompareTo.

Ringkasan

IComparable<T> menentukan urutan alami melalui CompareTo.

Nilai negatif, nol, dan positif berarti kurang dari, sama dengan, dan lebih besar dari.
Memungkinkan penggunaan List.Sort, Array.Sort, dan koleksi terurut.
Jika nilainya sama, bandingkan bidang sekunder sebagai pemecah seri.
Pastikan CompareTo == 0 konsisten dengan Equals.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Mengimplementasikan IComparable” gratis?

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

Apa yang akan aku pelajari di “Mengimplementasikan IComparable”?

Definisikan urutan pengurutan alami dengan CompareTo. Kamu berlatih C# 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 C# Academy?

Tidak diperlukan pengalaman sebelumnya. C# 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 3 dari 4.

Berapa lama pelajaran “Mengimplementasikan IComparable” 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 C# Academy ini?

Ya. Setiap pelajaran C# 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 C# Academy