List em C#: Add, Remove, Contains, Find e Sort

List<T> é uma coleção ordenada que cresce e diminui conforme você adiciona e remove itens. Ela fica em System.Collections.Generic, é indexada como um array (list[0]) e é a escolha padrão para "um monte de coisas" em C#.

Criando uma lista e adicionando itens

O parâmetro de tipo entre os sinais de menor e maior diz o que a lista guarda: 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);
    }
}

Saída:

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

Count é uma propriedade, não um método (arrays usam Length, o LINQ tem um método Count(); em uma lista, use a propriedade). Insert empurra cada item seguinte uma posição, então inserir no começo de uma lista grande custa um tempo proporcional ao tamanho dela. Add no fim é a operação barata.

Removendo itens

Há quatro formas de remover, dependendo do que você sabe sobre o item:

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);
    }
}

Saída:

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

Remove recebe um valor e apaga só a primeira correspondência. Para apagar todas as cópias de um valor, use RemoveAll(s => s == 40). Um índice inválido em uma lista lança ArgumentOutOfRangeException (um array lança IndexOutOfRangeException no lugar), tanto em list[i] quanto em RemoveAt(i). RemoveRange(index, count) remove um bloco.

Count vs Capacity

Uma lista guarda os itens em um array interno. Capacity é o tamanho desse array; Count é quantas posições estão em uso. Quando Count chega a Capacity, o próximo Add aloca um array com o dobro do tamanho e copia tudo para ele.

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);
    }
}

Saída:

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

Dobrar o tamanho faz com que a maioria das chamadas a Add seja só uma escrita em uma posição livre. Se você sabe mais ou menos quantos itens vêm por aí, passe o número ao construtor para evitar as cópias intermediárias. Repare que new List<int>(1000) ainda tem Count 0: list[0] nela lança exceção. Capacidade é espaço, não itens.

Buscando: 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)));
    }
}

Saída:

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

Find retorna a primeira correspondência ou o valor padrão do tipo (null para uma classe) quando nada corresponde, então verifique antes de usar o resultado. A última linha imprime False porque Contains usa Equals, e uma classe sem sobrescrever Equals compara referências: um Product novo com os mesmos campos é outro objeto. Busque por uma propriedade com Exists ou Find, ou sobrescreva Equals e GetHashCode na classe.

Todos esses métodos percorrem a lista desde o começo, então cada chamada é O(n). Para consultas repetidas por uma chave, um Dictionary responde em tempo constante.

Ordenando uma lista

Sort() ordena a própria lista usando a ordem natural dos itens. Passe uma lambda de comparação para ordenar por qualquer outra coisa.

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
    }
}

Saída:

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

Uma comparação retorna um número negativo quando a deve vir primeiro, positivo quando b deve, e zero quando empatam; CompareTo produz exatamente isso. Duas diferenças entre Sort e o OrderBy do LINQ importam na prática:

• Sort muda a lista; OrderBy retorna uma nova sequência e deixa a lista como está.
• Sort não é estável: itens considerados iguais podem trocar de lugar. OrderBy é estável, e ThenBy adiciona uma segunda chave: players.OrderBy(p => p.Score).ThenBy(p => p.Name).

Chamar Sort() em uma lista da sua própria classe sem uma comparação lança InvalidOperationException, porque a lista não sabe como ordenar os itens. Passe uma comparação ou implemente IComparable<T> na classe.

Reverse() inverte a própria lista. Como System.Linq também define uma extensão Reverse, list.Reverse() em uma List<T> escolhe a versão que altera a lista, que não retorna nada.

Percorrendo, e removendo durante a iteração

foreach lê cada item em ordem. Um laço for também dá o índice. O que você não pode fazer é adicionar ou remover itens no meio de um foreach sobre a mesma lista:

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));
    }
}

Saída:

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

A exceção é InvalidOperationException com a mensagem "Collection was modified; enumeration operation may not execute." Um laço for para frente não lança exceção, mas pula sem aviso o item logo depois de cada um que você remove, porque tudo desce um índice. Percorrer de trás para frente evita isso. Uma terceira solução é iterar sobre uma cópia: foreach (var t in orders.ToList()).

Mudar uma propriedade de um item dentro do foreach (por exemplo order.Status = "sent") não tem problema. Adicionar ou remover itens quebra o enumerador, e substituir um pelo indexador (orders[i] = 0) também.

Convertendo entre listas e arrays

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));
    }
}

Saída:

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

As duas direções copiam os elementos para um armazenamento novo, então mudar a lista depois não afeta o array. ConvertAll é a versão da própria lista para o Select(...).ToList() do LINQ. Imprimir uma lista com Console.WriteLine(list) mostra o nome do tipo (System.Collections.Generic.List`1[System.String]); use string.Join.

Referência rápida

Erros comuns

• Remover dentro de um foreach. Lança InvalidOperationException; use RemoveAll ou um laço for de trás para frente.
• Esperar que Remove(x) remova todas as cópias. Ele remove a primeira; use RemoveAll.
• Usar Contains em objetos sem Equals. Ele compara referências; busque por propriedade com Exists.
• Acessar por índice uma lista criada com capacidade. new List<int>(10) está vazia; adicione itens antes.
• Supor que Sort mantém a ordem dos empates. Não mantém; use OrderBy quando a ordem entre iguais importar.
• Atribuir uma lista para compartilhá-la e se surpreender com as mudanças. var copy = list; é a mesma lista; new List<T>(list) é uma cópia.