Cualquier Software independientemente del lenguaje en la cual la estemos desarrollando, requiere manipular un conjunto de datos. Una manera de manejar los datos similares de una manera eficaz es almacenándolos en un arreglo o colección.

Los arreglo también son un conjunto de variables o clases de mismo tipo. Cuando se crean el arreglo se especifica el tamaño del conjunto (cantidad de elementos del arreglo).

Las colecciones proporcionan una manera más flexible de trabajar con grupos de datos (variables o clases). A diferencia de los arreglos, el grupo de datos con el que trabaja puede aumentar y reducirse de manera dinámica a medida que cambian las necesidades de la aplicación. Para algunas colecciones, puede asignar una clave a cualquier objeto que incluya en la colección para, de este modo, recuperar rápidamente el objeto con la clave.

Arreglos son una estructura que almacena una o más datos (variables o clases) del mismo tipo. Puede declarar un arreglos mediante la especificación del tipo de sus elementos. Si quiere que el arreglo almacene elementos de cualquier tipo, puede especificar object como su tipo. Cada uno de estos elementos almacenados se identifica mediante un número al cual se llama índice. Así, para acceder al primer elemento del array habría que usar el índice cero, para el segundo el índice uno, para el tercero el índice dos, y así sucesivamente. La clase Array no se encuentra en el espacio de nombres System.Collections, pero puede considerarse como una colección.

Un arreglo puede ser indefinido el tamaño pero al especificar el tamaño esta utilizando menos recursos en la memoria. Una vez asignado el tamaño no se puede cambiarlo.

tipoDeDato[] nombreDelArreglo = new tipoDeDato[cantidadDeElementos];

• tipoDeDato: El tipo de dato que desea almacenar en el arreglo. Ejemplo: int, string, float, una clase, etc.
• nombreDelArreglo: El nombre del arreglo.
• cantidadDeElementos: Cantidad de elementos que va almacenar en el arreglo.

Podemos agregar información a un arreglo (array) de varias formas, esto dependiendo de la forma declarada.

Sintaxis

    // Declaración de un arreglo de tipo int
    //después asignando el tamaño del arreglo y contenido.
    int[] array1;
    array1 = new int[5] { 1, 3, 5, 7, 9 }

    // Inicializando un arreglo de tipo int especificando el tamaño y su contenido.
    int[] array2 = new int[5] { 1, 3, 5, 7, 9 };

    // Inicializando de un arreglo de tipo int con su contenido pero sin especificar el tamaño.
    int[] array3 = new int[] { 1, 3, 5, 7, 9 };

    // Sintaxis alternativo.
    int[] array4 = { 1, 2, 3, 4, 5, 6 };

Se puede acceder el elemento especifico de un arreglo a través de la posición (numero de índice).

Sintaxis

    int[] numbers = new int[5] { 1, 3, 5, 7, 9 };
   
    int number1 = numbers[0]; //almacenamos en la variable number1 valor del elemento de posición 0, valor 1
    int number2 = numbers[3]; //almacenamos en la variable number2 valor del elemento de posición 3, valor 7

Se puede cambiar el valor de un dato del elemento especifico de un arreglo igualmente a través de la posición (numero de índice).

Sintaxis

    int[] numbers = new int[5] { 1, 3, 5, 7, 9 };
   
    numbers[0] = 10; //el elemento de la posición 0 se cambio de valor 1 a 10
    numbers[3] = 20; //el elemento de la posición 3 se cambio de valor 7 a 20

La propiedad Length de un arreglo de C # se puede utilizar para obtener el número de elementos de un arreglo en particular.

Sintaxis

    int[] numbers = new int[5] { 1, 3, 5, 7, 9 };

    //asigna al variable numberOfElements el valor de la cantidad de elementos del arreglo numbers
    int numberOfElements = numbers.Length;

Se podrá recorrer todos los elementos de un arreglo utilizando Loop (Bucle). Los bucles que se podrá utilizar son los siguientes:

• for
• foreach
• while
• do while

Sintaxis de for

    int[] numbers = new int[5] { 1, 3, 5, 7, 9 };
  
    for(int i = 0; i < numbers.Length; i++)
    {
        Debug.Log(numbers[i].ToString());
    }

Sintaxis de foreach

    int[] numbers = new int[5] { 1, 3, 5, 7, 9 };
  
    foreach(var number in numbers)
    {
        Debug.Log(number.ToString());
    }

Sintaxis de while

    int[] numbers = new int[5] { 1, 3, 5, 7, 9 };
  
    int position = 0;

    while (position < numbers.Length)
    {
        Debug.Log(numbers[position]);
        position++;
    }

