1. Un array es un contenedor de elementos
Probablemente ya has oído que los ordenadores pueden manejar cantidades enormes de información. El operador condicional (if-else) y los bucles (for, while) ayudan, claro. Pero no basta con eso, porque los datos que procesamos hay que guardarlos de alguna manera.
Para eso, en C#, como en casi todos los lenguajes de programación, existe una cosa genial llamada array (Array). También se les llama tablas.
Un array es un objeto especial donde puedes guardar no solo un valor, sino varios.
Si antes comparábamos una variable con una caja (donde puedes guardar algún valor), un array es más bien una caja dividida en secciones. Cada sección en la "caja-array" tiene su número. La numeración, por supuesto, empieza desde cero...
O podemos hacer otra comparación. Imagina una casa normal y un bloque de pisos. Una casa normal la ocupa una familia, pero un bloque de pisos está dividido en apartamentos. Para enviar una carta a una familia que vive en una casa normal, tienes que poner su dirección única. Pero para una familia que vive en un piso, tienes que poner la dirección única de la casa y además el número del piso.
Así que, una variable-array es como una variable-bloque de pisos. Puedes guardar no solo un valor, sino varios. En esa variable hay varios pisos (celdas), y puedes acceder a cada uno por su número (índice).
Para eso, después del nombre de la variable, entre corchetes, tienes que poner el índice de la celda a la que quieres acceder. Es bastante sencillo:
array[índice] = valor;Donde array es el nombre de la variable-array, índice es el número de la celda en el array, y valor es el valor que quieres poner en esa celda.
Pero primero vamos a ver cómo se crean los arrays.
2. Crear un array de elementos en C#
Supón que tu programa necesita guardar 100 números enteros en algún sitio. Lo más probable es que un array sea lo ideal. ¿Y cómo lo creamos?
Si quisiéramos guardar un solo número entero, usaríamos el tipo int, pero si queremos guardar 100 números enteros, seguramente necesitamos un array de tipo int. Así es como se vería el código para crearlo:
int[] array = new int[100];Vamos a ver qué significa esto.
Como ya habrás adivinado, a la izquierda del igual tenemos la declaración de una variable llamada array y de tipo int[]. Después del tipo int van los corchetes, que te dan la pista de que en las "cajas" de este tipo puedes guardar no solo un valor, sino varios.
A la derecha del igual tenemos la "creación del objeto" (la palabra new) de 100 elementos (celdas) de tipo int. Tampoco es tan complicado.
Si, por ejemplo, quisiéramos crear un array de 20 celdas para guardar números decimales, el código sería algo así:
double[] vals = new double[20];El número de celdas en un array se llama tamaño del array o longitud del array. Y por su capacidad de guardar muchos valores, los arrays también se llaman contenedores.
Dato importante: el tamaño del contenedor array no se puede cambiar después de crearlo.
Puedes crear uno nuevo, pero la longitud del contenedor ya creado no se puede cambiar.
3. Trabajar con las celdas del array
Vale, ya sabemos crear arrays, ¿pero cómo trabajamos bien con ellos?
Pues casi igual que con las variables normales, solo que después del nombre de la variable-array tienes que poner el número de la celda con la que trabajas.
La numeración de las celdas del array siempre empieza en cero. Si tenemos un array de 10 elementos, los números (índices) de sus celdas son 0..9, si el array es de 200 elementos, entonces 0..199. Y así sucesivamente.
Ejemplos:
int[] a = new int[10]; // Creamos un array de 10 elementos tipo int.
a[2] = 4; // En la celda con índice 2 guardamos el valor 4.
a[7] = 9; // En la celda con índice 7 guardamos el valor 9.
a[9] = a[2] + a[5]; // En la celda con índice 9 guardamos la suma de los valores que hay en las celdas 2
// (hay 4) y 5 (hay 0).
Esto es lo que habrá en memoria después de ejecutar ese código:
La columna a la izquierda del array (en gris) son los números (índices) de las celdas. En las celdas están los valores que hemos puesto: 4, 9 y 4. Justo después de crear el array, las celdas están llenas de ceros.
Importante. Todas las celdas del array tienen el mismo tipo de datos. Si creamos un array de strings string, solo podemos guardar strings en sus celdas. El tipo de datos del array se define al crearlo. Ni el tipo de datos ni la longitud del array se pueden cambiar después.
4. Arrays en la memoria
Las imágenes de los ejemplos anteriores no son del todo exactas.
Al crear arrays (igual que con los strings), en memoria se reservan dos bloques: uno para guardar el propio array (el contenedor), y otro para la variable que guarda su dirección. La situación real está en la imagen de abajo:
En verde está el array de 10 elementos tipo int y la variable de tipo int[], que guarda la dirección (referencia) del array tipo int en la memoria.
Para comparar, en azul está una variable normal tipo int, que guarda el valor 199.
¿No te recuerda a cómo se guardan los strings en memoria?
Exacto, los strings. Y como con los strings, puedes asignar "variables tipo array" unas a otras:
int[] a = new int[10]; // Creamos un array de 10 elementos tipo int.
a[2] = 4; // En la celda con índice 2 guardamos el valor 4.
a[7] = 9; // En la celda con índice 7 guardamos el valor 9.
int[] b = a; // En la variable b guardamos la dirección que hay en la variable a.
// Ahora a y b apuntan al mismo objeto-array en memoria.
a[9] = b[2] + a[7]; // En la celda con índice 9 del objeto-array guardamos la suma de los valores
// que hay en las celdas 2 (hay 4) y 7 (hay 9).
El objeto-array seguirá estando donde estaba, y las variables a y b guardarán la misma dirección (referencia) al mismo objeto. Mira la imagen:
5. Trabajar con arrays más a fondo
Puedes crear un array de cualquier tipo. Solo tienes que poner corchetes después del nombre del tipo. La forma general de crear un array es así:
tipo[] nombre = new tipo[cantidad];Donde tipo es el tipo de los elementos (celdas) del array que vamos a guardar. nombre es el nombre de la variable con la que vamos a acceder al array, y cantidad es el número de celdas en el array.
En el ejemplo de arriba está la forma canónica: crear la variable-array y crear el objeto-array. En realidad, son dos cosas independientes. Puedes crear la variable-array y el objeto-array por separado:
tipo[] nombre;
nombre = new tipo[cantidad];
Y otro detalle importante
Como índice del array y como cantidad de elementos del array puedes usar variables e incluso expresiones completas.
Ejemplos:
int n = 100;
int[] a = new int[n]; // Creamos un array de n elementos
int n = 100;
int[] a = new int[n * 2 + 3]; // Creamos un array de 203 elementos
int n = 100;
int[] a = new int[n];
a[n-1] = 2; // a[99] = 2;
a[n-2] = 3; // a[98] = 3;
a[n/5] = a[n-1] + a[n-2]; // a[20] = a[99] + a[98];
Salir del límite del array
Por cierto, ojo: si intentas acceder a una celda del array con un índice que no existe (en nuestro caso, cualquier número entero que no sea 0..99), el programa se cerrará con el error IndexOutOfRangeException — índice fuera de los límites del array.
6. Longitud del array
Como vimos en el ejemplo anterior, puedes crear la variable tipo array y luego, en alguna parte del código, asignarle un valor (una referencia al objeto-array). Incluso puedes hacer esto:
int[] array; // Creamos la variable-array tipo int[]
if (a < 10) // Si la variable a es menor que 10,
array = new int[10]; // entonces creamos un array de 10 elementos.
else // Si no
array = new int[20]; // creamos un array de 20 elementos
¿Y cómo trabajamos con ese array? ¿Cómo sabemos cuántos elementos tiene?
Para eso, el array tiene una propiedad especial (variable) — length. Y puedes saber la longitud del array con esta expresión:
array.Length;Donde array es el nombre de la variable-array, y Length es el nombre de la propiedad del objeto-array. El valor de la propiedad Length no se puede cambiar: puedes asignar la propiedad Length a otras variables, pero no puedes asignarle nada a ella (el programa simplemente no compilará).
Así puedes continuar el ejemplo anterior:
int[] array; // Creamos la variable-array tipo int[]
if (a < 10) // Si la variable a es menor que 10,
array = new int[10]; // entonces creamos un array de 10 elementos.
else // Si no
array = new int[20]; // creamos un array de 20 elementos
for (int i = 0; i < array.Length; i++) // Bucle por todos los elementos del array: de 0 hasta array.Length — 1
{
Console.WriteLine(array[i]);
}
7. Hechos sobre los arrays en C#
Vamos a resumir los hechos conocidos sobre los arrays:
- Hecho 1. Un array está formado por muchas celdas.
- Hecho 2. Accedes a una celda concreta indicando su número.
- Hecho 3. Todas las celdas son del mismo tipo.
- Hecho 4. El valor inicial de todas las celdas es 0 y null (si la celda guarda una dirección), false (para el tipo bool).
- Hecho 5. string[] list — esto solo declara la variable: el contenedor (objeto-array) aún no está creado. Para poder usarlo, tienes que crear el array (contenedor) y ponerlo en esa variable, y luego ya lo puedes usar. Mira el ejemplo de abajo.
- Hecho 6. Cuando creamos el objeto-array (contenedor), hay que decir de qué longitud es — cuántas celdas tiene. Se hace así: new TypeName[n];
- Hecho 7. Puedes saber la longitud del array con la propiedad .Length.
- Hecho 8. Después de crear el array, no puedes cambiar ni el tipo de sus elementos ni su cantidad.
string s; // s es igual a null
string[] list; // list es igual a null
list = new string[10]; // La variable list guarda la referencia al objeto – array de strings de 10 elementos.
int n = list.Length; // n es igual a 10
list = new string[0]; // Ahora list contiene un array de 0 elementos.
// El array existe, pero no puede guardar elementos.
list = null;
Console.WriteLine(list[1]); // Se generará un error de programa — el programa se cerrará.
// list contiene una referencia vacía — null
list = new string[10];
Console.WriteLine(list[10]); // Se generará un error — fuera de los límites del array.
// Si list contiene 10 elementos/celdas, los índices permitidos son: 0 1 2 3 4 5 6 7 8 9 — en total 10.
GO TO FULL VERSION