Matrices en Java

Un array en Java puede tener más de una dimensión. El caso más general son los arrays
bidimensionales también llamados matrices o tablas.
La dimensión de un array la determina el número de índices necesarios para acceder a sus
elementos.
Los vectores que hemos visto en otra entrada anterior son arrays unidimensionales porque
solo utilizan un índice para acceder a cada elemento.
Una matriz necesita dos índices para acceder a sus elementos. Gráficamente podemos
representar una matriz como una tabla de n filas y m columnas cuyos elementos son todos del
mismo tipo.
La siguiente figura representa un array M de 3 filas y 5 columnas:

Pero en realidad una matriz en Java es un array de arrays.

Gráficamente podemos representar la disposición real en memoria del array anterior así:

La longitud del array M (M.length) es 3.

La longitud de cada fila del array (M[i].length) es 5.
Para acceder a cada elemento de la matriz se utilizan dos índices. El primero indica la fila y el
segundo la columna.
CREAR MATRICES EN JAVA
Se crean de forma similar a los arrays unidimensionales, añadiendo un índice.
Por ejemplo:
matriz de datos de tipo int llamado ventas de 4 filas y 6 columnas:
int [][] ventas = new int[4][6];
matriz de datos double llamado temperaturas de 3 filas y 4 columnas:
double [][] temperaturas = new double[3][4];
En Java se pueden crear arrays irregulares en los que el número de elementos de cada fila
es variable. Solo es obligatorio indicar el número de filas.
Por ejemplo:
int [][] m = new int[3][];
crea una matriz m de 3 filas.
A cada fila se le puede asignar un número distinto de columnas:
m[0] = new int[3];
m[1] = new int[5];
m[2] = new int[2];
Gráficamente podemos representar la disposición real en memoria del array anterior así:
 INICIALIZAR MATRICES
Un array es un objeto, por lo tanto, cuando se crea, a sus elementos se les asigna
automáticamente un valor inicial:
- 0 para arrays numéricos
- '\u0000' (carácter nulo) para arrays de caracteres
- false para arrays booleanos
- null para arrays de String y de referencias a objetos.
También podemos dar otros valores iniciales al array cuando se crea.
Los valores iniciales se escriben entre llaves separados por comas.
Los valores que se le asignen a cada fila aparecerán a su vez entre llaves separados
por comas.
El número de valores determina el tamaño de la matriz.
Por ejemplo:
int [][] numeros = {{6,7,5}, {3, 8, 4}, {1,0,2}, {9,5,2}};
se crea la matriz numeros de tipo int, de 4 filas y 3 columnas, y se le asignan esos
valores iniciales.
Asignando valores iniciales se pueden crear también matrices irregulares.
int [][] a = {{6,7,5,0,4}, {3, 8, 4}, {1,0,2,7}, {9,5}};
Crea una matriz irregular de 4 filas. La primera de 5 columnas, la segunda de 3, la
tercera de 4 y la cuarta de 2.

RECORRER MATRICES
Para recorrer una matriz se anidan dos bucles for. En general para recorrer un array
multidimensional se anidan tantas instrucciones for como dimensiones tenga el array.
Ejemplo de recorrido de una matriz en Java:
Programa que lee por teclado números enteros y los guarda en una matriz de 5 filas y 4
columnas. A continuación muestra los valores leídos, el mayor y el menor y las posiciones que
ocupan.

import java.util.*;

public class Bidimensional2 {

public static void main(String[] args) {

final int FILAS = 5, COLUMNAS = 4;
Scanner sc = new Scanner(System.in);
int i, j, mayor, menor;
int filaMayor, filaMenor, colMayor, colMenor;
int[][] A = new int[FILAS][COLUMNAS];
System.out.println("Lectura de elementos de la matriz: ");
for (i = 0; i < FILAS; i++) {
for (j = 0; j < COLUMNAS; j++) {
System.out.print("A[" + i + "][" + j + "]= ");
A[i][j] = sc.nextInt();
}
}
System.out.println("valores introducidos:");
for (i = 0; i < A.length; i++) {
for (j = 0; j < A[i].length; j++) {
 System.out.print(A[i][j] + " ");
}
System.out.println();
}
mayor = menor = A[0][0];//se toma el primero como mayor y menor
filaMayor = filaMenor = colMayor = colMenor = 0;

for (i = 0; i < A.length; i++) { //

for (j = 0; j < A[i].length; j++) {
if (A[i][j] > mayor) {
mayor = A[i][j];
filaMayor = i;
colMayor = j;
} else if (A[i][j] < menor) {
menor = A[i][j];
filaMenor = i;
colMenor = j;
}
}
}
System.out.print("Elemento mayor: " + mayor);
System.out.println(" Fila: "+ filaMayor + " Columna: " + colMayor);
System.out.print("Elemento menor: " + menor);
System.out.println(" Fila: "+ filaMenor + " Columna: " + colMenor);
}
}

