List C#: Add, Remove, Contains, Find dan Sort

List<T> adalah koleksi berurutan yang bertambah dan berkurang seiring kamu menambah dan menghapus item. Koleksi ini ada di System.Collections.Generic, diakses lewat indeks seperti array (list[0]), dan menjadi pilihan default untuk "sekumpulan benda" di C#.

Membuat list dan menambahkan item

Parameter tipe di dalam kurung sudut menyatakan apa isi list-nya: List<string>, List<int>, List<Order>.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var cart = new List<string>();
        cart.Add("apples");
        cart.Add("bread");

        var names = new List<string> { "Ana", "Ben" };  // collection initializer
        names.Insert(0, "Zoe");                         // at position 0
        names.AddRange(new[] { "Chloe", "Dev" });        // several at once

        var fromArray = new List<int>(new[] { 3, 1, 2 });

        Console.WriteLine(cart.Count);
        Console.WriteLine(string.Join(", ", names));
        Console.WriteLine(names[1]);
        names[1] = "Ana B.";                             // replace by index
        Console.WriteLine(names[1]);
        Console.WriteLine(fromArray.Count);
    }
}

Output:

2
Zoe, Ana, Ben, Chloe, Dev
Ana
Ana B.
3

Count adalah property, bukan method (array memakai Length, LINQ punya method Count(); pada list, pakai property-nya). Insert menggeser setiap item sesudahnya satu tempat, jadi menyisipkan di depan list yang besar butuh waktu sebanding dengan ukurannya. Add di akhir adalah operasi yang murah.

Menghapus item

Ada empat cara menghapus, tergantung apa yang kamu ketahui tentang item tersebut:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var scores = new List<int> { 40, 85, 62, 40, 91, 55 };

        bool removed = scores.Remove(40);          // first 40 only
        Console.WriteLine(removed + ": " + string.Join(", ", scores));

        Console.WriteLine(scores.Remove(100));     // not found, nothing happens

        scores.RemoveAt(0);                        // by index
        Console.WriteLine(string.Join(", ", scores));

        int count = scores.RemoveAll(s => s < 60); // every match
        Console.WriteLine(count + " removed: " + string.Join(", ", scores));

        try
        {
            scores.RemoveAt(10);
        }
        catch (ArgumentOutOfRangeException e)
        {
            Console.WriteLine("Caught " + e.GetType().Name);
        }

        scores.Clear();
        Console.WriteLine(scores.Count);
    }
}

Output:

True: 85, 62, 40, 91, 55
False
62, 40, 91, 55
2 removed: 62, 91
Caught ArgumentOutOfRangeException
0

Remove menerima sebuah nilai dan hanya menghapus kecocokan pertama. Untuk menghapus semua salinan sebuah nilai, pakai RemoveAll(s => s == 40). Indeks yang salah pada list melempar ArgumentOutOfRangeException (sedangkan array melempar IndexOutOfRangeException), baik untuk list[i] maupun RemoveAt(i). RemoveRange(index, count) menghapus satu blok item.

Count vs Capacity

List menyimpan item-itemnya di sebuah array internal. Capacity adalah ukuran array itu; Count adalah berapa banyak slot yang terpakai. Saat Count mencapai Capacity, Add berikutnya mengalokasikan array yang dua kali lebih besar lalu menyalin semuanya.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var list = new List<int>();
        Console.WriteLine("Count " + list.Count + ", Capacity " + list.Capacity);

        for (int i = 1; i <= 9; i++)
        {
            list.Add(i);
            Console.WriteLine("Count " + list.Count + ", Capacity " + list.Capacity);
        }

        var sized = new List<int>(1000); // preallocate when you know the size
        Console.WriteLine("Count " + sized.Count + ", Capacity " + sized.Capacity);
    }
}

Output:

Count 0, Capacity 0
Count 1, Capacity 4
Count 2, Capacity 4
Count 3, Capacity 4
Count 4, Capacity 4
Count 5, Capacity 8
Count 6, Capacity 8
Count 7, Capacity 8
Count 8, Capacity 8
Count 9, Capacity 16
Count 0, Capacity 1000

