ARREGLOS EN DOS DIMENSIONES

(MATRICES)
 DESARROLLO

CONCEPTOS DE MATRICES:

 Definición de Matrices:

Son estructuras de datos estáticas encargadas del almacenamiento de datos, se conocen

como arreglos bidimensionales, puesto que define dos índices para el almacenamiento de
información. Al igual que los vectores almacenan datos homogéneos, es decir mismo tipo
de datos, ya sea primitivo o por referencia.

Los datos que se almacena en las matrices serán del mismo tipo, es decir si se declara la
matriz como int los valores que ingresare serán de un único tipo de dato, en este caso
enteros.

Las matrices a diferencia de los vectores que utilizan un solo índice; estas utilizan dos
índices para referencia una posición dentro de la estructura, es decir una matriz posee un
índice para referenciar la fila y otro índice para referencia la columna. El siguiente gráfico
representa una matriz:
 Índices de la matriz:

Los índices de la matriz como en cualquier arreglo inician en 0 para filas y columnas; igualmente
el último elemento será N-1, siendo N el número de filas -1 y el número de columnas -1. Los
índices se manejan de la siguiente forma:

nombre_Matriz [Índice Fila] [Índice Columna]

En Java la primera componente de un arreglo es siempre 0, por lo tanto en la posición

nombre_Matriz [0][0], estará ubicado el primer elemento de la matriz.

 Declaración de una matriz:

Para declarar una matriz se debe indicar el nombre de la misma, así como la cantidad de elementos
que estarán almacenos en cada índice.

Forma 1: Tipo_de_Dato nombreMatriz [ ] [ ];

Forma 2: Tipo_de_Dato [ ] [ ] nombreMatriz;

float matrizNumeros[ ][ ];

int [ ][ ] matrizNumeros;

 Creación de una Matriz:

nombreMatriz = new tipo [numeroFilas] [numeroColumnas];

Ejemplo:

public void crearMatriz() {

nombreMatriz = new int [filas] [columnas];
}
 Asignar datos a una matriz:

El ingreso de datos dentro de una matriz se realiza a partir de una determinada fila y columna, en
donde se asigna un valor específico.

Ejemplo:

nombreMatriz[1][2] = dato;

En la anterior línea de código se asigna a la matriz, en su respectiva fila 1 y columna 2, el

valor de la variable dato.

 Acceder a los datos de una matriz:

El acceso a los datos almacenados dentro de una matriz se realizar a partir de una determinada fila
y columna; es decir, la unión de estos dos valores permiten acceder a un valor dentro de la
estructura.

Ejemplo:

dato = nombreMatriz[1][2];

La anterior línea de código asigna en la variable dato, el valor que tiene la matriz, en su posición:
fila 1 y columna 2.

IMPLEMENTACIÓN DEL CONCEPTO DE MATRICES

 Ejercicio propuesto:

Imaginemos que se desea almacenar en un matriz números enteros, luego de registrar los
datos se requiere realizar las siguientes operaciones sobre los datos de la matriz:

o Mostar los elementos de la diagonal principal

o Determinar la suma y promedio de todos los elementos de la matriz

o Calcular la sumatoria de los elementos de la diagonal principal.

 Diseño de clases UML de la solución

 Implementación de la clase DeclararMatriz en el fichero DeclararMatriz.java

public class DeclararMatriz {

//Se declara una matriz de nombre matrizNumeros para almacenar datos de tipo entero.
private int matrizNumeros [][];
private int filas; //Atributo para asignar el número de filas.
private int columnas; //Atributo para asignar el número de columnas.
public DeclararMatriz() { //Método constructor de la clase.
matrizNumeros = null;
filas = 0;
columnas = 0;
}
//Método modificador para asignar el número de filas que tendrá la matriz.
public void setFilas(int f){
filas=f;
}
//Método selector para obtener el número de filas de la matriz.
public int getFilas(){
return filas;
}
//Método modificador para asignar el número de columnas que tendrá la matriz.
public void setColumnas(int c){
columnas=c;
}
//Método selector para obtener el número de columnas de la matriz.
public int getColumnas(){
return columnas;
}
//Método que muestra la sintaxis de cómo se crea una matriz de nombre matrizNumeros para
//asignar datos de tipo entero.
public void crearMatriz(){
matrizNumeros = new int [filas][columnas];
}

//Método modificador de la matriz para asignar un elemento dentro de la matriz, en una posición
//determinada por una fila y columna especifica.
public void setMatriz(int f, int c, int dato){
matrizNumeros[f][c] = dato;
}

//Método que devuelve un elemento de la matriz, ubicado en una fila y columna especifica.
public int getMatriz(int f, int c){
return matrizNumeros[f][c];
}

//Método que recorre la matriz por filas y suma cada uno de los datos almacenados en la matriz.
public int sumarMatriz(){
int suma = 0;
for(int i=0; i<=getFilas()-1; i++){
for(int j=0; j<=getColumnas()-1; j++){
suma = suma + getMatriz(i,j);
}
}
return suma;
}

Método que recorre la matriz por filas y calcula el promedio de los datos almacenados en la matriz.
public double promedioMatriz(){
double suma = 0;
for(int i=0; i<=getFilas()-1; i++){
for(int j=0; j<=getColumnas()-1; j++){
suma = suma + getMatriz(i,j);
}
}
return suma/(getColumnas()*getFilas());
}

Método que recorre la matriz por filas y suma los elementos de la diagonal principal.
public int sumaDiagonalPrincipal(){
int suma = 0;
for(int i=0; i<=getFilas()-1; i++){
for(int j=0; j<=getColumnas()-1; j++){
if(i==j){
suma = suma + getMatriz(i,j);
}
}
}
return suma;
}
}
 Implementación de la clase Main en el fichero Main.java