En este ejemplo se han utilizado dos formas distintas para recorrer la matriz:
- utilizando en el for el número de filas y columnas
- utilizando en el for el atributo length
Para recorrer arrays irregulares como el siguiente:
int [][] a = {{6,7,5,0,4}, {3, 8, 4}, {1,0,2,7}, {9,5}};

Usaremos siempre length para obtener el número de columnas que tiene cada fila:

for (i = 0; i < a.length; i++) { //número de filas

for (j = 0; j < a[i].length; j++) { //número de columnas de cada fila
System.out.print(a[i][j] + " ");
}
System.out.println();
}

ARRAYS (ARREGLOS) MULTIDIMENSIONALES

Vamos a realizar un repaso sobre conocimientos que debemos tener relativos a arrays multidimensionales.
En Java es posible crear arrays con más de una dimensión, pasando de la idea de lista, vector o matriz de
una sola fila a la idea de matriz de m x n elementos, estructuras tridimensionales, tetradimensionales, etc.
La sintaxis será:
Tipo_de_variable[ ][ ]… [ ] Nombre_del_array = new Tipo_de_variable[dimensión1][dimensión2]…[dimensiónN];

También podemos alternativamente usar esta declaración:

Tipo_de_variable[ ][ ] … [ ] Nombre_del_array;
Nombre_del_array = new Tipo_de_variable[dimensión1][dimensión2]…[dimensiónN];

El tipo de variable puede ser cualquiera de los admitidos por Java y que ya ha sido explicado. Ejemplos de
declaración e inicialización con valores por defecto de arrays, usando los distintos tipos de variables Java,
serían:

- byte[][] edad = new byte[4][3];

- short ][] edad = new short[4][3];

- int[][] edad = new int[4][3];

- long[][] edad = new long[4][3];

- float[][] estatura = new float[3][2];

- double[][] estatura = new double[3][2];

- boolean[][] estado = new boolean[5][4];

- char[][] sexo = new char[2][1];

 - String[][] nombre = new String[2][1];

La declaración de una matriz tradicional de m x n elementos podría ser:

/* Ejemplo declaración - aprenderaprogramar.com */

int[][] matriz = new int[3][2];
O alternativamente
int[][] matriz;
matriz = new int[3][2];

El número de elementos sería: 3 x 2 = 6, dónde 3 es el número de filas y 2 es el número de columnas.

Ahora procedemos a cargar la matriz con valores:

matriz[0][0] = 1; matriz[0][1] = 2; matriz[1][0] = 3; matriz[1][1] = 4; matriz[2][0] = 5; matriz[2][1] = 6;

Hay que recordar que los elementos empiezan a numerarse por 0. Así, la esquina superior izquierda de la
matriz será el elemento [0][0] y la esquina inferior derecha será el [2][1]. Hay que prestar atención a esto
porque en otros lenguajes de programación la numeración puede empezar por 1 en vez de por 0.

También se pueden cargar directamente los elementos, durante la declaración de la matriz de la siguiente
manera:

int[][] matriz = {{1,2},{3,4},{5,6}};

donde {1,2} corresponde a la fila 1, {3,4} a la fila 2 y {5,6} a la fila 3, y los números separados por coma
dentro de cada fila, corresponden a las columnas. En este caso, los números (1, 3, 5) de cada una de las
filas corresponden a la primera columna y los números (2, 4, 6) atañen a la segunda columna.

