Arrays en C#

En este artículo, exploraremos en detalle cómo trabajar con arrays en C#, abarcando desde conceptos básicos hasta operaciones avanzadas y buenas prácticas.

Al final de este artículo, tendrás una sólida base sobre cómo utilizar y sacar el máximo provecho de los arrays en tus proyectos de C#.

¿Qué es un array en C#?

Un array en C# es una estructura de datos que permite almacenar una colección de elementos del mismo tipo en una única variable.

Estos elementos están organizados de manera secuencial y pueden ser accedidos mediante un índice, que indica su posición dentro del array. El primer elemento del array siempre tiene el índice 0, el segundo tiene el índice 1, y así sucesivamente.

Los arreglos (arrays) en C# son fundamentales en la programación, ya que permiten almacenar y manipular grandes cantidades de información de manera estructurada y eficiente.

Por ejemplo, pueden usarse para almacenar una lista de números enteros, una colección de objetos o incluso otros arrays.

Tipos de arrays en C#

Los vectores o arrays en C# pueden clasificarse en tres categorías principales:

Arrays unidimensionales

Son arrays de una sola dimensión, que se pueden visualizar como una lista o un vector. Pueden almacenar elementos de cualquier tipo (primitivo, objeto o estructura) y se accede a sus elementos utilizando un único índice.

Por ejemplo:


int[] numeros = new int[5]; // Un array de 5 enteros
string[] nombres = new string[3]; // Un array de 3 cadenas

Lenguaje del código: C# (cs)

Arrays multidimensionales

Son arrays que tienen más de una dimensión y pueden visualizarse como una matriz o un cubo. Los arrays multidimensionales también pueden almacenar elementos de cualquier tipo y se accede a sus elementos utilizando múltiples índices, uno por cada dimensión.

Por ejemplo:


int[,] matriz = new int[3, 4]; // Una matriz de 3 filas y 4 columnas
string[,,] cubo = new string[2, 2, 2]; // Un cubo de 2x2x2

Lenguaje del código: C# (cs)

Arrays en forma de estrella (jagged arrays)

Son arrays de arrays, donde cada elemento es a su vez un array unidimensional. Estos arrays permiten crear estructuras de datos irregulares, como matrices de diferentes longitudes. Se accede a sus elementos utilizando dos índices: el primero para el array exterior y el segundo para el array interior.

Por ejemplo:


int[][] matrizIrregular = new int[3][]; // Un array de 3 arrays unidimensionales
matrizIrregular[0] = new int[4]; // El primer array tiene 4 elementos
matrizIrregular[1] = new int[2]; // El segundo array tiene 2 elementos
matrizIrregular[2] = new int[5]; // El tercer array tiene 5 elementos

Lenguaje del código: C# (cs)

En este ejemplo, hemos creado una matriz irregular que contiene tres arrays unidimensionales de diferentes longitudes. El primer array tiene 4 elementos, el segundo tiene 2 elementos y el tercer array tiene 5 elementos.

Declaración, creación de Arrays en C#

Un array en C# se declara especificando el tipo de dato de sus elementos seguido de corchetes vacíos y el nombre del array.

Para crear un array en C#, se utiliza la palabra clave new seguida del tipo de dato y la cantidad de elementos entre corchetes.

Veamos un ejemplo básico:


int[] numeros; // Declaración de un array de enteros
numeros = new int[5]; // Creación de un array de 5 elementos

Lenguaje del código: C# (cs)

Inicialización de Arrays en C#

Existen dos formas de inicializar un array en C#: implícita y explícita.

  • Inicialización implícita:

La inicialización implícita permite asignar los valores directamente en la declaración del array sin especificar su tamaño. El compilador determina automáticamente el tamaño del array según la cantidad de elementos proporcionados.


int[] numeros = {1, 2, 3, 4, 5}; // Inicialización implícita

Lenguaje del código: C# (cs)
  • Inicialización explícita:

En la inicialización explícita, se especifica el tamaño del array y se asignan los valores a cada elemento individualmente. Esto se puede hacer utilizando la notación de corchetes y el índice del elemento.


int[] numeros = new int[5]; // Inicialización explícita
numeros[0] = 1;
numeros[1] = 2;
numeros[2] = 3;
numeros[3] = 4;
numeros[4] = 5;

