C# Academy · Pelajaran

List dalam Praktik

Tambah, hapus, dan cari.

List dalam Praktik adalah pelajaran C# 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 C# Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus C# Academy mencakup 4 pelajaran total.

Mengapa List<T>?

List<T> adalah larik dinamis yang umum digunakan dalam C#. Tipe ini berada di System.Collections.Generic dan bertambah otomatis saat Anda menambahkan elemen.

Berbeda dari larik biasa, Anda tidak perlu menetapkan ukuran tetap sejak awal. Tipe ini aman berdasarkan tipe: List<int> hanya menampung nilai int, dan kesalahan tersebut terdeteksi saat kompilasi.

using System.Collections.Generic;

List<int> scores = new List<int>();
scores.Add(90);
scores.Add(85);

Membuat dan Menginisialisasi

Anda dapat langsung mengisi daftar menggunakan penginisialisasi koleksi. Cara ini singkat dan mudah dibaca.

Kompiler mengubah setiap entri menjadi pemanggilan Add di balik layar, sehingga hasilnya sama seperti menambahkan elemen satu per satu.

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var fruits = new List<string> { "apple", "pear", "plum" };
        Console.WriteLine(fruits.Count);
    }
}

Pengindeksan dan Jumlah

Akses elemen berdasarkan indeks yang dimulai dari nol, sama seperti pada larik. list[0] adalah elemen pertama.

Gunakan Count, bukan Length, untuk mengetahui jumlah elemen yang ditampung daftar. Membaca atau menulis berdasarkan indeks membutuhkan waktu konstan O(1).

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var nums = new List<int> { 10, 20, 30 };
        Console.WriteLine(nums[1]);
        Console.WriteLine(nums.Count);
    }
}

Menambahkan dan Menyisipkan

Add menambahkan elemen ke akhir dengan waktu O(1) secara amortisasi. AddRange menambahkan banyak elemen sekaligus.

Insert(index, item) menempatkan elemen pada suatu posisi dan menggeser semua elemen setelahnya. Pergeseran ini membuat Insert di bagian awal membutuhkan waktu O(n), jadi sebaiknya tambahkan elemen di akhir jika memungkinkan.

var list = new List<string> { "b", "c" };
list.Insert(0, "a");
list.AddRange(new[] { "d", "e" });
// list is now a, b, c, d, e

Menghapus Elemen

Remove(item) menghapus nilai pertama yang cocok dan mengembalikan true jika ditemukan. RemoveAt(index) menghapus berdasarkan posisi.

Keduanya menggeser elemen berikutnya ke kiri, sehingga penghapusan dari bagian tengah membutuhkan waktu O(n). RemoveAll menerima predikat dan menghapus semua kecocokan dalam satu lintasan.

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var nums = new List<int> { 1, 2, 3, 4, 5 };
        nums.RemoveAll(n => n % 2 == 0);
        Console.WriteLine(string.Join(",", nums));
    }
}

Mencari dalam Daftar

Contains memberi tahu apakah suatu nilai ada; IndexOf memberikan posisinya atau -1. Keduanya melakukan pemindaian linear, O(n).

Jika Anda sering mencari berdasarkan nilai dalam daftar besar, biaya linear tersebut akan terakumulasi. HashSet atau Dictionary mungkin lebih sesuai.

var names = new List<string> { "Ann", "Bob", "Cy" };
bool hasBob = names.Contains("Bob");   // true
int pos = names.IndexOf("Cy");          // 2

Melakukan Iterasi

Perulangan foreach adalah cara paling jelas untuk membaca setiap elemen. Anda juga dapat menggunakan perulangan for klasik ketika memerlukan indeks.

Jangan menambahkan atau menghapus elemen di dalam foreach yang menelusuri daftar yang sama karena tindakan tersebut akan memunculkan InvalidOperationException.

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var colors = new List<string> { "red", "green", "blue" };
        foreach (var c in colors)
            Console.WriteLine(c);
    }
}

Mengurutkan

Sort() mengurutkan daftar secara langsung menggunakan pembanding bawaan. Untuk urutan khusus, berikan delegasi perbandingan.

Pengurutan membutuhkan waktu O(n log n). Untuk mendapatkan salinan terurut tanpa mengubah original, gunakan OrderBy milik LINQ, yang mengembalikan urutan baru.

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var nums = new List<int> { 4, 1, 3, 2 };
        nums.Sort();
        Console.WriteLine(string.Join(",", nums));
    }
}

Kapasitas dan Jumlah

Count adalah jumlah elemen yang ada; Capacity adalah jumlah elemen yang dapat ditampung sebelum larik internal dialokasikan ulang.

Ketika daftar bertambah melebihi kapasitas, daftar tersebut mengalokasikan larik yang lebih besar lalu menyalin elemen, biasanya dengan menggandakan ukurannya. Jika Anda mengetahui ukuran akhirnya, berikan ukuran tersebut ke konstruktor agar penyalinan berulang dapat dihindari.

var list = new List<int>(1000); // reserve capacity
for (int i = 0; i < 1000; i++)
    list.Add(i);
// no intermediate reallocations

Daftar sebagai Argumen Metode

List<T> adalah tipe referensi. Meneruskannya ke metode berarti meneruskan referensinya, sehingga perubahan di dalam metode memengaruhi daftar milik pemanggil.

Jika suatu metode hanya membaca, terimalah IEnumerable<T> atau IReadOnlyList<T> untuk menandakan bahwa Anda tidak akan mengubahnya.

using System;
using System.Collections.Generic;

class Program {
    static void AddOne(List<int> xs) => xs.Add(1);
    static void Main() {
        var nums = new List<int>();
        AddOne(nums);
        Console.WriteLine(nums.Count); // 1
    }
}

Mengonversi dan Menyalin

ToArray() menghasilkan larik berukuran tetap; new List<T>(other) membuat salinan dangkal dari urutan lain.

Salinan dangkal menggandakan struktur daftar, tetapi menggunakan referensi elemen yang sama. Karena itu, perubahan pada objek yang ditampung akan terlihat melalui kedua daftar.

var original = new List<int> { 1, 2, 3 };
int[] arr = original.ToArray();
var copy = new List<int>(original);

Pemeriksaan Cepat

Pilih operasi yang biayanya paling menonjol.

Ringkasan

List<T> adalah larik yang dapat bertambah dan aman berdasarkan tipe. Akses berdasarkan indeks dan Count membutuhkan waktu O(1); Add di akhir membutuhkan waktu O(1) secara amortisasi.

Penyisipan, penghapusan, dan pencarian berdasarkan nilai di bagian tengah membutuhkan waktu O(n) karena adanya pergeseran atau pemindaian. Sisihkan kapasitas ketika ukurannya sudah diketahui untuk menghindari alokasi ulang.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “List dalam Praktik” gratis?

Ya — teks lengkap “List dalam Praktik” 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 “List dalam Praktik”?

Tambah, hapus, dan cari. 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 1 dari 4.

Berapa lama pelajaran “List dalam Praktik” 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