Ir al contenido principal

Arrays unidimensionales

Hasta ahora hemos trabajado con variables individuales que almacenan un único valor. Pero, ¿qué sucede cuando necesitamos manejar múltiples valores relacionados? Por ejemplo, las calificaciones de un estudiante, los precios de varios productos, o los nombres de los días de la semana. Crear variables separadas para cada valor sería tedioso e ineficiente: calificacion1, calificacion2, calificacion3... y así sucesivamente.

Los arrays unidimensionales (también conocidos como arreglos o vectores) son una estructura de datos fundamental que nos permite almacenar múltiples valores del mismo tipo en una sola variable. Imagina un array como una fila de casillas numeradas, donde cada casilla puede contener un valor y podemos acceder a cualquier casilla específica usando su número de posición.

En este artículo exploraremos cómo declarar, inicializar y manipular arrays unidimensionales en C#. Aprenderemos las diferentes formas de crear arrays, cómo acceder a sus elementos, modificarlos, y realizar operaciones comunes como buscar valores, calcular sumas y encontrar el elemento mayor o menor.

¿Qué es un array unidimensional?

Un array unidimensional es una colección ordenada de elementos del mismo tipo de datos, almacenados en posiciones de memoria consecutivas. Cada elemento se identifica por un índice numérico que comienza en 0.

Características principales de los arrays

Característica Descripción
Tipo homogéneo Todos los elementos deben ser del mismo tipo de datos
Tamaño fijo Una vez creado, el tamaño no puede cambiarse
Indexado por números Se accede a los elementos mediante índices numéricos (0, 1, 2, ...)
Almacenamiento continuo Los elementos se almacenan en posiciones consecutivas de memoria
Acceso directo Podemos acceder a cualquier elemento directamente usando su índice

Representación visual de un array

Índices:    [0]  [1]  [2]  [3]  [4]
Valores:    [10] [25] [33] [47] [52]

En este ejemplo, tenemos un array de 5 enteros donde:

  • El elemento en la posición 0 es 10
  • El elemento en la posición 1 es 25
  • El elemento en la posición 4 es 52

Declaración de arrays

En C#, hay varias formas de declarar un array. La sintaxis básica es:

tipo[] nombreArray;

Ejemplos de declaraciones

using System;

class Program
{
    static void Main()
    {
        // Declaración de arrays de diferentes tipos
        int[] numeros;           // Array de enteros
        string[] nombres;        // Array de cadenas
        double[] precios;        // Array de números decimales
        bool[] estados;          // Array de valores booleanos
        char[] letras;           // Array de caracteres
        
        Console.WriteLine("Arrays declarados correctamente");
    }
}

Importante: Declarar un array no significa que ya esté listo para usar. Necesitamos inicializarlo para poder almacenar valores en él.

Inicialización de arrays

Existen varias formas de inicializar un array en C#:

1. Inicialización con tamaño específico

using System;

class Program
{
    static void Main()
    {
        // Crear array con un tamaño específico
        int[] numeros = new int[5];  // Array de 5 enteros (todos inicializados en 0)
        string[] nombres = new string[3];  // Array de 3 strings (todos inicializados en null)
        
        Console.WriteLine($"Tamaño del array de números: {numeros.Length}");
        Console.WriteLine($"Tamaño del array de nombres: {nombres.Length}");
        
        // Mostrar valores por defecto
        Console.WriteLine("Valores por defecto en array de números:");
        for (int i = 0; i < numeros.Length; i++)
        {
            Console.WriteLine($"numeros[{i}] = {numeros[i]}");
        }
    }
}

2. Inicialización con valores específicos

using System;

class Program
{
    static void Main()
    {
        // Inicialización directa con valores
        int[] calificaciones = {85, 92, 78, 96, 88};
        string[] diasSemana = {"Lunes", "Martes", "Miércoles", "Jueves", "Viernes"};
        
        // Forma alternativa de inicialización
        double[] precios = new double[] {12.99, 8.50, 15.75, 22.30};
        
        Console.WriteLine("Calificaciones:");
        for (int i = 0; i < calificaciones.Length; i++)
        {
            Console.WriteLine($"Calificación {i + 1}: {calificaciones[i]}");
        }
        
        Console.WriteLine("\nDías de la semana:");
        for (int i = 0; i < diasSemana.Length; i++)
        {
            Console.WriteLine($"{i + 1}. {diasSemana[i]}");
        }
    }
}