Penggandaan ini berarti sebagian besar pemanggilan Add hanya menulis ke slot yang masih kosong. Kalau kamu kira-kira tahu berapa banyak item yang akan datang, kirim angkanya ke constructor untuk melewati penyalinan di tengah jalan. Perhatikan bahwa new List<int>(1000) tetap punya Count 0: list[0] padanya akan melempar exception. Capacity adalah ruang, bukan item.

Mencari: Contains, IndexOf, Find, Exists

using System;
using System.Collections.Generic;

class Product
{
    public string Name;
    public decimal Price;
    public Product(string name, decimal price) { Name = name; Price = price; }
}

class Program
{
    static void Main()
    {
        var tags = new List<string> { "new", "sale", "gift" };
        Console.WriteLine(tags.Contains("sale"));
        Console.WriteLine(tags.IndexOf("gift"));
        Console.WriteLine(tags.IndexOf("used"));

        var products = new List<Product>
        {
            new Product("Mug", 8.50m),
            new Product("Lamp", 32.00m),
            new Product("Pen", 1.20m),
        };

        Product lamp = products.Find(p => p.Name == "Lamp");
        Console.WriteLine(lamp.Price);

        List<Product> cheap = products.FindAll(p => p.Price < 10m);
        Console.WriteLine(cheap.Count + " cheap items");

        Console.WriteLine(products.Exists(p => p.Price > 100m));
        Console.WriteLine(products.FindIndex(p => p.Name == "Pen"));

        Product missing = products.Find(p => p.Name == "Desk");
        Console.WriteLine(missing == null);

        // Contains compares references for a class without Equals:
        Console.WriteLine(products.Contains(new Product("Mug", 8.50m)));
    }
}

Output:

True
2
-1
32.00
2 cheap items
False
2
True
False

Find mengembalikan kecocokan pertama, atau nilai default tipe tersebut (null untuk class) saat tidak ada yang cocok, jadi periksa dulu sebelum memakai hasilnya. Baris terakhir mencetak False karena Contains memakai Equals, dan class tanpa override Equals membandingkan referensi: Product baru dengan field yang sama adalah objek yang berbeda. Cari berdasarkan property dengan Exists atau Find sebagai gantinya, atau override Equals dan GetHashCode pada class itu.

Semua method ini menelusuri list dari awal, jadi setiap pemanggilan bernilai O(n). Untuk pencarian berulang berdasarkan key, Dictionary menjawab dalam waktu konstan.

Mengurutkan list

Sort() mengurutkan list itu sendiri berdasarkan urutan alami item-itemnya. Kirim lambda perbandingan untuk mengurutkan berdasarkan hal lain.

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

class Player
{
    public string Name;
    public int Score;
    public Player(string name, int score) { Name = name; Score = score; }
    public override string ToString() { return Name + " " + Score; }
}

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

        numbers.Sort((a, b) => b.CompareTo(a)); // descending
        Console.WriteLine(string.Join(", ", numbers));

        var players = new List<Player>
        {
            new Player("Ana", 120),
            new Player("Ben", 95),
            new Player("Chloe", 150),
        };

        players.Sort((a, b) => a.Score.CompareTo(b.Score)); // by property
        Console.WriteLine(string.Join(", ", players));

        List<Player> byName = players.OrderByDescending(p => p.Name).ToList(); // new list
        Console.WriteLine(string.Join(", ", byName));
        Console.WriteLine(string.Join(", ", players)); // unchanged by OrderBy
    }
}

Output:

1, 2, 5, 9
9, 5, 2, 1
Ben 95, Ana 120, Chloe 150
Chloe 150, Ben 95, Ana 120
Ben 95, Ana 120, Chloe 150

Sebuah perbandingan mengembalikan angka negatif saat a harus berada di depan, positif saat b yang harus di depan, dan nol saat keduanya setara; CompareTo menghasilkan persis itu. Ada dua perbedaan antara Sort dan OrderBy milik LINQ yang penting dalam praktik:

• Sort mengubah list-nya; OrderBy mengembalikan urutan baru dan tidak mengubah list.
• Sort tidak stabil: item yang dianggap sama bisa bertukar tempat. OrderBy stabil, dan ThenBy menambahkan key kedua: players.OrderBy(p => p.Score).ThenBy(p => p.Name).