Sintaxis de do while

    int[] numbers = new int[5] { 1, 3, 5, 7, 9 };
  
    int position = 0;

    do
    {
        Debug.Log(numbers[position]);
        position++;
    }
    while (position < numbers.Length);

Para recorredor todos los elementos de un arreglo sin una condición para finalizar el bucle se recomienda utilizar el for o foreach.

• Arreglo de una dimensión se conoce como vector.
• Arreglo de dos dimensiones como matriz.
• Arreglo con tres dimensiones conocido como arreglo tridimensional.
• Arreglo con mas de tres dimensiones como arreglo multidimensional.

Los ejemplos que hemos visto previamente, son vectores que serian arreglos unidimensional.

Almacene una única lista de elemento de un tipo de datos similar. Su almacenamiento es horizontal. Representar varios elementos de datos como una lista en fila.

Sintaxis de vector

    int[] numbers = new int[5] { 15, 12, 0, 59, 2 };
  
    Debug.Log(numbers[2]); //imprime 0
    Debug.Log(numbers[4]); //imprime 2

Almacene una "lista de listas" de elemento de un tipo de datos similar. Su almacenamiento es vertical y horizontal. Representa los elementos de datos como una tabla que consta de filas y columnas.

Sintaxis de matriz

    int[,] numbers = new int[3,5] {{ 15, 12, 0, 59, 2 }, 
                                   { 100, 41, 7, 19, 62 },
                                   { 77, 92, 2, 66, 3 }};
  
    Debug.Log(numbers[0,2]); //imprime 0
    Debug.Log(numbers[0,4]); //imprime 2
    Debug.Log(numbers[1,3]); //imprime 19

La lista son una colección de datos (variables o clases) del mismo tipo, como los arreglos, a diferencia de que en una lista es más simple y fácil de trabajar. Por ejemplo podemos añadir y quitar datos fácilmente y cuando desea, también no tiene que crear una Lista con un tamaño específico, se expandirá automáticamente para ajustarse a la cantidad de elementos a medida que los agregue.

List<tipoDeDato> nombreDeLaLista = new List<tipoDeDato>();

• List: List es una palabra reservada para crear una lista.
• tipoDeDato: El tipo de dato que desea almacenar en la lista. Ejemplo: int, string, float, una clase, etc.
• nombreDeLaLista: El nombre de la lista.
• new: new una palabra reservada para instanciar objetos.

Podemos crear una lista de varias formas, esto dependiendo de la forma que desea declarar.

Sintaxis

    // Declaración de una lista de tipo int
    //después asignando el contenido.
    List<int> list1;
    list1 = new List<int>() { 1, 3, 5, 7, 9 };

    // Inicializando una lista de tipo int con su contenido.
    List<int> list2 = new List<int>() { 1, 3, 5, 7, 9 };

    // Inicializando una lista sin contenido.
    List<int> list3 = new List<int>();

Podemos agregar nuevo elemento al final de la lista utilizando Add.

Sintaxis

    List<int> numbers = new List<int>();

    numbers.Add(5);   //Agrego el elemento 5 en la lista
    numbers.Add(24);  //Agrego el elemento 24 en la lista
    numbers.Add(13);  //Agrego el elemento 13 en la lista

Se puede acceder el elemento especifico de una lista como los arreglos a través de la posición (numero de índice). El índice de una lista igual que arreglo empieza desde cero.

Sintaxis

    List<int> numbers = new List<int>() { 1, 3, 5, 7, 9 };

    int number1 = numbers[0]; //almacenamos en la variable number1 valor del elemento de posición 0, valor 1
    int number2 = numbers[3]; //almacenamos en la variable number2 valor del elemento de posición 3, valor 7

Se puede insertar un nuevo elemento en la lista en una posición (índice) especifico utilizando Insert.

Sintaxis

    List<string> personNames = new List<string>();
    personNames.Add("Armando");
    personNames.Add("Kevin");

    personNames.Insert(0, "Mario");

En el sintaxis primero se creo la lista de string llamado personNames después se agrego en la lista el elemento "Armando" y "Kevin" (en este orden). Finalmente se inserto un nuevo elemento "Mario" en la lista en la posición 0 (índice). De esta forma, la lista estaría formada por tres nombres: "Mario", "Armando" y "Kevin" (en este orden).

Se puede eliminar un elemento especifico en la lista utilizando Remove.

Sintaxis

    List<int> numbers = new List<int>() { 1, 3, 5, 7, 9 };

    numbers.Remove(3); //se elimino el elemento 3 de la lista.

    List<string> names = new List<string>() { "Mario", "Armando", " Kevin" };

    names.Remove("Kevin"); //se elimino el elemento Kevin en la lista.

Nota

Si a la función Remove le pasamos un parámetro que no exista en nuestra lista, no ocurre nada.