3. Tabla de valores por defecto

Cuando creamos un array sin inicializar sus valores, C# asigna valores por defecto según el tipo:

Tipo de datos Valor por defecto
int, long, short 0
float, double, decimal 0.0
bool false
char '\0' (carácter nulo)
string null
Tipos de referencia null

Acceso a elementos del array

Para acceder a un elemento específico del array, utilizamos la sintaxis de corchetes con el índice:

using System;

class Program
{
    static void Main()
    {
        string[] colores = {"Rojo", "Verde", "Azul", "Amarillo", "Negro"};
        
        // Acceso a elementos individuales
        Console.WriteLine($"Primer color: {colores[0]}");
        Console.WriteLine($"Tercer color: {colores[2]}");
        Console.WriteLine($"Último color: {colores[4]}");
        
        // También podemos usar la propiedad Length para acceder al último elemento
        Console.WriteLine($"Último color (dinámico): {colores[colores.Length - 1]}");
        
        // Modificar elementos
        colores[1] = "Violeta";
        Console.WriteLine($"Segundo color modificado: {colores[1]}");
        
        Console.WriteLine("\nTodos los colores:");
        for (int i = 0; i < colores.Length; i++)
        {
            Console.WriteLine($"Posición {i}: {colores[i]}");
        }
    }
}

Manejo de índices fuera de rango

Es importante recordar que los índices van de 0 a Length - 1. Intentar acceder a un índice fuera de este rango genera una excepción:

using System;

class Program
{
    static void Main()
    {
        int[] numeros = {10, 20, 30};
        
        try
        {
            Console.WriteLine($"Elemento válido: {numeros[1]}");  // OK
            Console.WriteLine($"Elemento inválido: {numeros[5]}");  // IndexOutOfRangeException
        }
        catch (IndexOutOfRangeException ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
            Console.WriteLine("Los índices válidos son de 0 a 2");
        }
    }
}

Propiedades y métodos útiles de arrays

Los arrays en C# tienen propiedades y métodos útiles para trabajar con ellos:

Propiedades principales

Propiedad Descripción
Length Número total de elementos en el array
LongLength Número de elementos como long (para arrays muy grandes)

Métodos estáticos útiles de la clase Array

Método Descripción
Array.Sort() Ordena los elementos del array
Array.Reverse() Invierte el orden de los elementos
Array.IndexOf() Encuentra la primera posición de un valor
Array.LastIndexOf() Encuentra la última posición de un valor
Array.Clear() Establece elementos a sus valores por defecto

Ejemplo de uso de estos métodos:

using System;

class Program
{
    static void Main()
    {
        int[] numeros = {64, 34, 25, 12, 22, 11, 90, 25};
        
        Console.WriteLine("Array original:");
        MostrarArray(numeros);
        
        // Ordenar array
        Array.Sort(numeros);
        Console.WriteLine("\nArray ordenado:");
        MostrarArray(numeros);
        
        // Invertir array
        Array.Reverse(numeros);
        Console.WriteLine("\nArray invertido:");
        MostrarArray(numeros);
        
        // Buscar elementos
        int valorBuscado = 25;
        int posicion = Array.IndexOf(numeros, valorBuscado);
        if (posicion >= 0)
        {
            Console.WriteLine($"\nEl valor {valorBuscado} se encuentra en la posición {posicion}");
        }
        else
        {
            Console.WriteLine($"\nEl valor {valorBuscado} no se encontró en el array");
        }
        
        // Limpiar parte del array
        Array.Clear(numeros, 0, 3);  // Limpiar primeros 3 elementos
        Console.WriteLine("\nArray después de limpiar los primeros 3 elementos:");
        MostrarArray(numeros);
    }
    
    static void MostrarArray(int[] array)
    {
        for (int i = 0; i < array.Length; i++)
        {
            Console.Write($"{array[i]} ");
        }
        Console.WriteLine();
    }
}

Recorrido de arrays

Existen diferentes formas de recorrer un array para acceder a todos sus elementos:

1. Bucle for tradicional

using System;

