Un vistazo avanzado de los Arrays

En esta entrada vamos a ver aspectos intermedios/avanzados de los arrays como son los arrays de objetos y múltiples dimensiones.

Si no estás familiarizado con los arrays o quieres refrescar la memoria tienes disponible de forma gratuita el libro Programación en C#.

Arrays de objetos

Entre los distintos elementos que puede contener un array también se encuentran los objetos.

Para la explicación he creado una clase Persona con dos parámetros, el nombre (string) y la edad (edad).

namespace Blitchet
{
    public class Persona
    {
        private string nombre;
        private int edad;

        public Persona(string nombre, int edad)
        {
            this.nombre = nombre;
            this.edad = edad;
        }

        public string Nombre
        {
            get
            {
                return nombre;
            }
        }

        public int Edad
        {
            get
            {
                return edad;
            }
        }
    }
}

El código anterior tiene un constructor, métodos descriptores de acceso que permiten acceder a las propiedades y establecer valores.

Ahora ya podemos ver cómo trabajar con arrays cuyos elementos son objetos de la clase Persona.

using System;
namespace Blitchet
{
    class MainClass
    {
        public static void Main(string[] args)
        {
            //Se declara un array de tres elementos del objeto Persona.
            Persona[] personas = new Persona[3];

            //Se crean distintos objetos persona.
            personas[0] = new Persona("Paco", 29);
            personas[1] = new Persona("Ana", 25);
            personas[2] = new Persona("Carlos", 30);

            //Se recorren los elementos del array y se muestra por consola un mensaje con los datos.
            for (int i = 0; i < personas.Length; i++)
            {
                Console.WriteLine(personas[i].Nombre + " tiene " <br>                  + personas[i].Edad.ToString() + " años.");
            }
        }
    }
}

En el código anterior se declara un array de 3 elementos, que serán objetos de la clase Persona.

Persona[] personas = new Persona[3];

Cuando los elementos de un array son objetos de una clase que no se corresponde con los tipos básicos de C#, entonces se deben crear dichos objetos.

personas[0] = new Persona("Paco", 29);

Una vez creados los elementos del array podemos acceder a los objetos. Para acceder a un determinado elemento se utiliza el nombre del array indicando su índice. Y como el elemento es un objeto se utiliza el punto para acceder a sus propiedades y métodos.

personas[0].Nombre

Arrays Multidimensionales

Una de las características más potentes de los arrays es que pueden tener más de una dimensión, es decir, que se utiliza más de un índice para identificar elementos.

Lo que permite estructuras de datos más complejas, donde la información de guarda como un conjunto de filas y columnas.

He preparado un ejemplo sencillo para comprobar cómo podemos trabajar con arrays de más de una dimensión.

El ejemplo trata de anotar la puntuación de un jugador que tiene varias jugadas. Por no hacer un ejemplo demasiado largo vamos a tener tres jugadores y cinco jugadas.

Lo primero que podemos observar es que en este ejemplo no es lo más adecuado utilizar un array con una única dimensión.

El tipo del array va a ser string, ya que tenemos que almacenar cadenas de caracteres y números.

using System;
namespace Blitchet
{
    class MainClass
    {
        public static void Main(string[] args)
        {
            //Se declara un array de dos dimensiones.
            int[,] jugadas = new int[3, 5];

            //Se guardan valores aleatorios.
            Random r = new Random();
            for (int i = 0; i < jugadas.GetLength(0); i++)
            {
                for (int j = 0; j < jugadas.GetLength(1); j++)
                {
                    jugadas[i, j] = r.Next(0, 100);
                }
            }

            //Se recorre el array 
            for (int i = 0; i < jugadas.GetLength(0); i++)
            {
                Console.Write("El jugador " + (i + 1) 
                    + " tiene las puntuaciones: ");

                for (int j = 0; j < jugadas.GetLength(1); j++)
                {
                    Console.Write( jugadas[i, j].ToString() + " ");
                }
                Console.WriteLine();
            }
        }
    }
}

Lo primero que se hace es declarar un array de dos dimensiones, es muy parecido al de una sola dimensión, pero se separan las dimensiones por comas.

int[,] jugadas = new int[3, 5];

Cada uno de los valores representa lo elementos que tendrá cada dimensión. En el caso del ejemplo el array tiene en la primera dimensión tres elementos (nº del jugador) y en la segunda cinco elementos (nº de la jugada).

Después se recorren las dos dimensiones del array con dos bucles for, el primer bucle recorre las columnas y el segundo las filas de dicha columna.

Una vez has llegado a la posición deseada se asigna un valor.

jugadas[i, j] = r.Next(0, 100);

De la misma forma, se recorre el array para mostrar el resultado por pantalla.

Console.Write( jugadas[i, j].ToString() + " ");

Principales propiedades

• Length: representa el número total de elementos del array.
• Rank: devuelve el número de dimensiones del array.

Principales métodos

• Find: busca un elemento que coincida con unas condiciones y devuelve la primera coincidencia.
• IndexOf: devuelve el índice de la primera aparición de un valor en un array unidimensional o en una parte de array.
• LastIndexOF: igual que IndexOf pero devuelve la última aparición.
• GetLength: devuelve el número de elementos de una dimensión.
• GetUpperBound: devuelve el límite superior de una dimensión, si la dimensión tiene 5 elementos devuelve el valor 4.
• Reverse: invierte el orden de los elementos de un array unidimensional o de una parte.
• Sort: ordena los elementos en arrays unidimensionales.

Más información en Microsoft Docs.