Para obtener el número de filas de la matriz, podemos recurrir a la propiedad “length” de los arrays, de la
siguiente manera:

int filas = matriz.length;

Para el caso del número de columnas sería de la siguiente forma :

int columnas = matriz[0].length;

También Java nos permite la posibilidad de clonar una matriz, es decir, crear una matriz nueva a partir de
otra matriz, siguiendo esta sintaxis:

String[][] nuevaMatriz = matriz.clone();

donde clone() es un método especial, que permite la clonación de arrays de cualquier dimensión en Java.
De esta manera “nuevaMatriz” y “matriz” son 2 matrices distintas pero con los mismos valores. Hablaremos
del método clone más adelante.

EJERCICIO RESUELTO

Vamos a plantear y resolver un ejercicio: queremos almacenar en una matriz el número de alumnos con el
que cuenta una academia, ordenados en función del nivel y del idioma que se estudia. Tendremos 3 filas
que representarán al Nivel básico, medio y de perfeccionamiento y 4 columnas en las que figurarán los
idiomas (0 = Inglés, 1 = Francés, 2 = Alemán y 3 = Ruso). Se pide realizar la declaración de la matriz y
asignarle unos valores de ejemplo a cada elemento.

SOLUCIÓN

La declaración de la matriz sería:

/* Ejemplo declaración - aprenderaprogramar.com */

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

Podríamos asignar contenidos de la siguiente manera:

 alumnosfxniveleidioma[0][0] = 7; alumnosfxniveleidioma[0][1] = 14;

alumnosfxniveleidioma[0][2]= 8; alumnosfxniveleidioma[0][3] = 3;

alumnosfxniveleidioma[1][0] = 6; alumnosfxniveleidioma[1][1]= 19;

alumnosfxniveleidioma[1][2] = 7; alumnosfxniveleidioma[1][3] = 2

alumnosfxniveleidioma[2][0] = 3; alumnosfxniveleidioma[2][1]= 13;

alumnosfxniveleidioma[2][2] = 4; alumnosfxniveleidioma[2][3] = 1

También, podríamos asignar contenido de esta otra forma, como ya se ha explicado anteriormente:

int[][] alumnosfxniveleidioma = {{7,14,8,3},{6,19,7,2},{3,13,4,1}};

La representación gráfica que podríamos asociar a esta asignación de datos sería esta matriz:

La organización de la información en matrices, nos generará importantes ventajas a la hora del tratamiento
de datos en nuestros programas.

Para terminar en cuanto a multidimensionalidad, veamos casos de declaraciones con más

de dos dimensiones. Para ello supongamos que estamos realizando un “conteo de
coches”, es decir, que estamos contando los coches que pasan por un determinado lugar
en un periodo de tiempo que puede ser un día, varios días, varios meses, etc. La forma de
declarar esos arrays podría ser la siguiente:

Declaración con Java

Duración del conteo Tipo de array
(nc es Número de coches)
 Array de una dimensión
Un día int[] nc = new int[24];
(hora)

Array de dos dimensiones

Varios días int[][] nc = new int[24][31];
(hora y día)

Array de tres dimensiones

Varios meses int[][][] nc = new int[24][31][12];
(hora, día y mes)

Array de cuatro dimensiones

Varios años Int[][][][] nc = new int[24][31][12][2999];
(hora, día, mes y año)

Array de cinco dimensiones

Varios siglos Int[][][][][] nc = new int[24][31][12][2999][21];
(hora, día, mes, año y siglo)

Veamos lo que sería un ejemplo de programa con array multidimensional, usando un tipo String.

/* Ejercicio Array multidimensional – aprenderaprogramar.com */

public class MatrizAlumnos {
public static void main(String arg[]) {
String[ ][ ] nombreAlumno = new String[5][25];
nombreAlumno[2][23] = “Pedro Hernández González”;
System.out.println(“El alumno número 24 del curso tercero se llama “+nombreAlumno[2][23]);
}
}

El resultado del programa es la aparición del mensaje “El alumno número 24 del curso tercero se llama
Pedro Hernández González.

