El lenguaje de programación iJava (5)

Arrays

Como ya hemos visto, una variable sirve para dar un nombre a un valor y nos permite modificar el valor asociado a dicho nombre durante la ejecución del programa. Un array nos permite asociar un nombre a una lista de valores del mismo tipo. Cada valor se almacenará en una posición de la lista concreta así que para poder referirnos a los distintos valores se utiliza un índice que representará la posición de la lista que ocupa cada valor y que empezará en 0 y acabará en n-1 siendo n el tamaño del array.

Aunque un array es capaz de almacenar muchos valores distintos se considera una única variable que tenemos que declarar para poder utilizarla. Para declarar un array pondremos el tipo que queremos que tengan cada uno de los distintos valores que podrá almacenar el array seguido de una pareja de corchetes y acabando con el nombre de la variable. En el siguiente ejemplo se declara una variable de tipo array de enteros y con nombre tabla

void main() {
	int[] tabla; // Declaración del array
}

Una vez que tenemos creada la variable tabla lo primero que hay que hacer para poder utilizarla es crear el espacio en memoria donde se guardarán los distintos valores. Para eso le asignaremos al array el resultado de utilizaremos la palabra new seguida del tipo que tendrán los valores del array indicando entre corchetes el número de valores que queremos poder manejar en dicho array. El número de valores, es decir, el tamaño que queremos que tenga el array debe ser un número entero

void main() {
	int[] tabla;
	tabla = new int[10]; // Creación del array
}

En el ejemplo anterior, tras declarar la variable tabla para que sea un array de enteros hemos creado espacio suficiente para guardar 10 enteros y ese espacio se lo hemos asignado al array.

Para utilizar cada uno de los valores que contiene un array utilizaremos un índice. En concreto, el nombre de la variable que tiene el array seguido del índice entre corchetes representará el valor que ocupe la posición expresada por el índice. Además, es muy importante tener en cuenta que la primera posición será la 0 por lo que si el array se creó para ser capaz de guardar N valores, la última posición válida será la N-1. Por ejemplo, si tabla es un array de 3 enteros, para guardar el valor 100 en la primera posición y mostrar el valor que ocupe la tercera posición (última posición de este array) haremos lo siguiente:

void main() {
	int[] tabla;
	tabla = new int[3];
	tabla[0] = 100;  // La primera posición es la 0
	println(tabla[2]); 
}

Fíjate bien cómo para acceder a la última posición del array tabla usamos el índice 2. Como tabla tiene tres elementos y el primero ocupa la posición 0, el segundo ocupará la 1 y el tercero la 2.

Se puede realizar la declaración y creación del array en la misma línea igual que cuando creábamos variables de tipo entero o real y directamente les dábamos un valor. Por ejemplo, para declarar y crear un array de enteros llamado tabla con capacidad para 3 enteros podemos hacerlo así:

void main() {
	int[] tabla = new int[3];
}

También es posible declarar, crear y rellenar un array en una única línea. Cuando sabemos todos los valores que queremos que tenga un array podemos escribirlos separados por comas y encerrados entre dos llaves para crear el array completo con dichos valores y asignarlo a la variable que estemos declarando en la misma línea.

void main() {
	// Declaro, creo y relleno al mismo tiempo el array tabla
	int[] tabla = {1,2,3};
	// Muestro el valor que ocupa la segunda posición
	println(tabla[1]);
}

Una vez que un array está creado no se puede modificar su tamaño. Pero sí podemos conocerlo utilizando una función llamada sizeOf. Por ejemplo, el siguiente programa escribe 5 por la pantalla.

void main() {
	int[] tabla;
	tabla = new int[5];
	println(sizeOf(tabla)); 
}

Arrays y Funciones propias

Ya hemos visto que es posible escribir nuestras propias funciones y que, además, podemos ponerles parámetros y hacer que devuelvan un valor. Igual que hemos usado enteros, reales, caracteres, textos o valores de verdad como parámetros o como valor a devolver por la función, también podemos utilizar arrays de cualquiera de estos tipos como parámetro y como valor devuelto por una función.

Para poner como parámetro un array lo único que hay que hacer es declararlo correctamente al especificar el parámetro. Por ejemplo, si queremos hacer una función que muestre por la pantalla todos los enteros incluidos en un array escribiremos lo siguiente:

// Función que muestra el contenido de un array de enteros
void muestra(int[] array) {
	int indice = 0;
	for ( int n = 1 ; n <= sizeOf(array) ; n = n + 1 ) {
		println(array[indice]);
		indice = indice + 1;
	}
}

void main() {
	int[] tabla;
	tabla = new int[3];
	tabla[0] = 30;
	tabla[1] = 20;
	tabla[2] = 10;
	muestra(tabla);
}

A la hora de utilizar nuestra función muestra primero necesitamos contar con un array. En el ejemplo anterior, la función principal del programa, la función main, primero declara el array tabla y, tras crearlo, lo rellena con los valores 30, 20 y 10. Después usa la función muestra pasando como parámetro el array tabla completo para lo que sólo hay que escribir el nombre de la variable que lo contiene.

Fíjate bien en la función muestra. En ella usamos la función sizeOf del array para saber cuántas repeticiones hacer y como dicho número no cambia usamos una estructura for para hacer el bucle.

