Capítulo 8. El trabajo de bud. Matrices 2D

Los días se me hacen eternos. Estoy esperando ansioso la visita de Rich, pero está tardando más de lo habitual. Hace diez días que tuve la conversación con el primo de Chani y aún no ha venido a verme. Bud me mantiene entretenido; recientemente me ha presentado a su amigo Pedro. Él también ayuda a los funcionarios de la prisión con el software de seguridad. Es una persona muy introvertida. Apenas habla con nadie y suele pasar gran parte del día con el ordenador. Pienso que, con la personalidad que tiene, es una suerte para él que le dejen pasar tanto tiempo pegado al ordenador.

Sin previo aviso, me informan de que tengo una visita. Espero que sea Rich, pero no lo es. De nuevo es el primo de Chani. Esta vez me comenta que tienen un plan para demostrar mi inocencia. Quieren tender una trampa a Rich. El problema es que, para llevarlo a cabo, necesito estar fuera de la cárcel. La manera más sencilla sería fingir algún tipo de dolencia, como un problema dental, y que así me trasladen a un médico externo.

El problema sería burlar a los policías que supuestamente me escoltarían hasta allí. Si lo consiguiera, supongo que el siguiente paso del plan consistiría en quedar con Rich y tratar de sacarle una confesión.

 

Importancia de las matrices bidimensionales en Java

 

Las matrices bidimensionales en Java nos permiten representar datos en formato de tabla, distribuidos en filas y columnas. También conocidas como arreglos 2D, se puede decir que estas matrices son una evolución de los arrays que vimos en el tema anterior. Los arrays funcionan solo en una dimensión. Las matrices permiten almacenar información en forma de tabla. Esta disposición las hace útiles en muchas aplicaciones.

Al utilizar matrices 2D, es posible estructurar datos de manera más organizada. Además, facilitan el acceso a los elementos a través de índices, lo que agiliza tareas como la manipulación y búsqueda de datos.

Las matrices bidimensionales también son esenciales para implementar algoritmos que requieren una estructura de tabla, como algunos algoritmos de búsqueda y ordenación. Gracias a su versatilidad, se emplean en diversos campos, desde la creación de videojuegos y gráficos hasta simulaciones científicas y análisis de datos.

 

Declaración y Creación de Matrices 2D

 

Para declarar una matriz 2D, debes especificar el tipo de datos que almacenará y su nombre. Básicamente así:

int[][] miMatriz;

Después de declarar la matriz, necesitas crearla, es decir, asignar memoria para ella. Para esto, debes especificar cuántas filas y columnas tendrá. La sintaxis es:

nombreMatriz = new tipoDato[numFilas][numColumnas];

Por ejemplo, para crear una matriz de enteros con 3 filas y 4 columnas:

miMatriz = new int[3][4];

Igual que con los arrays, he empezado explicando paso a paso cómo se declara, después se crea y, por último, se le asigna valor. Creo que es la forma más gráfica de entender cómo funciona la sintaxis de Java. Aunque, en la práctica, lo más sencillo es hacer todo a la vez en una misma línea. Ahorramos código y todo queda mucho más ordenado. Vamos a ver cómo se hace.

 

Declaración, Creación y asignación de valor en una Sola Línea

 

int[][] miMatriz = new int[3][4];

Creo que el ejemplo se explica por sí solo. En la primera parte de la línea, antes del signo igual, declaramos la matriz y la nombramos de la manera que mejor nos parezca. Después del igual, creamos la matriz utilizando new más el tipo de dato y, entre corchetes, asignamos el número de filas y columnas que necesitamos.

 

Acceso a Elementos de una Matriz 2D

 

Para acceder a un elemento específico en una matriz 2D, debes utilizar dos índices: uno para la fila y otro para la columna. La sintaxis básica es:

nombreMatriz[fila][columna]

Imagínate que tienes una matriz llamada “miMatriz” de tamaño 3×3 y quieres acceder al elemento en la segunda fila y tercera columna, Probablemente lo harías así:

int valor = miMatriz[2][3];

Pero te equivocas, recuerda que al igual que pasaba con los arrays, no empezamos desde 1. Sino desde 0. Por lo tanto, para acceder al valor que está en la segunda fila y tercera columna lo haremos así:

int valor = miMatriz[1][2];

Lo podemos ver con otro ejemplo, tenemos dada la siguiente matriz:

int[][] miMatriz = {

{1, 2, 3},

{4, 5, 6},

{7, 8, 9}

};

int valor = miMatriz[1][1]; // 5

Si queremos cambiar el valor 6 a 14 lo haríamos de la siguiente forma:

int miMatriz[1][2] = 14;

 

Inicialización de Matrices 2D

 

–      Puedes inicializar una matriz directamente cuando la declaras, especificando todos sus elementos de antemano:

int[][] miMatriz = {

{1, 2, 3},

{4, 5, 6},

{7, 8, 9}

};

 

–      También puedes declarar una matriz primero y asignar valores a sus elementos después:

int[][] miMatriz = new int[3][3]; miMatriz[0][0] = 1;

miMatriz[0][1] = 2;

miMatriz[0][2] = 3;

miMatriz[1][0] = 4;

miMatriz[1][1] = 5;

miMatriz[1][2] = 6;

miMatriz[2][0] = 7;

miMatriz[2][1] = 8;

miMatriz[2][2] = 9;

 

Recorrer Matrices 2D Usando Bucles

 

Para recorrer los arrays utilizábamos un bucle. En este caso, uno no va a ser suficiente ya que tenemos elementos colocados en filas y columnas. Por lo tanto, vamos a tener que utilizar dos bucles anidados.

Esta sería la estructura que seguiríamos:

 

