Tutorial CSharp: Arrays y listas

Arrays de longitud fija

Los arrays son estructuras de datos fundamentales en C# que permiten almacenar múltiples elementos del mismo tipo bajo un único nombre de variable. A diferencia de otras colecciones, los arrays en C# tienen una característica distintiva: su tamaño debe definirse al momento de su creación y permanece fijo durante toda su vida útil.

Un array puede visualizarse como una secuencia de casillas numeradas (índices) donde cada casilla puede contener un valor. En C#, los índices de los arrays siempre comienzan en cero, por lo que el primer elemento se encuentra en la posición 0, el segundo en la posición 1, y así sucesivamente.

Declaración y creación de arrays

Existen varias formas de declarar y crear arrays en C#:

// Declaración y creación en dos pasos
int[] numeros;           // Declaración
numeros = new int[5];    // Creación con tamaño 5

// Declaración y creación en un solo paso
string[] nombres = new string[3];

// Declaración, creación e inicialización en un solo paso
char[] vocales = new char[] {'a', 'e', 'i', 'o', 'u'};

// Forma abreviada (inferencia de tipo)
var dias = new[] {"Lunes", "Martes", "Miércoles", "Jueves", "Viernes"};

Acceso a elementos

Para acceder a los elementos de un array, utilizamos la notación de corchetes con el índice del elemento que queremos leer o modificar:

int[] calificaciones = new int[4];

// Asignación de valores
calificaciones[0] = 85;  // Primera posición
calificaciones[1] = 90;
calificaciones[2] = 78;
calificaciones[3] = 92;  // Última posición

// Lectura de valores
Console.WriteLine($"La segunda calificación es: {calificaciones[1]}");  // Muestra 90

Es importante tener cuidado con los índices, ya que intentar acceder a una posición fuera del rango del array provocará una excepción IndexOutOfRangeException:

// Esto generará una excepción en tiempo de ejecución
// calificaciones[4] = 88;  // ¡Error! El array solo tiene índices del 0 al 3

Propiedades y métodos útiles

Los arrays en C# son objetos que heredan de la clase System.Array, lo que les proporciona propiedades y métodos útiles:

int[] numeros = {10, 20, 30, 40, 50};

// Propiedades
int longitud = numeros.Length;       // Devuelve 5
int dimension = numeros.Rank;        // Devuelve 1 (array unidimensional)

// Métodos
Array.Sort(numeros);                 // Ordena el array: {10, 20, 30, 40, 50}
int posicion = Array.IndexOf(numeros, 30);  // Devuelve 2 (posición del valor 30)
Array.Reverse(numeros);              // Invierte el array: {50, 40, 30, 20, 10}
Array.Clear(numeros, 0, 2);          // Limpia los primeros 2 elementos: {0, 0, 30, 20, 10}

Arrays multidimensionales

C# permite crear arrays con múltiples dimensiones. Existen dos tipos principales:

1. Arrays rectangulares: Cada fila tiene el mismo número de columnas

// Array bidimensional 3x2 (3 filas, 2 columnas)
int[,] matriz = new int[3, 2];

// Asignación de valores
matriz[0, 0] = 1;  // Primera fila, primera columna
matriz[0, 1] = 2;  // Primera fila, segunda columna
matriz[1, 0] = 3;  // Segunda fila, primera columna
matriz[1, 1] = 4;  // Segunda fila, segunda columna
matriz[2, 0] = 5;  // Tercera fila, primera columna
matriz[2, 1] = 6;  // Tercera fila, segunda columna

// Inicialización directa
int[,] tablero = {
    {1, 2, 3},
    {4, 5, 6}
};  // Array 2x3

2. Arrays escalonados (jagged arrays): Arrays de arrays, donde cada fila puede tener diferente longitud

// Declaración de un array escalonado
int[][] triangulo = new int[3][];

// Inicialización de cada fila con diferente longitud
triangulo[0] = new int[1] {1};
triangulo[1] = new int[2] {2, 3};
triangulo[2] = new int[3] {4, 5, 6};

