Arreglos con MobileProcessing

En Tipos de datos de MobileProcessing se introdujeron los arreglos (Array) como un tipo de datos compuesto, ahora voy a ampliar brevemente su concepto.

Un arreglo, al igual que en muchos lenguajes de programación, es un objeto que encapsula una serie finita de variables del mismo tipo referenciadas a través de un índice numérico. De esta definición podemos concluir fácilmente las siguientes afirmaciones relacionadas con los arreglos.

  1. Un arreglo agrupa varias variables/objetos.
  2. Todas y cada una de las celdas de un arreglo son de un mismo tipo de datos.
  3. Los arreglos son finitos: limitados en su cantidad de celdas, teniendo en cuenta MP provee funciones para manipular su longitud en tiempo de ejecución.
  4. Las celdas se referencian a través de un índice numérico (entero) utilizando el operador de corchetes ([ ]).

Al igual que los demás objetos, la creación de un arreglo consta de dos partes que se pueden agrupar en una sola línea de código.

// Declaración del arreglo de celdas de tipo 'entero'.
// En este punto arreglo_enteros = null.
int[] arreglo_enteros;
// Creación del objeto arreglo_enteros como un arreglo
// de 25 celdas de tipo entero.  arreglo_enteros != null.
arreglo_enteros = new int[25];

Como se mencionó anteriormente este proceso se puede realizar en una sola línea de código.

int[] arreglo_enteros = new int[25];    // Instrucción equivalente.

Es posible crear arreglos de cualquiera de los tipos de datos que soporta el lenguaje, inclusive de objetos.

String[] arreglo_cadenas = new String[50];

Las celdas del arreglo se pueden acceder de manera directa tanto para lectura como para escritura a través del operador corchetes.

// Modificar el valor de la celda 13.
arreglo_cadenas[13] = "Hola Mundo";
// Obtener el valor de la celda 20.
String cadena = arreglo_cadenas[20];

Como se mencionó los arreglos son objetos, por tal motivo tienen atributos y métodos provenientes de la clase Object. En este momento nos es interesante el atributo length el cual indica siempre la longitud de arreglo, es decir, el número de celdas del mismo.

int longitud1 = arreglo_enteros.length;
// longitud1 = 25.
int longitud2 = arreglo_cadenas.length;
// longitud2 = 50.

Gracias a este atributo es posible recorrer facilmente el arreglo para obtener o modificar sus valores. A continuación se realiza una iteración que recorre una a una las celdas del arreglo y les asigna un valor.

for(int indice=0; indice
{
    arreglo_cadenas[indice] = "Elemento #" + indice;
}

El ciclo anterior hace iterar a la variable indice desde 0 hasta el valor anterior a la longitud del arreglo (arreglo_cadenas.length), aumentando el valor de la variable indice en una unidad (indice++) en cada iteración.

Al final de la ejecución de este código el contenido de las celdas del arreglo arreglo_cadenas será:

["Elemento #0", "Elemento #1", "Elemento #2", ..., "Elemento #49"]

Nótese que los indices de los arreglos empiezan en cero (0) y terminan consecuentemente en la longitud - 1 del arreglo. Es decir, un arreglo de tres elementos tendrá los índices: 0, 1 y 2 respectivamente.

Existe una forma rápida de instanciar arreglos la cual es conveniente cuando se conocen sus valores iniciales.

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

La instrucción anterior crea en arreglo_enteros un arreglo de 5 celdas inicializadas con los valores especificados al lado derecho del igual. Téngase en cuenta que del lado izquierdo a pesar de que no se especificó un tamaño si se especificó que iba a ser un arreglo (int[]). El tamaño del arreglo es determinado finalmente por la cantidad de elementos que se especifiquen al lado derecho de la asignación.

Para conocer mas acerca de las funciones para manipular la longitud de los arreglos consulte las funciones expand() y contract() en Tipos de datos de MobileProcessing.

Las matrices binarias (de dos dimensiones) y n-arias (de n dimensiones) no son mas que construcciones compuestas de arreglos, es decir, son arreglos de arreglos.

Una matriz entera de dos dimensiones puede utilizarse para representar el tablero del juego de Burbujas, donde 0 indica que la celda se encuentra vacía y >0 que se encuentra ocupada, siendo 1 por una burbuja azul, 2 por una verde, 3 por una naranja y 4 por una roja por ejemplo.

Para crear el objeto tablero matriz de dos dimensiones de tipo entero de 15 filas por 10 columnas utilizamos la siguiente instrucción.

int[][] tablero = new int[15][10];

Nótense los elementos adicionales respecto a la creación de arreglos.

  • Se debe indicar que el objeto será matriz de dos dimensiones: int[][]. De manera sucesiva para n-dimensiones.
  • Se deben indicar los tamaños para las dos dimensiones: primero filas (horizontales) y después columnas (verticales). Ejemplo: new int[15][10]; Esto indica que el tablero tendrá 15 filas y 10 columnas. De manera sucesiva para las n-dimensiones.

Para recorrer una matriz bidimencional se utilizan dos ciclos anidados de manera análoga a como se hizo con el arreglo en una única dimensión.

for(int filas=0; filas<15; filas++)
{
    for (int columnas=0; columnas<10; columnas++)
    {
        tablero[filas][columnas] = 0;    // Inicializado como celda vacía.
    }
}

Para acceder a posiciones específicas de la matriz utilice también el operador de corchetes espeficicando la coordenada bidimensional (fila, columna) de la posición a acceder.

// Obtiene información de la burbuja ubicada en la cuarta fila, segunda columna.
int b1 = tablero[3][1]:
// Poner en la posición (6, 3) a una burbuja azul.
tablero[6][3] = 1;

Leave a Reply

Your email address will not be published. Required fields are marked *