Si le pasamos un parámetro la cual hay mas de dos elemento de mismo valor. Se eliminara el primero que encuentre. La búsqueda en la lista es ascendente.

Se puede eliminar elemento de una posición especifica en la lista utilizando RemoveAt.

Sintaxis

    List<int> numbers = new List<int>() { 1, 3, 5, 7, 9 };

    numbers.RemoveAt(3); //se elimino el elemento 7 de la lista.

Se puede eliminar todos los elementos de la lista utilizando Clear.

Sintaxis

    List<int> numbers = new List<int>() { 1, 3, 5, 7, 9 };

    numbers.Clear(); //se elimino todos los elementos de la lista.

Se puede obtener la longitud(cantidad de elementos) de la lista utilizando Count.

Sintaxis

    List<int> numbers = new List<int>() { 1, 3, 5, 7, 9 };

    Debug.Log(numbers.Count.ToString());   //Se imprime 5

Se podrá recorrer todos los elementos de un arreglo utilizando Loop (Bucle). Los bucles que se podrá utilizar son los siguientes:

• for
• foreach
• while
• do while

Sintaxis de for

    List<int> numbers = new List<int>() { 1, 3, 5, 7, 9 };

    for(int i = 0; i < numbers.Count; i++)
    {
        Debug.Log(numbers[i].ToString());
    }

Sintaxis de foreach

    List<int> numbers = new List<int>() { 1, 3, 5, 7, 9 };
  
    foreach(var number in numbers)
    {
        Debug.Log(number.ToString());
    }

Sintaxis de while

    List<int> numbers = new List<int>() { 1, 3, 5, 7, 9 };
  
    int position = 0;

    while (position < numbers.Count)
    {
        Debug.Log(numbers[position]);
        position++;
    }

Sintaxis de do while

    List<int> numbers = new List<int>() { 1, 3, 5, 7, 9 };
  
    int position = 0;

    do
    {
        Debug.Log(numbers[position]);
        position++;
    }
    while (position < numbers.Count);

Para recorredor todos los elementos de una lista sin una condición para finalizar el bucle se recomienda utilizar el for o foreach.

El Queue es un tipo especial de colección dinámicas (variables y objetos) que almacena los elementos en estilo FIFO (First In First Out). Se puede tomar el Queue como una fila significa de que el primer elemento que ingresa a la cola es el primer elemento que sale. Para comprender mejor este comportamiento se puede asociar la Queue con una fila en el supermercado para pagar las compras en la caja. El cajero atiende en el orden en que llegan las personas a la cola.

Queue<tipoDeDato> nombreDeLaCola = new Queue<tipoDeDato>();

• Queue: Queue es una palabra reservada para crear una cola.
• tipoDeDato: El tipo de dato que desea almacenar en la cola. Ejemplo: int, string, float, una clase, etc.
• nombreDeLaCola: El nombre de la cola.
• new: new una palabra reservada para instanciar objetos.

Podemos crear una cola declarando de la forma mostrada previamente en Estructura. Se puede agregar nuevos elementos al final de la cola utilizando el método Enqueue(). Y se puede extraer el elemento que se encuentra al principio de la cola utilizando el método Dequeue().

Sintaxis

    // Declaración de una cola de tipo string
    Queue<string> customersWaiting = new Queue<string>();

    // Agregando nuevos elementos a la cola de tipo string
    customersWaiting.Enqueue("Armando Carpa");
    customersWaiting.Enqueue("Erick Manani");
    customersWaiting.Enqueue("Saitama");
    customersWaiting.Enqueue("Alex Russo");

    // Extrayendo el elemento e imprimiendo en la consola
    string personName = customersWaiting.Dequeue();
    Debug.Log(personName);
    personName = customersWaiting.Dequeue();
    Debug.Log(personName);
    personName = customersWaiting.Dequeue();
    Debug.Log(personName);

    // Manera de recorrer toda la cola utilizando while
    /*
    while(customersWaiting.Count > 0)
    {
        Debug.Log(customersWaiting.Dequeue());
    }
    */

Algunos de los otros métodos que tiene Queue:

• Peek: mira el valor de la cabeza pero sin extraer.
• Clear: borra todo el contenido de la cola.
• Contains: indica si un cierto elemento está en la cola.
• GetType: para saber de que tipo son los elementos almacenados en la cola.
• ToString: devuelve el elemento actual convertido en un string.
• ToArray: devuelve toda la cola convertida en un array.
• GetEnumerator: permite usar enumeradores para recorrer la pila.
• Count: indica cuantos elementos contiene.