// Acceso a elementos
Console.WriteLine(triangulo[1][0]);  // Muestra 2

Limitaciones de los arrays de longitud fija

Los arrays de longitud fija presentan algunas limitaciones importantes:

• No se puede modificar su tamaño después de la creación
• Agregar o eliminar elementos requiere crear un nuevo array
• No tienen métodos integrados para insertar o eliminar elementos

// Para "agrandar" un array, debemos crear uno nuevo y copiar los elementos
int[] original = {1, 2, 3};
int[] nuevo = new int[5];

// Copiamos los elementos del array original al nuevo
Array.Copy(original, nuevo, original.Length);

// Ahora podemos agregar elementos en las posiciones adicionales
nuevo[3] = 4;
nuevo[4] = 5;

Uso de arrays en bucles

Los arrays se utilizan frecuentemente con estructuras de bucle para procesar sus elementos:

string[] frutas = {"manzana", "naranja", "plátano", "fresa", "kiwi"};

// Bucle for tradicional
for (int i = 0; i < frutas.Length; i++)
{
    Console.WriteLine($"Fruta {i+1}: {frutas[i]}");
}

// Bucle foreach (más simple para recorrer todos los elementos)
foreach (string fruta in frutas)
{
    Console.WriteLine($"Me gusta comer {fruta}");
}

Ejemplo práctico: Cálculo de estadísticas

Un ejemplo común del uso de arrays es para almacenar y procesar datos numéricos:

int[] temperaturas = {22, 25, 18, 20, 23, 19, 21};

// Cálculo de la temperatura promedio
int suma = 0;
foreach (int temp in temperaturas)
{
    suma += temp;
}
double promedio = (double)suma / temperaturas.Length;

// Encontrar temperatura máxima y mínima
int maxima = temperaturas[0];
int minima = temperaturas[0];

for (int i = 1; i < temperaturas.Length; i++)
{
    if (temperaturas[i] > maxima)
        maxima = temperaturas[i];
    
    if (temperaturas[i] < minima)
        minima = temperaturas[i];
}

Console.WriteLine($"Temperatura promedio: {promedio:F1}°C");
Console.WriteLine($"Temperatura máxima: {maxima}°C");
Console.WriteLine($"Temperatura mínima: {minima}°C");

Los arrays de longitud fija son ideales cuando conocemos de antemano el número exacto de elementos que necesitamos almacenar y este número no cambiará durante la ejecución del programa. Para situaciones donde necesitamos una colección que pueda crecer o reducirse dinámicamente, C# ofrece otras estructuras como List<T>, que veremos en la siguiente sección.

List<T> dinámica

A diferencia de los arrays con tamaño fijo, C# ofrece una alternativa más flexible para almacenar colecciones de elementos: la clase List<T>. Esta estructura de datos forma parte del espacio de nombres System.Collections.Generic y proporciona una colección dinámica que puede crecer o reducirse automáticamente según sea necesario.

La T en List<T> representa un tipo genérico, lo que significa que podemos crear listas de cualquier tipo de datos, ya sean tipos primitivos (como int o string) o tipos complejos definidos por el usuario (como clases personalizadas).

Declaración e inicialización

Para utilizar una lista, primero debemos incluir el espacio de nombres correspondiente:

using System.Collections.Generic;

Existen varias formas de crear e inicializar una lista:

// Crear una lista vacía de enteros
List<int> numeros = new List<int>();

// Crear una lista con capacidad inicial (optimización de rendimiento)
List<string> nombres = new List<string>(20);

// Crear e inicializar con valores
List<double> precios = new List<double> { 19.99, 29.99, 15.50 };

// Crear a partir de una colección existente
string[] ciudadesArray = { "Madrid", "Barcelona", "Valencia" };
List<string> ciudades = new List<string>(ciudadesArray);

Agregar y eliminar elementos

A diferencia de los arrays, las listas ofrecen métodos integrados para modificar su contenido:

