C# Academy · Lección

List en la práctica

Añada, elimine y busque

List en la práctica es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C# Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C# Academy incluye 4 lecciones en total.

¿Por qué List<T>?

List<T> es la matriz dinámica de uso habitual en C#. Se encuentra en System.Collections.Generic y crece automáticamente a medida que añade elementos.

A diferencia de una matriz normal, nunca tiene que establecer de antemano un tamaño fijo. Es segura respecto a los tipos: una List<int> solo contiene valores int, algo que se comprueba en tiempo de compilación.

using System.Collections.Generic;

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

Crear e inicializar

Puede rellenar una lista de inmediato mediante un inicializador de colección. Es una forma concisa y fácil de leer.

El compilador convierte cada entrada en una llamada a Add internamente, por lo que el resultado es idéntico a añadir los elementos uno por uno.

using System;
using System.Collections.Generic;

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

Indexación y Count

Acceda a los elementos mediante un índice basado en cero, igual que con una matriz. list[0] es el primer elemento.

Use Count (no Length) para obtener cuántos elementos contiene la lista. Leer o escribir mediante un índice tiene un tiempo 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);
    }
}

Añadir e insertar

Add añade elementos al final en un tiempo amortizado O(1). AddRange añade muchos elementos de una vez.

Insert(index, item) coloca un elemento en una posición y desplaza todo lo que viene después. Ese desplazamiento hace que insertar al principio con Insert tenga un coste O(n), por lo que, cuando sea posible, es preferible añadir al final.

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

Eliminar elementos

Remove(item) elimina el primer valor coincidente y devuelve true si lo encuentra. RemoveAt(index) elimina por posición.

Ambos métodos desplazan los elementos posteriores hacia la izquierda, por lo que eliminar en el centro cuesta O(n). RemoveAll acepta un predicado y elimina todas las coincidencias en una sola pasada.

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

Buscar en una lista

Contains indica si existe un valor; IndexOf devuelve su posición o -1. Ambos recorren la lista linealmente, con un coste O(n).

Si tiene que buscar repetidamente un valor en una lista grande, ese coste lineal se acumula. Un HashSet o un Dictionary puede ser más adecuado.

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

Iterar

Un bucle foreach es la forma más clara de leer todos los elementos. También puede usar un bucle for clásico cuando necesite el índice.

No añada ni elimine elementos dentro de un foreach que recorra la misma lista; esto produce 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);
    }
}

Ordenar

Sort() ordena la lista en el mismo lugar mediante el comparador predeterminado. Para usar un orden personalizado, pase un delegado de comparación.

Ordenar cuesta O(n log n). Para obtener una copia ordenada sin cambiar la original, use OrderBy de LINQ, que devuelve una secuencia nueva.

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

Capacity frente a Count

Count es el número de elementos existentes; Capacity es el número de elementos que puede contener antes de reasignar su matriz interna.

Cuando la lista supera la capacidad, asigna una matriz más grande y copia los elementos, normalmente duplicando el tamaño. Si conoce el tamaño final, páselo al constructor para evitar copias 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 un método

Una List<T> es un tipo por referencia. Al pasarla a un método se pasa la referencia, por lo que los cambios realizados dentro del método afectan a la lista del código que lo llamó.

Si un método solo lee la lista, acepte IEnumerable<T> o IReadOnlyList<T> para indicar que no la modificará.

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

Convertir y copiar

ToArray() produce una matriz de tamaño fijo; new List<T>(other) crea una copia superficial de otra secuencia.

Una copia superficial duplica la estructura de la lista, pero comparte las mismas referencias a los elementos, por lo que modificar un objeto contenido se refleja en ambas listas.

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

Comprobación rápida

Elija la operación cuyo coste destaca.

Resumen

List<T> es una matriz ampliable y segura respecto a los tipos. El acceso mediante índice y Count son O(1); Add al final tiene un coste amortizado O(1).

Insertar, eliminar y buscar un valor en el centro cuesta O(n) debido a los desplazamientos o al recorrido. Reserve capacidad cuando conozca el tamaño para evitar reasignaciones.

Preguntas frecuentes

¿La lección «List en la práctica» es gratis?

Sí — el texto completo de «List en la práctica» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C# Academy, actualiza a CoddyKit PRO. El curso de C# Academy incluye 4 lecciones en total.

¿Qué aprenderé en «List en la práctica»?

Añada, elimine y busque Practicas C# Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C# Academy?

No se requiere experiencia previa. C# Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «List en la práctica»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C# Academy?

Sí. Cada lección de C# Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a C# Academy