C# Academy · Aula

List na prática

Adicione, remova e pesquise.

List na prática é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C# Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C# Academy inclui 4 aulas no total.

Por que usar List<T>?

List<T> é o array dinâmico usado no dia a dia em C#. Ele fica em System.Collections.Generic e cresce automaticamente à medida que você adiciona itens.

Ao contrário de um array comum, você nunca precisa definir um tamanho fixo de antemão. Ele oferece segurança de tipos: uma List<int> só contém valores int, e isso é verificado em tempo de compilação.

using System.Collections.Generic;

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

Criando e inicializando

Você pode preencher uma lista imediatamente usando um inicializador de coleção. Essa forma é concisa e legível.

Nos bastidores, o compilador transforma cada entrada em uma chamada a Add, portanto o resultado é idêntico ao de adicionar os itens um por um.

using System;
using System.Collections.Generic;

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

Indexação e contagem

Acesse os elementos por um índice baseado em zero, assim como em um array. list[0] é o primeiro item.

Use Count, e não Length, para saber quantos itens a lista contém. Ler ou escrever por índice tem tempo constante 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);
    }
}

Adicionando e inserindo

Add adiciona ao final com custo amortizado O(1). AddRange adiciona vários itens de uma só vez.

Insert(index, item) coloca um item em uma posição, deslocando tudo o que vem depois. Esse deslocamento torna Insert no início uma operação O(n), portanto prefira adicionar ao final quando possível.

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

Removendo itens

Remove(item) exclui o primeiro valor correspondente e retorna true se encontrá-lo. RemoveAt(index) exclui o item pela posição.

Ambos deslocam os elementos seguintes para a esquerda, portanto remover algo do meio custa O(n). RemoveAll recebe uma função de filtragem e remove todas as correspondências em uma única passagem.

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

Pesquisando em uma lista

Contains informa se um valor existe; IndexOf fornece sua posição ou -1. Ambos percorrem a lista linearmente, em O(n).

Se você perceber que está pesquisando repetidamente uma lista grande por valor, esse custo linear se acumula. Um HashSet ou Dictionary pode ser mais adequado.

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

Percorrendo

Um laço foreach é a forma mais clara de ler cada elemento. Você também pode usar um laço clássico for quando precisar do índice.

Não adicione nem remova itens dentro de um foreach que percorre a mesma lista, pois isso lança 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);
    }
}

Ordenando

Sort() ordena a lista no próprio lugar usando o comparador padrão. Para uma ordem personalizada, passe um delegado de comparação.

Ordenar custa O(n log n). Para obter uma cópia ordenada sem alterar o original, use o OrderBy do LINQ, que retorna uma nova sequência.

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

Capacidade versus contagem

Count é a quantidade de itens existentes; Capacity é a quantidade de itens que a lista pode conter antes de realocar seu array interno.

Quando a lista ultrapassa a capacidade, ela aloca um array maior e copia os itens, aproximadamente dobrando o tamanho. Se você souber o tamanho final, passe-o ao construtor para evitar cópias repetidas.

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

Lista como argumento de método

Uma List<T> é um tipo de referência. Passá-la a um método passa a referência, portanto as alterações feitas dentro do método afetam a lista de quem o chamou.

Se um método apenas lê os dados, aceite IEnumerable<T> ou IReadOnlyList<T> para indicar que você não irá modificá-la.

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

Convertendo e copiando

ToArray() produz um array de tamanho fixo; new List<T>(other) cria uma cópia superficial de outra sequência.

Uma cópia superficial duplica a estrutura da lista, mas compartilha as mesmas referências dos elementos, portanto alterar um objeto contido fica visível por meio das duas listas.

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

Verificação rápida

Escolha a operação cujo custo mais se destaca.

Recapitulação

List<T> é um array expansível e seguro quanto aos tipos. O acesso por índice e Count custam O(1); Add no final tem custo amortizado O(1).

Inserir, remover e pesquisar por valor no meio custam O(n) por causa do deslocamento ou da varredura. Reserve capacidade quando o tamanho for conhecido para evitar realocações.

Perguntas Frequentes

A aula “List na prática” é grátis?

Sim — o texto completo de “List na prática” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C# Academy, atualize para CoddyKit PRO. O curso de C# Academy inclui 4 aulas no total.

O que vou aprender em “List na prática”?

Adicione, remova e pesquise. Você pratica C# Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C# Academy?

Nenhuma experiência prévia é necessária. C# Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “List na prática”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C# Academy?

Sim. Cada aula de C# Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para C# Academy