List<string> tareas = new List<string>();

// Agregar elementos al final de la lista
tareas.Add("Estudiar C#");
tareas.Add("Hacer ejercicio");
tareas.Add("Comprar víveres");

// Insertar un elemento en una posición específica
tareas.Insert(1, "Llamar al médico");  // Se inserta en la posición 1

// Eliminar un elemento específico
tareas.Remove("Hacer ejercicio");  // Elimina la primera ocurrencia

// Eliminar el elemento en una posición específica
tareas.RemoveAt(0);  // Elimina el primer elemento

// Eliminar varios elementos que cumplan una condición
tareas.RemoveAll(t => t.StartsWith("Comprar"));

// Limpiar toda la lista
tareas.Clear();

Acceso a elementos

Podemos acceder a los elementos de una lista de manera similar a los arrays:

List<int> puntuaciones = new List<int> { 85, 92, 78, 95, 88 };

// Acceder por índice
int segundaPuntuacion = puntuaciones[1];  // Obtiene 92

// Modificar un elemento existente
puntuaciones[2] = 80;  // Cambia 78 por 80

// Obtener el primer y último elemento
int primera = puntuaciones[0];
int ultima = puntuaciones[puntuaciones.Count - 1];

// Métodos alternativos para el primer y último elemento
int primeraAlt = puntuaciones.First();
int ultimaAlt = puntuaciones.Last();

Propiedades y métodos útiles

La clase List<T> proporciona numerosas propiedades y métodos que facilitan el trabajo con colecciones:

List<string> frutas = new List<string> { "manzana", "naranja", "plátano", "fresa", "kiwi" };

// Propiedades
int cantidad = frutas.Count;  // Número de elementos (5)
int capacidad = frutas.Capacity;  // Capacidad interna (puede ser mayor que Count)

// Búsqueda
bool contieneFresa = frutas.Contains("fresa");  // Devuelve true
int posicionNaranja = frutas.IndexOf("naranja");  // Devuelve 1
int ultimaFruta = frutas.FindIndex(f => f.Length > 5);  // Encuentra índice de "naranja"

// Ordenación
frutas.Sort();  // Ordena alfabéticamente: "fresa", "kiwi", "manzana", "naranja", "plátano"
frutas.Reverse();  // Invierte el orden actual

// Conversión a array
string[] frutasArray = frutas.ToArray();

// Filtrado (devuelve una nueva lista)
List<string> frutasCortas = frutas.FindAll(f => f.Length <= 5);

Recorrido de listas

Al igual que con los arrays, podemos recorrer las listas utilizando bucles:

List<string> animales = new List<string> { "perro", "gato", "conejo", "pájaro" };

// Usando for
for (int i = 0; i < animales.Count; i++)
{
    Console.WriteLine($"Animal {i+1}: {animales[i]}");
}

// Usando foreach (más común y legible)
foreach (string animal in animales)
{
    Console.WriteLine($"Me gustan los {animal}s");
}

// Usando métodos funcionales (más moderno)
animales.ForEach(animal => Console.WriteLine($"Tengo un {animal}"));

Ventajas de List<T> sobre arrays

Las listas ofrecen varias ventajas significativas sobre los arrays tradicionales:

• Tamaño dinámico: Se redimensionan automáticamente al agregar o eliminar elementos
• Métodos integrados: Incluyen funcionalidad para insertar, eliminar, buscar y ordenar
• API más rica: Ofrecen más operaciones predefinidas que simplifican el código
• Compatibilidad LINQ: Se integran perfectamente con consultas LINQ para operaciones avanzadas

Ejemplo práctico: Gestión de estudiantes

Veamos un ejemplo que muestra cómo utilizar una lista para gestionar información de estudiantes:

// Definimos una clase simple para representar estudiantes
class Estudiante
{
    public string Nombre { get; set; }
    public int Edad { get; set; }
    public double Promedio { get; set; }

    public override string ToString()
    {
        return $"{Nombre} ({Edad} años) - Promedio: {Promedio:F1}";
    }
}