for (int i = 0; i < miMatriz.length; i++) { // Recorre las filas

    for (int j = 0; j < miMatriz[i].length; j++) { // Recorre las columnas

        System.out.println("Elemento en [" + i + "][" + j + "]: " + miMatriz[i][j]);

    }
}

 

Si empezamos a analizar el código, en la primera línea nos encontramos con miMatriz.length. Eso es básicamente el número de filas que tiene nuestra matriz. Podemos dejarlo escrito así o simplemente escribir el número de filas.

En la siguiente línea, nos encontramos con el segundo bucle. Por lo general, cuando creamos un bucle for, llamamos a la variable «i»; para un segundo bucle, se utiliza la letra «j». Básicamente, lo que hace es, por cada fila de nuestra matriz, recorrer cada columna.

La última línea simplemente nos sirve para imprimir los datos en la pantalla y asegurarnos de que el bucle está siendo recorrido de forma correcta y de que hemos hecho todo bien.

 

Suma de Elementos en una Matriz

 

Ahora que sabemos como se recorren las matrices, vamos con un par de operaciones muy básicas que podemos realizar gracias a los bucles. La primera de ella es la suma de los elementos. La estructura es la siguiente:

int suma = 0;

for (int i = 0; i < miMatriz.length; i++) {
    for (int j = 0; j < miMatriz[i].length; j++) {
        suma += miMatriz[i][j];
    }
}

System.out.println("La suma de todos los elementos es: " + suma);

 

Búsqueda de Elementos Específicos

 

int[][] miMatriz = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

int buscar = 5;
boolean encontrado = false;

for (int i = 0; i < miMatriz.length; i++) {
    for (int j = 0; j < miMatriz[i].length; j++) {
        if (miMatriz[i][j] == buscar) {
            System.out.println("Elemento " + buscar + " encontrado en [" + i + "][" + j + "]");
            encontrado = true;
            break;
        }
    }
    if (encontrado) break;
}

if (!encontrado) {
    System.out.println("Elemento " + buscar + " no encontrado.");
}

 

En la primera parte de este código nos encontramos es con la misma matriz que estábamos utilizando en ejercicios anteriores. Es una matriz declarada y con valores ya asignados. Después de ello, tenemos dos variables. La primera es de tipo int y es el elemento que queremos encontrar. La segunda es de tipo boolean, por defecto será false, pero cuando el programa encuentre el elemento deberemos hacer que cambie a true. Podríamos perfectamente escribir nuestro programa sin necesidad de utilizar esta última variable, pero no siempre hay una oportunidad tan buena para utilizar un boolean en nuestros ejemplos.

Hasta aquí, nada que no supiésemos. Ahora recorremos el bucle utilizando la anidación, tal y como hemos hecho en los ejemplos anteriores. Si te fijas, es exactamente el mismo código y la misma estructura. Lo único que cambia es que hemos añadido un if, y como puedes observar, su funcionamiento es muy sencillo. Si encuentra el elemento que buscamos, nos dirá exactamente en qué posición está y se cerrará el bucle gracias a que hemos añadido un break. Si no lo encuentra, seguirá buscando.

Utilizamos el boolean encontrado para hacer que el programa termine del todo si ya hemos encontrado el elemento deseado o que salga un mensaje final diciendo que el elemento no pudo ser encontrado.

Cabe destacar que cuando se trata de variables tipo boolean y trabajamos en un if, para escribir la condicional podemos hacerlo de la siguiente forma:

If (encontrado == true) {

}

Aunque, lo más correcto es hacerlo de la siguiente forma:

If (encontrado ) {

}

Lo mismo pasa si es false, podemos hacerlo de esta forma:

If (encontrado == false) {

}

Pero es recomendable hacerlo así:

if (!encontrado) {

}

 

Esto se debe a tres motivos:

• Claridad y Legibilidad: Es más claro y conciso escribir if (boolean) que if (boolean == true).

La expresión if (boolean) es más fácil de leer y entender porque está directamente verificando la condición booleana.

• Evitar Errores Comunes: Usar if (boolean == true) introduce la posibilidad de errores tipográficos, como accidentalmente escribir if (boolean = true).

Si escribimos el signo igual con un solo igual, va a traer errores graves en el programa y no funcionará correctamente. Muchas veces detectar este error es bastante difícil así que es mejor ahorrarse la posibilidad de que pueda suceder.

• Convención de Programación: En Java y en muchos otros lenguajes de programación, es una convención y buena práctica utilizar simplemente la variable booleana en una estructura de control, en lugar de compararla explícitamente con true.

Resumen de lo aprendido

 

Las matrices bidimensionales o arrays 2D son estructuras capaces de organizar datos en tablas que se componen de filas y columnas. Esta forma de almacenamiento resulta especialmente útil para los programadores en numerosos escenarios. Esto se debe a que permiten gestionar la información de un modo ordenado y lógico. En una matriz bidimensional, se puede acceder a los elementos de forma sencilla empleando dos índices: uno para las filas y otro para las columnas.

Muchos algoritmos de búsqueda y clasificación utilizan los arrays 2D, ya que gracias a ellos se puede trabajar con conjuntos de datos estructurados en dos dimensiones. Por ejemplo, pueden usarse para representar tableros de juegos, gráficos e incluso bases de datos sencillas, donde la facilidad de acceso y manipulación de los datos resulta esencial.

Pero la cosa no queda ahí; las matrices bidimensionales se caracterizan por su flexibilidad y facilidad de implementación, lo cual las convierte en idóneas para una amplia gama de aplicaciones. Así que, en resumen, los arrays 2D constituyen una herramienta poderosa y versátil que, en algunos casos, simplifica la programación y proporciona soluciones para problemas complejos.