Lenguaje del código: C# (cs)

Asignación de valores a elementos de un array

Para asignar valores a elementos individuales de un array, se utiliza la notación de corchetes junto con el índice del elemento. Es importante recordar que los índices de los arrays en C# comienzan en 0.

Por ejemplo:


int[] numeros = new int[3];
numeros[0] = 10;
numeros[1] = 20;
numeros[2] = 30;

string[] palabras = {"hola", "mundo"}; // Inicialización implícita
palabras[1] = "C#"; // Modificando el segundo elemento del array

Lenguaje del código: C# (cs)

Arrays de objetos y estructuras personalizadas

Los arrays en C# también pueden contener objetos de clases o estructuras personalizadas. Por ejemplo, si tenemos una clase llamada Persona, podemos crear un array de objetos Persona de la siguiente manera:


class Persona
{
    public string Nombre;
    public int Edad;
}

// Declaración y creación de un array de objetos Persona
Persona[] personas = new Persona[3];

// Inicializando objetos en el array
personas[0] = new Persona {Nombre = "Ana", Edad = 30};
personas[1] = new Persona {Nombre = "Juan", Edad = 25};
personas[2] = new Persona {Nombre = "Laura", Edad = 28};

Lenguaje del código: C# (cs)

Recuerda que, al tratarse de objetos, es necesario inicializar cada elemento del array para evitar errores en tiempo de ejecución al intentar acceder a elementos no inicializados.

Acceder a un elemento de Array en C#

Para acceder a un elemento específico de un arreglo en C#, debes usar el índice del elemento. El índice es un número entero que representa la posición del elemento en el arreglo. Los índices en C# comienzan en cero, lo que significa que el primer elemento tiene un índice de cero.

Para acceder a un elemento de un arreglo en C#, debes usar la siguiente sintaxis:


nombreArreglo[indice]

Lenguaje del código: C# (cs)

Donde nombreArreglo es el nombre del arreglo y indice es el número de índice del elemento que deseas acceder.

Por ejemplo, si tienes un arreglo de nombres de frutas y deseas acceder al segundo elemento, que tiene un índice de 1, puedes usar la siguiente sintaxis:


string[] frutas = { "manzana", "banana", "naranja", "piña", "fresa" };
string segundaFruta = frutas[1]; // "banana"

Lenguaje del código: C# (cs)

En este ejemplo, frutas[1] accede al segundo elemento del arreglo frutas, que es “banana”, y lo almacena en la variable segundaFruta.

Cambiar elementos de un Array en C#

Para modificar un elemento en un arreglo (array) en C#, primero debes acceder al elemento que deseas cambiar, y luego asignarle un nuevo valor. Puedes hacer esto de la siguiente manera:

Supongamos que tenemos un arreglo de enteros llamado numeros con 5 elementos y queremos cambiar el segundo elemento por un nuevo valor:


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

numeros[1] = 25;

Console.WriteLine(numeros[1]); // Imprime: 25

Lenguaje del código: C# (cs)

En este ejemplo, hemos cambiado el valor del segundo elemento (numeros[1]) a 25. Luego, hemos utilizado la función Console.WriteLine para imprimir el nuevo valor del segundo elemento.

Bucle for

Aquí tienes un ejemplo de cómo hacerlo utilizando un bucle for:


using System;

class Program {
    static void Main() {
        int[] numeros = {1, 2, 3, 4, 5};
        Console.WriteLine("Array original:");

        for (int i = 0; i < numeros.Length; i++) {
            Console.WriteLine(numeros[i]);
        }

        // Cambiar elementos del array
        for (int i = 0; i < numeros.Length; i++) {
            numeros[i] = numeros[i] * 2;
        }

        Console.WriteLine("Array modificado:");

        for (int i = 0; i < numeros.Length; i++) {
            Console.WriteLine(numeros[i]);
        }
    }
}

Lenguaje del código: C# (cs)

Este ejemplo multiplica cada elemento del array por 2 y luego muestra el array modificado.

Si deseas realizar cambios más complejos o basados en una condición específica, puedes ajustar el código dentro del bucle for. También puedes utilizar otros métodos de iteración, como un bucle foreach en combinación con un índice, si prefieres ese enfoque.

Cómo recorrer un Array en C#