En este ejemplo, [5] representa a los cursos. Hablamos de 5 cursos que son identificados con 0, 1, 2, 3, 4,
por lo que [2] hace mención al tercer curso;lo mismo podemos decir de [23], que corresponde al alumno
número 24. Hay que recordar que siempre en Java tenemos que contar el cero, ya que si no lo hacemos
podemos cometer errores.

EJERCICIO
Crea un programa que pida por pantalla cuatro países y a continuación tres ciudades de cada uno de estos
países. Los nombres de ciudades deben almacenarse en un array multidimensional cuyo primer índice sea el
número asignado a cada país y el segundo índice el número asignado a cada ciudad.

Ejemplo de resultados que debe mostrar el programa:

País: Argentina Ciudades: Buenos Aires Cordoba La Plata

País: España Ciudades: Madrid Lugo Sevilla

País: Francia Ciudades: Paris Niza Lyon

País: Italia Ciudades: Roma Napoles Sicilia

Para comprobar si es correcta tu solución puedes consultar en los foros aprenderaprogramar.com.

Tutorial 10 Java: Matrices

Hola a todos y, bienvenidos a un nuevo tutorial de Java. Hoy vamos a

aprender a utilizar matrices en Java. No voy a realizar un tutorial muy
extenso porque el uso que les vamos a dar y el tratamiento que recibirán es
exactamente el mismo que el de los vectores. Una matriz es un conjunto de
variables (también llamado bloque) cuyo índice se realiza por índice o líneas.
 En este tutorial,
vamos a introducir una matriz de las dimensiones que queramos para
introducir números enteros en ella. Los primero que haremos, será crear un
objeto llamado reader, de la clase Scanner, para introducir los números por
teclado. También declararemos la matriz, que podéis ver que se declara
exactamente igual que un vector. Además, definiremos las variables enteras
que corresponden al número de filas y de columnas, para que el usuario
pueda escoger las dimensiones de la matriz. El primer método que
crearemos servirá para definir las dimensiones de la matriz:
public void definir_dimension_matriz() {
reader=new Scanner(System.in);
System.out.print("Introduzca el número de filas: ");
filas=reader.nextInt();
System.out.print("Introduzca el número de columnas: ");
columnas=reader.nextInt();
System.out.println("Ha creado una matriz "+filas+"x"+columnas+".");
}

El siguiente método lo utilizaremos para introducir los valores de la matriz:

public void introducir_numeros() {
reader=new Scanner(System.in);
matriz=new int[filas][columnas];
for(int j=0; j<filas; j++){
for(int i=0; i<columnas; i++){
System.out.print("Introduzca la componente ("+j+", "+i+"): ");
matriz[j][i]=reader.nextInt();
}
}
}

El tercer y último método, nos mostrará los datos introducidos por pantalla:
public void mostrar_matriz() {
System.out.println("La matriz es: ");
for(int j=0; j<filas; j++){
for(int i=0; i<columnas; i++){
System.out.print(matriz[j][i]+" ");
}
System.out.println();
}
}

Para finalizar, en el main pondremos lo siguiente:

public static void main(String[] args) {
Matrices matriz=new Matrices();
matriz.definir_dimension_matriz();
matriz.introducir_numeros();
matriz.mostrar_matriz();
}

El resultado será el siguiente:

Esto es todo. Si tenéis alguna duda dejad un comentario y la resolveré. No he

especificado mucho en este tutorial porque, como ya he dicho, es igual que
los vectores. ¡Nos vemos en el siguiente tutorial"
La clase Matriz y la clase Vector

En esta página, definiremos la clase Vector y la clase Matriz cuadrada, las operaciones
entre matrices, suma y producto de dos matrices, el producto de una matriz por un vector,
el producto de una matriz por un escalar, la traza de una matriz y la matriz traspuesta de
una matriz dada.

Vectores y matrices
Un vector es un array unidimensional de números. Se define la clase Vector con dos
miembros dato, el número de datos que guarda y el array unidimensional que guarda
dichos datos.