// Uso de List<T> con objetos personalizados
List<Estudiante> estudiantes = new List<Estudiante>
{
    new Estudiante { Nombre = "Ana", Edad = 20, Promedio = 8.5 },
    new Estudiante { Nombre = "Carlos", Edad = 19, Promedio = 7.8 },
    new Estudiante { Nombre = "Elena", Edad = 21, Promedio = 9.2 }
};

// Agregar un nuevo estudiante
estudiantes.Add(new Estudiante { Nombre = "David", Edad = 20, Promedio = 8.9 });

// Encontrar estudiantes con promedio superior a 8.0
List<Estudiante> destacados = estudiantes.FindAll(e => e.Promedio > 8.0);

// Mostrar estudiantes destacados
Console.WriteLine("Estudiantes destacados:");
foreach (var estudiante in destacados)
{
    Console.WriteLine(estudiante);
}

// Ordenar por promedio (de mayor a menor)
estudiantes.Sort((e1, e2) => e2.Promedio.CompareTo(e1.Promedio));

// Mostrar lista ordenada
Console.WriteLine("\nEstudiantes ordenados por promedio:");
estudiantes.ForEach(e => Console.WriteLine(e));

Consideraciones de rendimiento

Aunque las listas son muy convenientes, es importante tener en cuenta algunas consideraciones de rendimiento:

• Las listas reservan más memoria de la que necesitan inicialmente para evitar frecuentes redimensionamientos
• Si conoces aproximadamente cuántos elementos tendrá tu lista, es recomendable especificar una capacidad inicial
• Para colecciones muy grandes o con operaciones frecuentes de inserción/eliminación al principio, otras estructuras como LinkedList<T> pueden ser más eficientes

// Optimización de rendimiento especificando capacidad inicial
List<int> muchosDatos = new List<int>(10000);

Las listas dinámicas son una herramienta fundamental en el desarrollo con C# y resultan ideales para la mayoría de los escenarios donde necesitamos almacenar colecciones de datos que pueden cambiar de tamaño durante la ejecución del programa.

Operaciones comunes

Las colecciones en C# ofrecen un conjunto de operaciones que nos permiten manipular los datos de forma eficiente. Estas operaciones son fundamentales para el trabajo diario con colecciones y nos ayudan a resolver problemas comunes de programación. Vamos a explorar las operaciones más utilizadas tanto en arrays como en listas, centrándonos en aquellas que no hemos cubierto en detalle en las secciones anteriores.

Búsqueda de elementos

Encontrar elementos específicos es una de las tareas más frecuentes cuando trabajamos con colecciones:

// Búsqueda en arrays
int[] numeros = { 10, 25, 3, 42, 15 };
int indice = Array.IndexOf(numeros, 25); // Devuelve 1
int noExiste = Array.IndexOf(numeros, 100); // Devuelve -1 si no encuentra el elemento

// Búsqueda en List<T>
List<string> colores = new List<string> { "rojo", "verde", "azul", "amarillo" };
bool existeVerde = colores.Contains("verde"); // Devuelve true
int posicionAzul = colores.IndexOf("azul"); // Devuelve 2

Para búsquedas más complejas, podemos utilizar los métodos Find y FindAll en listas:

List<int> valores = new List<int> { 5, 12, 8, 24, 3, 16 };

// Encontrar el primer número par
int primerPar = valores.Find(x => x % 2 == 0); // Devuelve 12

// Encontrar todos los números mayores que 10
List<int> mayoresQueDiez = valores.FindAll(x => x > 10); // Devuelve [12, 24, 16]

Filtrado y transformación

Filtrar y transformar colecciones son operaciones muy comunes en el desarrollo de software:

// Filtrado básico con bucles
List<int> numeros = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
List<int> pares = new List<int>();

foreach (int num in numeros)
{
    if (num % 2 == 0)
        pares.Add(num);
}