El Stack es una estructura dinámica de colección(variables y objetos) que almacena los elementos en estilo LIFO (Last Input First Output). Se puede tomar el Stack como una pila de elementos significa de que el ultimo elemento en entrar es el primero en salir. Para comprender mejor este comportamiento se puede asociar el Stack con una pila de platos, al apilar los platos van poniendo el nuevo plato encima del plato anterior. Cuando desea sacar un plato de la pila se saca desde la parte superior, el ultimo plato que se a colocado.

Stack<tipoDeDato> nombreDeLaPila = new Stack<tipoDeDato>();

• Stack: Stack es una palabra reservada para crear una pila.
• tipoDeDato: El tipo de dato que desea almacenar en la pila. Ejemplo: int, string, float, una clase, etc.
• nombreDeLaCola: El nombre de la pila.
• new: new una palabra reservada para instanciar objetos.

Podemos crear una pila declarando de la forma mostrada previamente en Estructura. Se puede agregar nuevos elementos al final de la pila utilizando el método Push(). Y se puede extraer el elemento que se encuentra al final de la pila utilizando el método Pop().

Sintaxis

    // Declaración de una pila de tipo string
    Stack<string> plates = new Stack<string>();
            

    // Agregando nuevos elementos a la pila de tipo string
    plates.Push("Plate 1");
    plates.Push("Plate 2");
    plates.Push("Plate 3");
    plates.Push("Plate 4");

    // Extrayendo el elemento e imprimiendo en la consola
    string plateName = plates.Pop();
    Debug.Log(plateName);
    personName = plates.Pop();
    Debug.Log(plateName);
    personName = plates.Pop();
    Debug.Log(plateName);

    // Manera de recorrer toda la pila utilizando while
    /*
    while(plates.Count > 0)
    {
        Debug.Log(plates.Pop());
    }
    */

Algunos de los otros métodos que tiene Stack:

• Peek: mira el valor de la cabeza pero sin desapilar.
• Clear: borra todo el contenido de la pila.
• Contains: indica si un cierto elemento está en la pila.
• GetType: para saber de que tipo son los elementos almacenados en la pila.
• ToString: devuelve el elemento actual convertido en un string.
• ToArray: devuelve toda la pila convertida en un array.
• GetEnumerator: permite usar enumeradores para recorrer la pila.
• Count: indica cuantos elementos contiene.

El Dictionary es una colección(variables y objetos) que almacena los datos en dos partes: una clave y un valor. Se puede tomar el Dictionary como una lista de elementos donde cada uno de los elementos tendrá un identificador único para poder acceder. Para comprender mejor este comportamiento se puede asociar el Dictionary con unos casilleros enumerados, lo cual se puede entender que el contenido del casillero como valor y el numero del casillero como la clave. Así que al querer encontrar el contenido especifico debe buscar a través del numero del casillero.

Dictionary<tipoDeClave, tipoDeValor> nombreDelDiccionario = new Dictionary<tipoDeClave, tipoDeValor>();

• Dictionary: Dictionary es una palabra reservada para crear un diccionario.
• tipoDeClave: El tipo de dato que desea almacenar en la clave. Ejemplo: int, string, float, una clase, etc.
• tipoDeValor: El tipo de dato que desea almacenar en la valor. Ejemplo: int, string, float, una clase, etc.
• nombreDelDiccionario: El nombre del diccionario.
• new: new una palabra reservada para instanciar objetos.

Podemos crear un diccionario declarando de la forma mostrada previamente en Estructura o también se puede crearlo inicializando. Se puede agregar nuevos elementos al diccionario utilizando el método Add().

Sintaxis

    // Primera forma para crear un diccionario
    // Declaración de un diccionario
    Dictionary<int, string> students = new Dictionary<int, string>();

    // Agregando nuevos elementos en el diccionario
    students.Add(101,"Armando Carpa");
    students.Add(102,"Erick Manani");
    students.Add(103,"Saitama");
    students.Add(104,"Alex Russo");

    // Imprimiendo el valor del elemento especifico a través de la clave
    Debug.Log(students[103]);

    // Segunda forma para crear un diccionario
    // Inicialización de un diccionario
    Dictionary<string, string> countries = new Dictionary<string, string>()
    {
        { "ARG", "Argentina" },
        { "BRA", "Brasil"},
        { "BOL", "Bolivia" },
        { "CHI", "Chile" }
    };

    // Imprimiendo el valor del elemento especifico a través de la clave
    Debug.Log(countries["BOL"]);

Algunos de los otros métodos que tiene Dictionary:

• Add(T): Agrega un elemento al diccionario.
• Add(TKey, TValue): Agrega un elemento a partir de una llave y un valor.
• Contains(T): Comprueba si un elemento existe en la colección.
• Remove(T): Remueve la primera ocurrencia.
• Remove(TKey): Remueve un elemento a través de su llave.