class Program
{
    static void Main()
    {
        double[] temperaturas = {18.5, 22.3, 19.8, 25.1, 21.7};
        double suma = 0;
        
        Console.WriteLine("Temperaturas registradas:");
        for (int i = 0; i < temperaturas.Length; i++)
        {
            Console.WriteLine($"Día {i + 1}: {temperaturas[i]}°C");
            suma += temperaturas[i];
        }
        
        double promedio = suma / temperaturas.Length;
        Console.WriteLine($"\nTemperatura promedio: {promedio:F1}°C");
    }
}

2. Bucle foreach

using System;

class Program
{
    static void Main()
    {
        string[] frutas = {"Manzana", "Banana", "Naranja", "Uva", "Fresa"};
        
        Console.WriteLine("Lista de frutas:");
        foreach (string fruta in frutas)
        {
            Console.WriteLine($"- {fruta}");
        }
        
        // Contar caracteres totales
        int totalCaracteres = 0;
        foreach (string fruta in frutas)
        {
            totalCaracteres += fruta.Length;
        }
        
        Console.WriteLine($"\nTotal de caracteres: {totalCaracteres}");
    }
}

Diferencias entre for y foreach:

Aspecto for foreach
Acceso al índice Sí, directamente No, solo al valor
Modificación de elementos Sí No (solo lectura)
Sintaxis Más verbosa Más concisa
Uso recomendado Cuando necesitas el índice o modificar Cuando solo necesitas leer

Operaciones comunes con arrays

Buscar el elemento mayor y menor

using System;

class Program
{
    static void Main()
    {
        int[] puntuaciones = {87, 92, 78, 96, 85, 74, 89, 95};
        
        int mayor = puntuaciones[0];
        int menor = puntuaciones[0];
        int indiceMayor = 0;
        int indiceMenor = 0;
        
        for (int i = 1; i < puntuaciones.Length; i++)
        {
            if (puntuaciones[i] > mayor)
            {
                mayor = puntuaciones[i];
                indiceMayor = i;
            }
            
            if (puntuaciones[i] < menor)
            {
                menor = puntuaciones[i];
                indiceMenor = i;
            }
        }
        
        Console.WriteLine("Análisis de puntuaciones:");
        Console.WriteLine($"Puntuación más alta: {mayor} (posición {indiceMayor})");
        Console.WriteLine($"Puntuación más baja: {menor} (posición {indiceMenor})");
        
        // Calcular promedio
        int suma = 0;
        foreach (int puntuacion in puntuaciones)
        {
            suma += puntuacion;
        }
        double promedio = (double)suma / puntuaciones.Length;
        Console.WriteLine($"Promedio: {promedio:F1}");
    }
}

Contar elementos que cumplan una condición

using System;

class Program
{
    static void Main()
    {
        int[] edades = {15, 22, 17, 30, 16, 25, 19, 21, 14, 28};
        
        int mayoresDeEdad = 0;
        int menoresDeEdad = 0;
        
        foreach (int edad in edades)
        {
            if (edad >= 18)
            {
                mayoresDeEdad++;
            }
            else
            {
                menoresDeEdad++;
            }
        }
        
        Console.WriteLine($"Total de personas: {edades.Length}");
        Console.WriteLine($"Mayores de edad: {mayoresDeEdad}");
        Console.WriteLine($"Menores de edad: {menoresDeEdad}");
        
        // Mostrar porcentajes
        double porcentajeMayores = (double)mayoresDeEdad / edades.Length * 100;
        Console.WriteLine($"Porcentaje de mayores de edad: {porcentajeMayores:F1}%");
    }
}

Copiar y comparar arrays

using System;

class Program
{
    static void Main()
    {
        int[] original = {1, 2, 3, 4, 5};
        int[] copia = new int[original.Length];
        
        // Copiar array manualmente
        for (int i = 0; i < original.Length; i++)
        {
            copia[i] = original[i];
        }
        
        // Modificar la copia
        copia[2] = 99;
        
        Console.WriteLine("Array original:");
        MostrarArray(original);
        
        Console.WriteLine("Array copia (modificado):");
        MostrarArray(copia);
        
        // Comparar arrays
        bool sonIguales = CompararArrays(original, copia);
        Console.WriteLine($"¿Los arrays son iguales? {sonIguales}");
        
        // Usar Array.Copy (método más eficiente)
        int[] otraCopia = new int[original.Length];
        Array.Copy(original, otraCopia, original.Length);
        
        Console.WriteLine("\nOtra copia (usando Array.Copy):");
        MostrarArray(otraCopia);
    }
    