// Transformación básica
List<string> nombres = new List<string> { "ana", "carlos", "elena" };
List<string> mayusculas = new List<string>();

foreach (string nombre in nombres)
{
    mayusculas.Add(nombre.ToUpper());
}

Ordenación personalizada

Aunque ya vimos la ordenación básica, a menudo necesitamos ordenar colecciones según criterios específicos:

// Ordenar array de enteros en orden descendente
int[] puntuaciones = { 85, 92, 78, 95, 88 };
Array.Sort(puntuaciones);
Array.Reverse(puntuaciones); // Ahora está en orden descendente

// Ordenación personalizada en List<T>
List<string> palabras = new List<string> { "manzana", "pera", "kiwi", "uva", "sandía" };

// Ordenar por longitud (de más corta a más larga)
palabras.Sort((a, b) => a.Length.CompareTo(b.Length));
// Resultado: ["uva", "kiwi", "pera", "manzana", "sandía"]

// Ordenar alfabéticamente ignorando mayúsculas/minúsculas
palabras.Sort((a, b) => string.Compare(a, b, StringComparison.OrdinalIgnoreCase));

Agregación y estadísticas

Calcular estadísticas sobre los elementos de una colección es otra operación común:

int[] calificaciones = { 85, 92, 78, 95, 88, 76, 90 };

// Cálculos básicos
int total = 0;
int maximo = calificaciones[0];
int minimo = calificaciones[0];

foreach (int cal in calificaciones)
{
    total += cal;
    if (cal > maximo) maximo = cal;
    if (cal < minimo) minimo = cal;
}

double promedio = (double)total / calificaciones.Length;

Console.WriteLine($"Promedio: {promedio:F1}");
Console.WriteLine($"Calificación más alta: {maximo}");
Console.WriteLine($"Calificación más baja: {minimo}");

Conversión entre colecciones

A menudo necesitamos convertir entre diferentes tipos de colecciones:

// Convertir array a List<T>
string[] frutasArray = { "manzana", "naranja", "plátano" };
List<string> frutasList = new List<string>(frutasArray);

// Convertir List<T> a array
List<int> edadesList = new List<int> { 25, 30, 28, 32 };
int[] edadesArray = edadesList.ToArray();

// Convertir a diccionario
List<string> ciudades = new List<string> { "Madrid", "Barcelona", "Valencia" };
Dictionary<int, string> ciudadesDic = ciudades
    .Select((ciudad, indice) => new { indice, ciudad })
    .ToDictionary(x => x.indice, x => x.ciudad);
// Resultado: {0: "Madrid", 1: "Barcelona", 2: "Valencia"}

Operaciones de conjuntos

Podemos realizar operaciones de teoría de conjuntos con colecciones:

List<int> conjunto1 = new List<int> { 1, 2, 3, 4, 5 };
List<int> conjunto2 = new List<int> { 4, 5, 6, 7, 8 };

// Unión (elementos que están en cualquiera de los conjuntos)
List<int> union = new List<int>(conjunto1);
foreach (int num in conjunto2)
{
    if (!union.Contains(num))
        union.Add(num);
}
// Resultado: [1, 2, 3, 4, 5, 6, 7, 8]

// Intersección (elementos que están en ambos conjuntos)
List<int> interseccion = new List<int>();
foreach (int num in conjunto1)
{
    if (conjunto2.Contains(num))
        interseccion.Add(num);
}
// Resultado: [4, 5]

// Diferencia (elementos en conjunto1 pero no en conjunto2)
List<int> diferencia = new List<int>();
foreach (int num in conjunto1)
{
    if (!conjunto2.Contains(num))
        diferencia.Add(num);
}
// Resultado: [1, 2, 3]

Modificación en bloque

A veces necesitamos modificar varios elementos de una colección a la vez:

List<int> numeros = new List<int> { 1, 2, 3, 4, 5 };

// Duplicar todos los valores
for (int i = 0; i < numeros.Count; i++)
{
    numeros[i] *= 2;
}
// Resultado: [2, 4, 6, 8, 10]