Para escribir una función propia que devuelva un array como resultado de sus acciones simplemente hay que escribir el tipo de los valores que contendrá el array seguido de una pareja de corchetes y, a continuación, el nombre de la función seguido de la lista de parámetros y el bloque de código.

// Función que crea y rellena un array de enteros
int[] crea(int cantidad) {
	int[] tabla = new int[cantidad];
	int indice = 0;
	for ( int n = 1 ; n <= cantidad ; n = n + 1 ) {
		tabla[indice] = indice*10;
		indice = indice + 1;
	}
	return tabla;
}

// Función que muestra el contenido de un array de enteros
void muestra(int[] array) {
	int indice = 0;
	for ( int n = 1 ; n <= sizeOf(array) ; n = n + 1 ) {
		println(array[indice]);
		indice = indice + 1;
	}
}

void main() {
	int[] mitabla = crea(5);
	muestra(mitabla);
}

En este último programa hemos añadido al anterior la función que crea un array de enteros del tamaño indicado a través de su parámetro cantidad y lo rellena con números. Fíjate como se utiliza una variable local llamada tabla para almacenar el array creado y rellenado y cómo la instrucción return termina la ejecución de la función devolviendo el array creado. En el programa principal (función main) se usa la función y su resultado se almacena en otra variable local a la propia función main, la variable se llama mitabla y, necesariamente tiene el mismo tipo que el devuelto por la función, es decir, es un array de enteros.

Arrays multidimensionales

Los arrays nos permiten manejar más de un valor usando un sólo nombre de variable y un índice. El índice indica la posición a la que nos referimos de entre todas las que almacena la variable. Como hemos dicho anteriormente, podemos considerar que un array es como una lista de valores del mismo tipo. Es decir, los arrays que hemos visto nos permiten representar un conjunto de valores estructurado en una dimensión.

Pero en algunas ocasiones necesitamos representar conjuntos de valores estructurados en más de una dimensión, por ejemplo, si quisiéramos representar un tablero del juego hundir la flota en el que cada casilla se identifica mediante dos coordenadas:horizontales y verticales.

En iJava podemos declarar, crear y utilizar arrays de dos o más dimensiones sin más que añadir más parejas de corchetes en la declaración, creación y uso de los mismos.

// Función que crea y rellena un array bidimensional de enteros
int[][] crea(int filas, int columnas) {
	int[][] tabla = new int[filas][columnas];
	int fila = 0;
	for ( int n = 1 ; n <= filas ; n = n + 1 ) {
		int columna = 0;
		for ( int m = 1 ; m <= columnas ; m = m + 1 ) {
			tabla[fila][columna] = fila*columna;
			columna = columna + 1;
		}
		fila = fila + 1;
	}
	return tabla;
}

// Función que muestra el contenido de un array bidimensional de enteros
void muestra(int[][] matriz) {
	int filas = sizeOf(matriz,1);
	int columnas = sizeOf(matriz,2);
	int fila = 0;
	for ( int n = 1 ; n <= filas ; n = n + 1 ) {
		int columna = 0;
		for ( int m = 1 ; m <= columnas ; m = m + 1 ) {
			print(matriz[fila][columna]);
			print(" ");
			columna = columna + 1;
		}
		println();
		fila = fila + 1;
	}
}

void main() {
	int[][] mitabla = crea(5,10);
	muestra(mitabla);
}

Este programa es una modificación del anterior para utilizar arrays de dos dimensiones. Fíjate que es necesario realizar bucles anidados tanto para rellenarlos como para mostrar su contenido. También es importante destacar que para conocer el tamaño de las diferentes dimensiones en un array multidimensional la función sizeOf permite indicar, ademas del array, la dimensión sobre la que queremos conocer el tamaño. La primera dimensión será la 1, la segunda la 2 y así sucesivamente.

Finalmente, es interesante destacar el uso de la función print para mostrar uno tras otro en el mismo renglón los valores almacenados en la misma fila y, después, cada vez que se cambia de fila, el uso de println sin ningún valor para conseguir el cambio de línea para mostrar los valores de la siguiente fila en el siguiente renglón.

Crear y Rellenar valores de arrays multidimensionales al mismo tiempo

Igual que asignamos valores a un array en su declaración poniéndolos en una lista separada por comas y encerrada entre llaves, también podemos hacerlo cuando el array que estamos declarando tiene varias dimensiones. Lo único que hay que hacer es usar tantas llaves anidadas como dimensiones tengamos.

// Función que muestra el contenido de un array bidimensional de enteros
void muestra(int[][] matriz) {
	int filas = sizeOf(matriz,1);
	int columnas = sizeOf(matriz,2);
	int fila = 0;
	for ( int n = 1 ; n <= filas ; n = n + 1 ) {
		int columna = 0;
		for ( int m = 1 ; m <= columnas ; m = m + 1 ) {
			print(matriz[fila][columna]);
			print(" ");
			columna = columna + 1;
		}
		println();
		fila = fila + 1;
	}
}

void main() {
	int[][] mitabla = {{1,2},{3,4},{5,6}};
	muestra(mitabla);
}

En el ejemplo anterior, el array mitabla se declara para tener dos dimensiones de enteros. Para crearlo y rellenarlo de valores al mismo tiempo ponemos entre dos llaves la lista de arrays de una dimensión que forman cada fila del array de dos dimensiones. Eso sí, todos ellos deben tener el mismo número de valores para que el array de dos dimensiones.

Sigue aprendiendo en El lenguaje de programación iJava (6)