Existen varias formas de recorrer un arreglo (array) en C#. Aquí te presento algunas de ellas:

Recorrido con bucle for:

Puedes recorrer un vector en C# con un bucle for, utilizando el índice de cada elemento para acceder a ellos.

Por ejemplo:


using System;

class Program {
    static void Main() {
        int[] numeros = {1, 2, 3, 4, 5};

        for (int i = 0; i < numeros.Length; i++) {
            Console.WriteLine(numeros[i]);
        }
    }
}

Lenguaje del código: C# (cs)

Recorrido con foreach:

El bucle foreach es otra forma común de recorrer un arreglo (array). En este caso, no necesitas utilizar un índice para acceder a cada elemento, sino que puedes hacerlo directamente con una variable.

Por ejemplo:


using System;

class Program {
    static void Main() {
        int[] numeros = {1, 2, 3, 4, 5};

        foreach (int numero in numeros) {
            Console.WriteLine(numero);
        }
    }
}

Lenguaje del código: C# (cs)

Recorrido con iteradores de la clase Array:

La clase Array de .NET Framework proporciona varios métodos para recorrer los elementos de un array. Por ejemplo, el método GetEnumerator() devuelve un iterador que permite recorrer el array con un bucle while.

Por ejemplo:


using System;

class Program {
  static void Main() {

    int[] numeros = { 1, 2, 3, 4, 5 };
    IEnumerator enumerador = numeros.GetEnumerator();

    while (enumerador.MoveNext())
    {
      Console.WriteLine(enumerador.Current);
    }

  }
}

Lenguaje del código: C# (cs)

Recorrido con método Array.ForEach():

El método Array.ForEach() es un método estático de la clase Array que toma un array y una acción (representada por un delegado) como argumentos.

La acción se ejecuta para cada elemento en el array. El método Array.ForEach() es útil cuando deseas aplicar una función o acción a cada elemento en el array sin preocuparte por los índices.

Sin embargo, al igual que el bucle foreach, no permite acceder al índice del elemento actual en el array directamente.

Por ejemplo:


using System;

class Program {
    static void Main() {
        int[] numeros = {1, 2, 3, 4, 5};

        Array.ForEach(numeros, numero => Console.WriteLine(numero));
    }
}

Lenguaje del código: C# (cs)

Cada uno de estos métodos tiene sus propias ventajas y desventajas. Por ejemplo, el bucle for te permite acceder a los índices de los elementos, mientras que el bucle foreach y Array.ForEach() son más simples y fáciles de leer, pero no permiten acceder a los índices directamente.

Longitud de un Array en C#

La longitud de un array en C# se refiere al número de elementos que contiene el array. La propiedad Length se utiliza para obtener la longitud de un array, y es de solo lectura.

Esta propiedad es especialmente útil cuando necesitas iterar sobre todos los elementos del array o cuando necesitas realizar operaciones basadas en el tamaño del array.

Por ejemplo:


using System;

class Program {
    static void Main() {

        int[] numeros = { 1, 2, 3, 4, 5 };
        int longitud = numeros.Length;
        Console.WriteLine("La longitud del array es: " + longitud);

    }
}
Lenguaje del código: C# (cs)

En este ejemplo, se crea un array de enteros llamado numeros que contiene los valores del 1 al 5. Luego se obtiene la longitud del array utilizando la propiedad Length y se almacena en la variable longitud.

Finalmente, se muestra la longitud del array en la consola mediante el método WriteLine de la clase Console.

Más ejemplos:

Aquí tienes un ejemplo bien documentado que muestra cómo utilizar la propiedad Length para calcular la longitud de un array y realizar algunas operaciones con ella:


using System;

class Program {
    static void Main() {
        // Declarar e inicializar un array de enteros
        int[] numeros = {1, 2, 3, 4, 5};

        // Obtener la longitud del array utilizando la propiedad Length
        int longitud = numeros.Length;

        // Imprimir la longitud del array en la consola
        Console.WriteLine("La longitud del array es: " + longitud);

        // Calcular e imprimir la suma de los elementos del array
        int suma = 0;
        for (int i = 0; i < numeros.Length; i++) {
            suma += numeros[i];
        }
        Console.WriteLine("La suma de los elementos del array es: " + suma);

        // Calcular e imprimir el promedio de los elementos del array
        double promedio = (double) suma / longitud;
        Console.WriteLine("El promedio de los elementos del array es: " + promedio);
    }
}