    static void MostrarArray(int[] array)
    {
        foreach (int elemento in array)
        {
            Console.Write($"{elemento} ");
        }
        Console.WriteLine();
    }
    
    static bool CompararArrays(int[] array1, int[] array2)
    {
        if (array1.Length != array2.Length)
        {
            return false;
        }
        
        for (int i = 0; i < array1.Length; i++)
        {
            if (array1[i] != array2[i])
            {
                return false;
            }
        }
        
        return true;
    }
}

Ejemplo práctico: Sistema de calificaciones

Vamos a crear un programa completo que gestione las calificaciones de un estudiante:

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("=== SISTEMA DE CALIFICACIONES ===");
        
        Console.Write("¿Cuántas materias tiene el estudiante? ");
        int numeroMaterias = int.Parse(Console.ReadLine());
        
        string[] materias = new string[numeroMaterias];
        double[] calificaciones = new double[numeroMaterias];
        
        // Capturar datos
        for (int i = 0; i < numeroMaterias; i++)
        {
            Console.Write($"Nombre de la materia {i + 1}: ");
            materias[i] = Console.ReadLine();
            
            Console.Write($"Calificación de {materias[i]} (0-10): ");
            calificaciones[i] = double.Parse(Console.ReadLine());
        }
        
        // Mostrar todas las calificaciones
        Console.WriteLine("\n=== REPORTE DE CALIFICACIONES ===");
        for (int i = 0; i < numeroMaterias; i++)
        {
            Console.WriteLine($"{materias[i]}: {calificaciones[i]:F1}");
        }
        
        // Calcular estadísticas
        double suma = 0;
        double mayor = calificaciones[0];
        double menor = calificaciones[0];
        string materiaMayor = materias[0];
        string materiaMenor = materias[0];
        
        for (int i = 0; i < calificaciones.Length; i++)
        {
            suma += calificaciones[i];
            
            if (calificaciones[i] > mayor)
            {
                mayor = calificaciones[i];
                materiaMayor = materias[i];
            }
            
            if (calificaciones[i] < menor)
            {
                menor = calificaciones[i];
                materiaMenor = materias[i];
            }
        }
        
        double promedio = suma / calificaciones.Length;
        
        // Mostrar estadísticas
        Console.WriteLine("\n=== ESTADÍSTICAS ===");
        Console.WriteLine($"Promedio general: {promedio:F2}");
        Console.WriteLine($"Calificación más alta: {mayor:F1} ({materiaMayor})");
        Console.WriteLine($"Calificación más baja: {menor:F1} ({materiaMenor})");
        
        // Determinar estado académico
        string estado;
        if (promedio >= 7.0)
        {
            estado = "APROBADO";
        }
        else if (promedio >= 5.0)
        {
            estado = "EN RIESGO";
        }
        else
        {
            estado = "REPROBADO";
        }
        
        Console.WriteLine($"Estado académico: {estado}");
        
        // Materias por mejorar
        Console.WriteLine("\nMaterias que requieren atención:");
        for (int i = 0; i < calificaciones.Length; i++)
        {
            if (calificaciones[i] < 6.0)
            {
                Console.WriteLine($"- {materias[i]}: {calificaciones[i]:F1}");
            }
        }
    }
}

Resumen

Los arrays unidimensionales son una estructura de datos fundamental en C# que nos permite almacenar y manipular colecciones de elementos del mismo tipo. Hemos aprendido que los arrays tienen un tamaño fijo, se indexan comenzando por 0, y proporcionan acceso directo a cualquier elemento mediante su posición.

Las operaciones básicas incluyen la declaración, inicialización, acceso a elementos, y recorrido usando bucles for y foreach. También exploramos métodos útiles como Array.Sort(), Array.Reverse(), y Array.IndexOf() que facilitan el trabajo con arrays. Las aplicaciones prácticas de los arrays son infinitas: desde almacenar calificaciones hasta manejar inventarios, procesar datos de sensores, o mantener listas de usuarios.

En el próximo artículo exploraremos los arrays multidimensionales, que nos permitirán trabajar con estructuras de datos más complejas como tablas y matrices.

Volver arriba