public class Vector {

public int n;
double[] x;

La clase Vector y la clase Matriz están en el mismo paquete. El miembro dato x de la

clase Vector tiene el control de acceso por defecto, es decir, público dentro del mismo
paquete pero privados fuera del paquete. Más abajo, en esta página al definir las
funciones miembro de la clase Matriz que realizan operaciones entre matrices y vectores
veremos que, los objetos de la clase Vector necesitan acceder a su miembro dato x.

Una matriz es un array bidimensional de números. En general, decimos que una matriz
tiene una dimensión m x n, cuando los números están dispuestos en m filas y n columnas.

Se denominan matrices cuadradas a aquellas que tienen el mismo número de filas que de
columnas. Estas matrices tienen especial importancia y serán las que tratemos en estas
páginas.

public class Matriz{

public int n;
private double[][] x;

La clase Matriz tiene dos miembros dato, la dimensión de la matriz n, y un array

bidimensional x, que crearemos e inicializaremos en los constructores.

Los constructores
Vamos a definir dos constructores en la clase Vector, al primero se le pasa el número de
elementos que va a guardar e inicializan a cero todos sus elementos.
 public Vector(int n) {
this.n=n;
x=new double[n];
for(int i=0; i<n; i++){
x[i]=0.0;
}
}

Para crear un vector v de dimensión tres se escribe

Vector v=new Vector(3);

Al segundo constructor, se le pasa el array unidiemensional, e inicializa el miembro dato

x con los valores que guardan los elementos de dicho array en una única y simple
operación de asignación

public Vector(double[] x) {
this.x=x;
n=x.length;
}

Para crear un vector v que guarde los datos del array v1 se escribe

double[] v1={1, 2, 3};

Vector v=new Vector(v1);

Para la clase Matriz necesitamos definir dos constructores, al primero se le pasa la

dimensión n de la matriz cuadrada, creando un array bidimensional de n filas y n
columnas, e inicializa todos sus elementos a cero.

public Matriz(int n) {
this.n=n;
x=new double[n][n];
for(int i=0; i<n; i++){
for(int j=0; j<n; j++){
x[i][j]=0.0;
}
}
 }

Para crear una matriz a de dimensión tres cuyos elementos son todos ceros, se escribe.

Matriz a=new Matriz(3);

Al segundo constructor, se le pasa un array bidimensional, e inicializa el miembro dato x

con los valores que guardan los elementos de dicho array en una única y simple
operación de asignación.

public Matriz(double[][] x) {
this.x=x;
n=x.length;
}

Para crear la matriz a

se crea un array bidimensional a1, y se le pasa al constructor de la clase Matriz

double[][] a1={{1, 2, 3},{-2, -4, -5},{3, 5, 6}};

Matriz a=new Matriz(a1);

public class Vector {

public int n; //dimensión
double[] x;
public Vector(int n) {
this.n=n;
x=new double[n];
for(int i=0; i<n; i++){
x[i]=0.0;
}
}
public Vector(double[] x) {
 this.x=x;
n=x.length;
}
//otras funciones miembro
}
****************************************
public class Matriz{
public int n; //dimensión
private double[][] x;
public Matriz(int n) {
this.n=n;
x=new double[n][n];
for(int i=0; i<n; i++){
for(int j=0; j<n; j++){
x[i][j]=0.0;
}
}
}
public Matriz(double[][] x) {
this.x=x;
n=x.length;
}
//otras funciones miembro
}

Mostrar un vector y una matriz

Para mostrar un vector redefinimos la función toString de la clase base Object, de la cual
deriva implícitamente Vector. Separamos sus elementos mediante el carácter tabulador '\t'.

public String toString(){

String texto=" ";
for(int i=0; i<n; i++){
 texto+="\t "+(double)Math.round(1000*x[i])/1000;
}
texto+="\n";
return texto;
}

Vamos añadiendo al string texto, los elementos del vector y el carácter separador entre
elementos, limitamos el número de decimales a tres mediante la función Math.round.
Para concluir la fila y pasar a la siguiente en la pantalla de texto, añadimos un carácter
retorno de carro '\n'. Mediante la operación + definida en la clase String podemos
concatenar fácilmente los distintos elementos y crear la representación textual del vector
que devuelve la función toString

Para mostrar el vector v en la pantalla de texto, basta escribir la sentencia

Vector v=new Vector(v1);

System.out.println(v);

Mostrar una matriz en la pantalla de texto es difícil, ya que Java no dispone de una
función que sitúe el cursor de texto en una posición de la pantalla, como lo hace la
función gotoxy disponible en los lenguajes C/C++. La única alternativa que nos queda es
mostrar los elementos de una fila unos a continuación de los otros separados por un
tabulador, después otra fila y así hasta mostrar todos los elementos de la matriz.

Para mostrar los elementos de la matriz, redefinimos la función toString de la clase base
Object, de la cual deriva implícitamente Matriz. Separamos los elementos de una fila
mediante el carácter tabulador '\t', y limitamos el número de decimales a tres mediante la
función Math.round. Cuando se acaba una fila se inserta un retorno de carro '\n' y se
continua con la siguiente fila, y así sucesivamente.

for(int j=0; j<n; j++){

texto+="\t "+(double)Math.round(1000*x[i][j])/1000;
}
texto+="\n";

Vamos añadiendo al string texto, los elementos de la matriz y los caracteres separadores
entre elementos y entre filas de elementos.

public String toString(){

String texto="\n";
for(int i=0; i<n; i++){
 for(int j=0; j<n; j++){
texto+="\t "+(double)Math.round(1000*x[i][j])/1000;
}
texto+="\n";
}
texto+="\n";
return texto;
}

Para mostrar una matriz a en la pantalla de texto basta escribir la sentencia

Matriz a=new Matriz(a1);

System.out.println(a);

public class Vector {

public int n; //dimensión
double[] x;
//...
public String toString(){
String texto=" ";
for(int i=0; i<n; i++){
texto+="\t "+(double)Math.round(1000*x[i])/1000;
}
texto+="\n";
return texto;
}
}
****************************
public class Matriz{
public int n; //dimensión
private double[][] x;
//...
 public String toString(){
String texto="\n";
for(int i=0; i<n; i++){
for(int j=0; j<n; j++){
texto+="\t "+(double)Math.round(1000*x[i][j])/1000;
}
texto+="\n";
}
texto+="\n";
return texto;
}
}

Copia de una matriz dada

Cuando calculamos la matriz inversa de una dada, pasamos una matriz en el único
parámetro de la función estática denominada inversa. En el cuerpo de dicha función se
realizan operaciones con los elementos de dicha matriz. Dado que en Java se pasan por
valor las referencias a objetos, la matriz original resulta modificada en el curso de la
llamada a la función inversa.

Si queremos mantener la matriz original, hacemos una copia de dicha matriz en el cuerpo
de la función y realizamos las operaciones con la matriz copia dejando la original sin
modificar.

Para realizar una copia hemos de implementar el interface Cloneable, y redefinir la

función miembro clone de la clase base Object, de la cual derivan todas las clases en
Java. El primer paso es la llamada a la función clone de la clase base Object.

public class Matriz implements Cloneable{

public int n; //dimensión
private double[][] x;
//..........
public Object clone(){
Matriz obj=null;
 try{
//llama a clone de la clase base Object
obj=(Matriz)super.clone();
}catch(CloneNotSupportedException ex){
System.out.println(" no se puede duplicar");
}
//copia la matriz bidimensional
obj.x=(double[][])obj.x.clone();
for(int i=0; i<obj.x.length; i++){
obj.x[i]=(double[])obj.x[i].clone();
}
return obj;
}
}

Para obtener una copia a de una matriz d se escribe.

Matriz a=(Matriz)d.clone();

La promoción (casting) es necesaria ya que clone devuelve una referencia a un objeto de

la clase base Object.

Traza de una matriz

Se denomina traza de una matriz cuadrada a la suma de los elementos de su diagonal
principal.

public double traza(){

double tr=0.0;
for(int i=0; i<n; i++){
tr+=x[i][i];
}
return tr;
}
Para obtener la traza de la matriz a de la sección anterior se escribe

double traza=a.traza();

Operaciones con matrices y vectores

Suma de dos matrices cuadradas
Cuando se suman dos matrices de las mismas dimensiones

Se obtiene otra matriz c en la que sus elementos cij son las suma de los correspondientes
elementos de las matrices a y b, es decir

cij=aij+bij

Para sumar dos matrices, se define una función miembro estática denominada suma.
Dentro de la función, se crea una matriz temporal resultado, con la misma dimensión de
las matrices que intervienen en la operación, y se guardan en sus elementos el resultado
de la suma de las matrices a y b. Finalmente, la función suma devuelve la matriz
resultado.

public static Matriz suma(Matriz a, Matriz b){

Matriz resultado=new Matriz(a.n);
for(int i=0; i<a.n; i++){
for(int j=0; j<a.n; j++){
resultado.x[i][j]=a.x[i][j]+b.x[i][j];
}
}
return resultado;
}

Veamos ahora como se llama a la función que suma dos matrices.

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

Matriz a=new Matriz(a1);
 double[][] b1={{1, 0, -1},{2,1,3},{-1, 0, 2}};
Matriz b=new Matriz(b1);
Matriz re=Matriz.suma(a, b);
System.out.println("matriz "+re);

Producto de dos matrices

La regla para multiplicar dos matrices es bastante más complicada que para sumar dos
matrices de las mismas dimensiones. En general, se pueden multiplicar dos matrices de
dimensiones m x n y n x q, dando como resultado una matriz de dimensiones m x q. En
este apartado nos circunscribiremos exclusivamente a matrices cuadradas de dimensión n.

Los elementos cij se obtienen multiplicando los elementos aik de la fila i por los elementos
akj de la columna j, y sumando los resultados.

La codificación se realiza empleando un tripe bucle for, guardando en los elementos de la

la matriz local resultado la suma de los productos de la fórmula anterior.

public static Matriz producto(Matriz a, Matriz b){

Matriz resultado=new Matriz(a.n);
for(int i=0; i<a.n; i++){
for(int j=0; j<a.n; j++){
for(int k=0; k<a.n; k++){
resultado.x[i][j]+=a.x[i][k]*b.x[k][j];
}
}
}
return resultado;
}

Otras variantes de la operación producto son:

El producto de un escalar (número real) por una matriz que da como resultado otra matriz
cuyos elementos están todos multiplicados por dicho escalar. Se define también la
operación conmutativa

public static Matriz producto(double d, Matriz a){

Matriz resultado=new Matriz(a.n);
for(int i=0; i<a.n; i++){
for(int j=0; j<a.n; j++){
resultado.x[i][j]=a.x[i][j]*d;
}
}
return resultado;
}

Al multiplicar una matriz cuadrada de dimensión n, por un vector columna de la misma

dimensión obtenemos otro vector columna. Cada elemento del vector resultante se
obtiene multiplicando los elementos de una fila de la matriz por los correspondientes
elementos del vector columna y se suman los resultados. La codificación de esta función
producto es la siguiente:

public static Vector producto(Matriz a, Vector v){

int n=v.n;
Vector b=new Vector(n);
for(int i=0; i<n; i++){
for(int k=0; k<n; k++){
b.x[i]+=a.x[i][k]*v.x[k];
}
}
return b;
}

Al multiplicar un vector fila por una matriz cuadrada de la misma dimensión obtenemos
otro vector fila. El código es semejante al de la función producto definida previamente.

public static Vector producto(Vector v, Matriz a){

int n=v.n;
 Vector b=new Vector(n);
for(int j=0; j<n; j++){
for(int k=0; k<n; k++){
b.x[j]+=v.x[k]*a.x[k][j];
}
}
return b;
}

Matriz traspuesta
Una matriz traspuesta de otra matriz es aquella que tiene los mismos elementos pero
dispuestos en forma distinta. Las columnas de la matriz original se transforman en filas
de la matriz traspuesta. La definición de la función estática traspuesta no reviste
dificultad alguna

public static Matriz traspuesta(Matriz a){

int n=a.n;
Matriz resultado=new Matriz(a.n);
for(int i=0; i<n; i++){
for(int j=0; j<n; j++){
resultado.x[i][j]=a.x[j][i];
}
}
return resultado;
}

Para hallar la matriz traspuesta de la matriz a se escribe

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

Matriz a=new Matriz(a1);
Matriz tras=Matriz.traspuesta(a);
System.out.println("matriz traspuesta"+tras);