Lenguaje del código: C# (cs)

En este ejemplo, primero declaramos e inicializamos un array de enteros llamado numeros. Luego, utilizamos la propiedad Length para obtener la longitud del array y la almacenamos en la variable longitud.

A continuación, utilizamos un bucle for para iterar sobre los elementos del array y calcular la suma de sus valores. Finalmente, dividimos la suma por la longitud del array para calcular el promedio y lo imprimimos en la consola.

La propiedad Length es fundamental en muchas operaciones y algoritmos que involucran arrays en C#, ya que permite recorrer el array de manera segura y evitar errores relacionados con el acceso a índices fuera de los límites del array.

Cómo ordenar un Array en C#

Ordenar un vector (array) en C# es una tarea común en la programación, y hay varias formas de hacerlo. En este caso, me centraré en dos métodos principales: utilizando el método Array.Sort() proporcionado por la clase Array, y ordenando manualmente el array mediante un algoritmo de ordenamiento como el “Bubble Sort”.

A continuación, se describen ambos métodos con ejemplos detallados.

1) Método Array.Sort():

La forma más fácil y rápida de ordenar un array en C# es utilizando el método Array.Sort() proporcionado por la clase Array.

Este método utiliza un algoritmo de ordenamiento eficiente y es apropiado para la mayoría de los casos.

Ejemplo:


using System;

class Program {
    static void Main() {
        int[] numeros = {5, 3, 8, 1, 4};
        Console.WriteLine("Array original:");

        foreach (int numero in numeros) {
            Console.Write(numero + " ");
        }

        // Ordenar el array
        Array.Sort(numeros);

        Console.WriteLine("\nArray ordenado:");

        foreach (int numero in numeros) {
            Console.Write(numero + " ");
        }
    }
}

Lenguaje del código: C# (cs)

Este ejemplo ordena un array de enteros en orden ascendente utilizando Array.Sort(). Si necesitas ordenar en orden descendente, puedes utilizar Array.Reverse() después de Array.Sort().


using System;

class Program {
    static void Main() {
        int[] numeros = {5, 3, 8, 1, 4};
        Console.WriteLine("Array original:");

        foreach (int numero in numeros) {
            Console.Write(numero + " ");
        }

        // Ordenar el array en orden ascendente
        Array.Sort(numeros);

        // Invertir el array para obtener el orden descendente
        Array.Reverse(numeros);

        Console.WriteLine("\nArray ordenado en orden descendente:");

        foreach (int numero in numeros) {
            Console.Write(numero + " ");
        }
    }
}

Lenguaje del código: C# (cs)

En este ejemplo, primero se ordena el array en orden ascendente utilizando Array.Sort(). Luego, se invierte el array utilizando Array.Reverse() para obtener el orden descendente. El resultado final es un array ordenado en orden descendente.

2) Bubble Sort:

Bubble Sort es un algoritmo simple de ordenamiento que compara y cambia elementos adyacentes si están en el orden incorrecto. Aunque no es el algoritmo más eficiente, es fácil de entender e implementar.

Ejemplo:


using System;

class Program {
    static void Main() {
        int[] numeros = {5, 3, 8, 1, 4};
        Console.WriteLine("Array original:");

        foreach (int numero in numeros) {
            Console.Write(numero + " ");
        }

        // Ordenar el array usando Bubble Sort
        for (int i = 0; i < numeros.Length - 1; i++) {
            for (int j = 0; j < numeros.Length - 1 - i; j++) {
                if (numeros[j] > numeros[j + 1]) {
                    // Intercambiar elementos
                    int temp = numeros[j];
                    numeros[j] = numeros[j + 1];
                    numeros[j + 1] = temp;
                }
            }
        }

        Console.WriteLine("\nArray ordenado:");

        foreach (int numero in numeros) {
            Console.Write(numero + " ");
        }
    }
}

Lenguaje del código: C# (cs)

Este ejemplo ordena un array de enteros en orden ascendente utilizando el algoritmo Bubble Sort. Puedes modificar la condición en el bucle interno para cambiar el criterio de ordenamiento (por ejemplo, ordenar en orden descendente).