public class Main {

//Se implementa el método con el menú de opciones de la aplicación.
public static int menu(){
int opcion = 0;
do{
opcion = Integer.parseInt(JOptionPane.showInputDialog("===== IMPLEMENTACIÓN DE
MATRICES - OPCIONES DEL MENÚ ===== \n\n"+
"1. Guardar datos en la Matriz \n"+"2. Mostrar elementos de la Matriz \n"+
"3. Mostrar diagonal principal \n"+"4. Promedio y suma de los elementos de la Matriz \n"+
"5. Salir"+"\n\n Seleccione una opción del 1 al 5:"));
}while(opcion <= 0 || opcion > 5);
return opcion;
}

//Método que recorre la matriz por filas y muestra todos los elementos de la Matriz.
public static void mostrarMatriz(DeclararMatriz obj){
String datosMatriz="";
for(int i=0; i<=obj.getFilas()-1; i++){
for(int j=0; j<=obj.getColumnas()-1; j++){
datosMatriz = datosMatriz+String.valueOf(obj.getMatriz(i,j)+" ");
}
datosMatriz = datosMatriz+"\n"+"\n";
}
JOptionPane.showMessageDialog(null, "=============== DATOS DE LA MATRIZ
==============="+"\n"+datosMatriz);
}

// Método que recorre la matriz por filas y muestra los elementos de la diagonal principal.
public static void mostrarDiagonalPrincipal(DeclararMatriz obj){
String datosMatriz="";
for(int i=0; i<=obj.getFilas()-1; i++){
for(int j=0; j<=obj.getColumnas()-1; j++){
if(i == j){
datosMatriz = datosMatriz+String.valueOf(obj.getMatriz(i,j)+" ");
}else{
datosMatriz = datosMatriz+String.valueOf("-- ");
}
}
datosMatriz = datosMatriz+"\n"+"\n";
}
JOptionPane.showMessageDialog(null, "=============== DATOS DE LA MATRIZ
==============="+"\n"+datosMatriz);
}
public static void main(String[] args) {
DeclararMatriz obj = new DeclararMatriz();
int opcion;
do{
opcion = menu();
switch(opcion) {
case 1:
int fila, columna;
//Se pide el número de filas que tendrá la matriz.
fila = Integer.parseInt(JOptionPane.showInputDialog("Digite el No. de FILAS de la Matriz:"));
obj.setFilas(fila); // Se pasa como parámetro el número de filas que se quieren asignar.
//Se pide el número de columnas que tendrá la matriz.
columna = Integer.parseInt(JOptionPane.showInputDialog("Digite el No. de COLUMNAS de la
Matriz:"));
//Se pasa como parámetro el número de columnas que se quieren asignar.
obj.setColumnas(columna);
obj.crearMatriz(); // Se crea la matriz.
for (int i=0; i<=obj.getFilas()-1; i++){
for(int j=0; j<=obj.getColumnas()-1; j++){
int dato = Integer.parseInt(JOptionPane.showInputDialog("Digite el elemento de la matriz
en la posicion ["+i+","+j+"]"));
obj.setMatriz(i,j,dato); // Se almacena en una determinada fila y columna el dato.
}
}
break;
case 2:
mostrarMatriz(obj);
break;
case 3:
if (obj.getFilas() == obj.getColumnas()){
mostrarDiagonalPrincipal(obj);
}else{

JOptionPane.showMessageDialog(null,"\n\n==============================================
========="+"\n\n"+
"LA MATRIZ NO ES CUADRADA, NO SE PUEDE MOSTRAR LA DIAGONAL"+
"\n\n=======================================================\n\n");
}
break;
case 4:
JOptionPane.showMessageDialog(null, "========== INFORME ELEMENTOS DE LA
MATRIZ =========="+"\n\n"+
"SUMA: "+obj.sumarMatriz()+"\n\n"+"PROMEDIO: "+obj.promedioMatriz()+"\n\n"+
"SUMA DIAGONAL PRINCIPAL: "+obj.sumaDiagonalPrincipal());
break;
case 5:
break;
}
}while(opcion != 5);
}
}
 EJERCICIOS/ACTIVIDADES

1. Para una matriz NxN determinar la suma de los elementos de la diagonal secundaria,
en una matriz de números enteros. Además mostrar los elementos de diagonal
secundaria.

2. Para el ejercicio propuesto, determinar cuál es el promedio de los elementos del

borde de la matriz.

3. Dada una matriz de NxM, que almacena valores enteros obtener la cantidad de
valores iguales a un valor X dado.

BIBLIOGRAFÍA

 Zahonero, I., y Joyanes Aguilar, L. (1999). Estructura de Datos - Algoritmos, Abstracción y

Objetos. España: McGraw-Hill.

 Allen Weiss, M. (2004). Estructuras de datos en Java. España: Addison Wesley - Pearson.
776 pp.