Memanggil Sort() pada list berisi class buatanmu tanpa perbandingan akan melempar InvalidOperationException, karena list tidak tahu cara mengurutkan item-itemnya. Kirim sebuah perbandingan atau implementasikan IComparable<T> pada class tersebut.

Reverse() membalik urutan list itu sendiri. Karena System.Linq juga mendefinisikan extension Reverse, list.Reverse() pada List<T> memilih versi yang mengubah list itu sendiri, yang tidak mengembalikan apa pun.

Perulangan, dan menghapus saat iterasi

foreach membaca setiap item secara berurutan. Perulangan for juga memberimu indeksnya. Yang tidak bisa kamu lakukan adalah menambah atau menghapus item di tengah foreach pada list yang sama:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var orders = new List<int> { 120, 15, 80, 5, 60 };

        try
        {
            foreach (int total in orders)
            {
                if (total < 20) orders.Remove(total);
            }
        }
        catch (InvalidOperationException e)
        {
            Console.WriteLine("Caught " + e.GetType().Name);
        }

        orders = new List<int> { 120, 15, 80, 5, 60 };

        // Fix 1: RemoveAll
        var a = new List<int>(orders);
        a.RemoveAll(t => t < 20);
        Console.WriteLine(string.Join(", ", a));

        // Fix 2: loop backwards, so removals do not shift items you have not seen
        var b = new List<int>(orders);
        for (int i = b.Count - 1; i >= 0; i--)
        {
            if (b[i] < 20) b.RemoveAt(i);
        }
        Console.WriteLine(string.Join(", ", b));
    }
}

Output:

Caught InvalidOperationException
120, 80, 60
120, 80, 60

Exception-nya adalah InvalidOperationException dengan pesan "Collection was modified; enumeration operation may not execute." Perulangan for yang maju tidak melempar exception, tapi diam-diam melewatkan item tepat setelah setiap item yang kamu hapus, karena semuanya bergeser turun satu indeks. Perulangan mundur menghindari masalah itu. Solusi ketiga adalah melakukan iterasi pada salinannya: foreach (var t in orders.ToList()).

Mengubah sebuah property item di dalam foreach (misalnya order.Status = "sent") tidak masalah. Menambah atau menghapus item merusak enumerator, begitu juga mengganti item lewat indexer (orders[i] = 0).

Konversi antara list dan array

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

class Program
{
    static void Main()
    {
        string[] cities = { "Oslo", "Lima", "Pune" };

        List<string> list = cities.ToList();       // or new List<string>(cities)
        list.Add("Kyiv");

        string[] back = list.ToArray();
        Console.WriteLine(back.Length);
        Console.WriteLine(cities.Length);           // the original array is unchanged

        List<int> lengths = list.ConvertAll(c => c.Length);
        Console.WriteLine(string.Join(", ", lengths));
        Console.WriteLine(string.Join(" / ", list));
    }
}

Output:

4
3
4, 4, 4, 4
Oslo / Lima / Pune / Kyiv

Kedua arah menyalin elemen ke penyimpanan baru, jadi mengubah list nantinya tidak memengaruhi array-nya. ConvertAll adalah versi milik list sendiri dari Select(...).ToList() di LINQ. Mencetak list dengan Console.WriteLine(list) menampilkan nama tipenya (System.Collections.Generic.List`1[System.String]); pakai string.Join.

Referensi singkat

Kesalahan yang sering terjadi

• Menghapus di dalam foreach. Melempar InvalidOperationException; pakai RemoveAll atau perulangan for mundur.
• Mengira Remove(x) menghapus setiap salinan. Method ini menghapus yang pertama; pakai RemoveAll.
• Memakai Contains pada objek tanpa Equals. Yang dibandingkan adalah referensi; cari berdasarkan property dengan Exists.
• Mengakses indeks pada list yang dibuat dengan capacity. new List<int>(10) masih kosong; tambahkan item dulu.
• Mengira Sort mempertahankan urutan item yang setara. Tidak; pakai OrderBy saat urutan di antara item yang setara itu penting.
• Memberikan list ke variabel lain untuk berbagi, lalu kaget dengan perubahannya. var copy = list; adalah list yang sama; new List<T>(list) adalah salinan.