En general, se recomienda utilizar el método Array.Sort() para ordenar arrays en C#, ya que es más eficiente y fácil de usar que implementar manualmente un algoritmo de ordenamiento.

Sin embargo, conocer y comprender algoritmos de ordenamiento como Bubble Sort puede ser útil para mejorar tus habilidades de programación y aprender cómo funcionan estos algoritmos en un nivel más profundo.

Buscar elementos en un Array

En C#, hay varias formas de buscar elementos en un array. Aquí te muestro tres métodos diferentes: Array.IndexOf(), Array.Find() y Array.Exists().

Método Array.IndexOf()

Este método busca la primera aparición de un elemento específico en un array y devuelve el índice del elemento. Si no se encuentra el elemento, devuelve -1.


using System;

class Program {
    static void Main() {
        int[] numeros = {10, 20, 30, 40, 50};
        
        int elementoABuscar = 30;
        int indice = Array.IndexOf(numeros, elementoABuscar);
        
        if (indice >= 0) {
            Console.WriteLine($"Elemento {elementoABuscar} encontrado en el índice: {indice}");
        } else {
            Console.WriteLine($"Elemento {elementoABuscar} no encontrado.");
        }
    }
}

Lenguaje del código: C# (cs)

Método Array.Find()

Este método busca el primer elemento que cumple con un criterio especificado por un delegado Predicate<T> y devuelve el elemento.

Si no se encuentra ningún elemento que cumpla con el criterio, se devuelve el valor predeterminado del tipo del array (como null para referencias o 0 para números).


using System;

class Program {
    static void Main() {
        int[] numeros = {10, 20, 30, 40, 50};
        
        int elementoEncontrado = Array.Find(numeros, x => x > 20);
        
        if (elementoEncontrado != 0) {
            Console.WriteLine($"Elemento encontrado: {elementoEncontrado}");
        } else {
            Console.WriteLine("Elemento no encontrado.");
        }
    }
}

Lenguaje del código: C# (cs)

Método Array.Exists()

Este método verifica si algún elemento del array cumple con un criterio especificado por un delegado Predicate<T> y devuelve un valor booleano true si existe un elemento que cumpla con el criterio, o false en caso contrario.


using System;

class Program {
    static void Main() {
        int[] numeros = {10, 20, 30, 40, 50};
        
        bool existeElemento = Array.Exists(numeros, x => x > 20);
        
        if (existeElemento) {
            Console.WriteLine("Existe un elemento que cumple con el criterio.");
        } else {
            Console.WriteLine("No existe ningún elemento que cumpla con el criterio.");
        }
    }
}

Lenguaje del código: C# (cs)

Estos métodos son útiles para buscar elementos en un array en función de diferentes criterios. Puedes elegir el método más adecuado según tus necesidades y la situación.

Filtrar, transformar y agregar Arrays en C#

Language Integrated Query (LINQ) es una característica poderosa en C# que te permite trabajar con colecciones de datos de manera eficiente y expresiva. LINQ proporciona una serie de operadores de consulta para filtrar, transformar y agregar datos en arrays y otras colecciones.

A continuación, se describen estos conceptos con ejemplos detallados.

Filtrar elementos de un array:

Filtrar se refiere a seleccionar elementos de una colección que cumplan con una condición específica. La función Where es el operador de filtrado más utilizado en LINQ.


using System;
using System.Linq;

class Program {
    static void Main() {
        int[] numeros = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

        // Filtrar números pares
        var numerosPares = numeros.Where(x => x % 2 == 0);

        Console.WriteLine("Números pares:");
        foreach (var numero in numerosPares) {
            Console.WriteLine(numero);
        }
    }
}

Lenguaje del código: C# (cs)

Transformar elementos de un array:

Transformar se refiere a aplicar una función a cada elemento de la colección y generar una nueva colección con los resultados. La función Select es el operador de transformación más utilizado en LINQ.


using System;
using System.Linq;

class Program {
    static void Main() {
        int[] numeros = {1, 2, 3, 4, 5};

        // Elevar al cuadrado cada número
        var cuadrados = numeros.Select(x => x * x);

        Console.WriteLine("Cuadrados:");
        foreach (var cuadrado in cuadrados) {
            Console.WriteLine(cuadrado);
        }
    }
}