// Alternativa con ForEach
List<string> textos = new List<string> { "uno", "dos", "tres" };
textos.ForEach(t => Console.WriteLine(t.ToUpper()));

Ejemplo práctico: Análisis de datos de ventas

Veamos un ejemplo más completo que combina varias operaciones comunes para analizar datos de ventas:

// Definimos una clase simple para representar ventas
class Venta
{
    public string Producto { get; set; }
    public double Importe { get; set; }
    public DateTime Fecha { get; set; }
}

// Creamos una lista de ventas de ejemplo
List<Venta> ventas = new List<Venta>
{
    new Venta { Producto = "Laptop", Importe = 899.99, Fecha = new DateTime(2023, 1, 15) },
    new Venta { Producto = "Teléfono", Importe = 499.50, Fecha = new DateTime(2023, 1, 20) },
    new Venta { Producto = "Monitor", Importe = 299.99, Fecha = new DateTime(2023, 2, 5) },
    new Venta { Producto = "Teclado", Importe = 59.99, Fecha = new DateTime(2023, 2, 10) },
    new Venta { Producto = "Laptop", Importe = 1299.99, Fecha = new DateTime(2023, 2, 15) },
    new Venta { Producto = "Teléfono", Importe = 599.99, Fecha = new DateTime(2023, 3, 1) }
};

// 1. Calcular el total de ventas
double totalVentas = 0;
foreach (var venta in ventas)
{
    totalVentas += venta.Importe;
}
Console.WriteLine($"Total de ventas: {totalVentas:C}");

// 2. Encontrar la venta de mayor importe
Venta ventaMayor = ventas[0];
foreach (var venta in ventas)
{
    if (venta.Importe > ventaMayor.Importe)
        ventaMayor = venta;
}
Console.WriteLine($"Venta de mayor importe: {ventaMayor.Producto} - {ventaMayor.Importe:C}");

// 3. Filtrar ventas por mes
List<Venta> ventasFebrero = new List<Venta>();
foreach (var venta in ventas)
{
    if (venta.Fecha.Month == 2) // Febrero
        ventasFebrero.Add(venta);
}
Console.WriteLine($"Ventas en febrero: {ventasFebrero.Count}");

// 4. Agrupar ventas por producto
Dictionary<string, double> ventasPorProducto = new Dictionary<string, double>();
foreach (var venta in ventas)
{
    if (ventasPorProducto.ContainsKey(venta.Producto))
        ventasPorProducto[venta.Producto] += venta.Importe;
    else
        ventasPorProducto[venta.Producto] = venta.Importe;
}

// Mostrar ventas por producto
Console.WriteLine("\nVentas por producto:");
foreach (var kvp in ventasPorProducto)
{
    Console.WriteLine($"{kvp.Key}: {kvp.Value:C}");
}

Rendimiento y consideraciones prácticas

Al trabajar con colecciones, es importante considerar el rendimiento de las operaciones:

• Las operaciones de búsqueda en arrays y listas no ordenadas tienen complejidad O(n)
• La inserción y eliminación en arrays requiere desplazar elementos, lo que puede ser costoso
• Para búsquedas frecuentes, considera usar un Dictionary<TKey, TValue> que ofrece acceso O(1)
• Para grandes volúmenes de datos, evalúa el uso de estructuras especializadas

// Ejemplo de optimización para búsquedas frecuentes
List<string> ciudades = new List<string> { "Madrid", "Barcelona", "Valencia", "Sevilla" };

// Convertir a HashSet para búsquedas más rápidas
HashSet<string> ciudadesSet = new HashSet<string>(ciudades);

// Ahora las búsquedas son O(1) en lugar de O(n)
bool contieneMadrid = ciudadesSet.Contains("Madrid"); // Muy eficiente

Dominar estas operaciones comunes te permitirá manipular datos de manera eficiente en tus aplicaciones C#, aprovechando al máximo el potencial de las colecciones para resolver problemas del mundo real.