Lenguaje del código: C# (cs)

Agregar elementos de un array:

Agregar se refiere a realizar operaciones en una colección que resulten en un único valor. Algunos ejemplos de agregación incluyen calcular la suma, el promedio, el máximo o el mínimo de una colección. LINQ proporciona operadores de agregación, como Sum, Average, Max y Min.


using System;
using System.Linq;

class Program {
    static void Main() {
        int[] numeros = {1, 2, 3, 4, 5};

        // Calcular la suma, el promedio, el máximo y el mínimo
        int suma = numeros.Sum();
        double promedio = numeros.Average();
        int maximo = numeros.Max();
        int minimo = numeros.Min();

        Console.WriteLine($"Suma: {suma}");
        Console.WriteLine($"Promedio: {promedio}");
        Console.WriteLine($"Máximo: {maximo}");
        Console.WriteLine($"Mínimo: {minimo}");
    }
}

Lenguaje del código: C# (cs)

Es importante mencionar que estos operadores pueden combinarse en consultas más complejas. Por ejemplo, aquí tienes un ejemplo, donde se aplican más operaciones de filtrado, transformación y agregación en una sola consulta:


using System;
using System.Linq;

class Program {
    static void Main() {
        int[] numeros = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

        // Filtrar números pares, elevar al cuadrado y calcular la suma
        int sumaCuadradosPares = numeros.Where(x => x % 2 == 0).Select(x => x * x).Sum();
        Console.WriteLine($"Suma de cuadrados de números pares: {sumaCuadradosPares}");

        // Filtrar números impares, multiplicar por 3 y calcular el promedio
        double promedioImparesTriple = numeros.Where(x => x % 2 != 0).Select(x => x * 3).Average();
        Console.WriteLine($"Promedio del triple de números impares: {promedioImparesTriple}");

        // Filtrar números menores a 6, elevar al cubo y calcular el máximo
        int maximoCubosMenoresSeis = numeros.Where(x => x < 6).Select(x => x * x * x).Max();
        Console.WriteLine($"Máximo de los cubos de números menores a 6: {maximoCubosMenoresSeis}");
    }
}

Lenguaje del código: C# (cs)

Este ejemplo muestra cómo combinar múltiples operadores de LINQ en una sola consulta para realizar operaciones más complejas en arrays. En este caso, se aplican diferentes operaciones a números pares, impares y números menores a 6, utilizando los operadores Where, Select, Sum, Average y Max.

Eliminar un elemento de un Array en C#

En C#, los arrays tienen un tamaño fijo y no se pueden cambiar directamente una vez que se crean. Si deseas eliminar un elemento de un array, en su lugar puedes crear un nuevo array sin el elemento que deseas eliminar.

Una forma de hacer esto es utilizar LINQ y el método Where para filtrar el elemento que deseas eliminar.

A continuación se muestra un ejemplo:


using System;
using System.Linq;

class Program {
    static void Main() {
        int[] numeros = {1, 2, 3, 4, 5};
        int elementoAEliminar = 3;

        // Eliminar el elemento del array
        int[] nuevoArray = numeros.Where(x => x != elementoAEliminar).ToArray();

        // Mostrar el nuevo array
        Console.WriteLine("Nuevo array sin el elemento 3:");
        foreach (int numero in nuevoArray) {
            Console.WriteLine(numero);
        }
    }
}

Lenguaje del código: C# (cs)

En este ejemplo, se crea un nuevo array llamado nuevoArray que contiene todos los elementos de numeros, excepto el elemento con el valor 3.

Ten en cuenta que este enfoque crea un nuevo array y no modifica el array original. Si deseas trabajar con colecciones que permitan agregar o eliminar elementos de manera más flexible, considera usar List<T> en lugar de arrays. La clase List<T> proporciona métodos como Add, Remove y RemoveAt para agregar y eliminar elementos fácilmente.

Referencias

Aquí tienes algunas referencias y recursos útiles para aprender más sobre Arrays en C#:

  1. Documentación oficial de Microsoft:
  2. Tutoriales y guías en línea:

Estas referencias y recursos cubren una amplia gama de temas relacionados con C#, incluidos los Arrays. Te proporcionarán una base sólida para comprender y dominar el uso de Arrays en C#.