E aê, swampps! blz?
Já tinha feito um projeto para faculdade referente a operações com matrizes. O projeto possui duas classes: uma referente à matriz e suas operações e a outra é a classe principal (que possui o método main). Vê se vc entende, caso contrário é só perguntar. Lá vai...
public class Matriz {
/**
* Armazena os elementos da matriz
*/
private double[][] elements;
/**
* Armazena o número de colunas da matriz
*/
private int colunas;
/**
* Armazena o número de colunas da matriz
*/
private int linhas;
/**
* Cria uma instância da classe Matriz e configura os atributos linhas e
* colunas de acordo com os argumentos recebidos (lin,col).
*
* @param lin
* @param col
*/
public Matriz(int lin, int col) {
this.linhas = lin;// atribui o valor de lin a linhas
this.colunas = col;// atribui o valor de col a colunas
elements = new double[linhas][colunas];// cria um array de duas
// dimensões utilizado para
// armazenar os elementos de uma
// Matriz com os números de
// linhas e colunas
// especificados.
}
/**
* Este método realiza a operação de soma entre duas matrizes que são
* recebidas como argumentos e retorna a matriz soma.
*
* @param m1
* @param m2
* @return
*/
public static Matriz somarMatrizes(Matriz matriz1, Matriz matriz2) {// O
// método
// é
// estático
// porque a
// operação de
// soma pertence
// a classe
// Matriz, desta
// forma, não há
// necessidade
// de criar
// objetos desta
// para realizar
// a soma.
Matriz matrizSoma = null;// result representa a matriz soma.
if (matriz1 != null && matriz2 != null) {// verifica se as matrizes
// recebidas
// como argumentos não são nulas.
if (matriz1.linhas == matriz2.linhas
&& matriz1.colunas == matriz2.colunas) {// verifica
// se as
// duas
// matrizes
// (matriz1,matriz2)
// podem
// ser
// somadas.
matrizSoma = new Matriz(matriz1.linhas, matriz1.colunas);// cria
// a
// matriz
// soma com o mesmo
// número de linhas
// e colunas da
// matriz1(a
// matriz2 possui
// os mesmos números
// de linhas e
// colunas).
for (int i = 0; i < matriz1.elements.length; i++) {// loop para
// percorrer as
// linhas da
// matriz onde i
// representa a
// linha.
for (int j = 0; j < matriz1.elements[0].length; j++) {// loop
// para
// percorrer
// as
// colunas
// da
// matriz
// onde
// j
// representa
// a
// coluna.
matrizSoma.elements[i][j] = matriz1.elements[i][j]
+ matriz2.elements[i][j];// O elemento da
// matriz
// resultado, especificado
// por i e j, recebe o valor
// da soma dos elementos de
// matriz1 e matriz2 epecificados
// pelas mesmas variáveis.
}
}
} else {
System.err.println("Erro: matrizes incompatíveis para soma");
}
} else {
System.err.println("Erro: Matriz nula");
}
return matrizSoma;// retorn a matriz resultado
}
public static Matriz subtrairMatrizes(Matriz matriz1, Matriz matriz2) {
Matriz matrizSubtracao = null;
if (matriz1 != null && matriz2 != null) {// verifica se as matrizes
// recebidas
// como argumentos não são nulas.
if (matriz1.linhas == matriz2.linhas
&& matriz1.colunas == matriz2.colunas) {// verifica
// se as
// duas
// matrizes
// (matriz1,matriz2)
// podem
// ser
// subtraídas.
matrizSubtracao = new Matriz(matriz1.linhas, matriz1.colunas);// cria
// a
// matrizSubtracao
// com o mesmo
// número de linhas
// e colunas da
// matriz1(a
// matriz2 possui
// os mesmos números
// de linhas e
// colunas).
for (int i = 0; i < matriz1.elements.length; i++) {// loop para
// percorrer as
// linhas da
// matriz onde i
// representa a
// linha.
for (int j = 0; j < matriz1.elements[0].length; j++) {// loop
// para
// percorrer
// as
// colunas
// da
// matriz
// onde
// j
// representa
// a
// coluna.
matrizSubtracao.elements[i][j] = matriz1.elements[i][j]
- matriz2.elements[i][j];// O elemento da
// matrizSubtracao, especificado
// por i e j, recebe o valor
// da subtração dos elementos de
// matriz1 e matriz2 com os mesmos índices(i,j).
}
}
} else {
System.err
.println("Erro: matrizes incompativeis para subtracao");
}
} else {
System.err.println("Erro: Matriz nula");
}
return matrizSubtracao;// retorn a matrizSubtracao.
}
public double[][] getElements() {
return elements;
}
/**
* Multiplica uma matriz por um número inteiro.
*
* @param matriz1
* @param inteiro
* @return Matriz
*/
public static Matriz mutiplicarMatrizPorInteiro(Matriz matriz1, int inteiro) {
Matriz matrizMultiplicacaoPorInteiro = null;// declara a matriz que
// receberá o resultado.
if (matriz1 != null) {// verifica se a matriz1 não é nula.
matrizMultiplicacaoPorInteiro = new Matriz(matriz1.linhas,
matriz1.colunas);// cria a matriz que receberá o
// resultado.
/*
* percorre todos os elementos da matriz1.
*/
for (int i = 0; i < matriz1.elements.length; i++) {
for (int j = 0; j < matriz1.elements[0].length; j++) {
/*
* atribui a cada elemento(i,j) da
* matrizMultiplicacaoPorInteir o resultado do produto do
* elemento(i,j) da matriz1 pelo inteiro.
*/
matrizMultiplicacaoPorInteiro.elements[i][j] = matriz1.elements[i][j]
* inteiro;
}
}
} else {
System.err.println("Erro: Matriz nula!");
}
return matrizMultiplicacaoPorInteiro;// retorna a
// matrizMultiplicacaoPorInteiro.
}
/**
* Verifica a igualdade entre duas matrizes.
*
* @param matriz1
* @param matriz2
* @return result
*/
public static boolean saoIguais(Matriz matriz1, Matriz matriz2) {
boolean result = true;// parte do suposto que ambas são iguais.
if (matriz1 != null && matriz2 != null) {// verifica se as matrizes
// não são nulas.
if (matriz1.linhas == matriz2.linhas
&& matriz1.colunas == matriz2.colunas) {// verifica se as
// matrizes possuem
// os mesmos números
// de linha e
// coluna.
for (int i = 0; i < matriz1.elements.length; i++) {// percorre
// as linhas
// da matriz
for (int j = 0; j < matriz2.elements[0].length; j++) {// percorre
// as
// colunas
// da
// matriz
if (matriz1.elements[i][j] != matriz2.elements[i][j]) {// verifica
// se o
// elemento(i,j)
// são
// diferentes.
return result = false;// retorna false caso
// encontre algum
// elemento(i,j) diferente
// entre as matrizes.
}
}
}
}
}
return result;
}
/**
* Recebe um número variável de elementos do tipo double e preenche as
* lacunas da Matriz se forem compatíveis.
*
* @param elements
*/
public void preencherMatriz(double... elements) {
int totalElements = linhas * colunas;// verifica o número total de
// elementos que a Matriz deve
// receber
int elementsIndex = 0;// índice do array recebido como
// argumeto(elements).
if (elements != null && elements.length == totalElements) {// verifica
// se
// elements
// não é
// nulo e o
// tamanho
// de elements
// coincide
// com o
// numero de
// elementos
// da
// matriz.
for (int i = 0; i < linhas; i++) {// percorre as linhas da matriz
for (int j = 0; j < colunas; j++) {// percorre as colunas da
// matriz
this.elements[i][j] = elements[elementsIndex++];// o
// elemento
// (i,j) da
// matriz
// recebe o
// valor
// contido
// no índice
// (elementsIndex) do array elements (passado como
// argumento) e
// depois incrementa elementsIndex em 1.
}
}
} else {
System.err
.println("Erro: numero de elementos da matriz incorreto!");
System.err.println("A matriz possui " + totalElements
+ " elementos, mas você forneceu " + elements.length + ".");
// System.exit(0);
}
}
/**
* Imprimi os elementos da matriz.
*/
public String toString() {
String result = "";
for (int i = 0; i < elements.length; i++) {
for (int j = 0; j < elements[0].length; j++) {
result += String.format("a(%d,%d)=%+4.2f ", (i + 1), (j + 1),
elements[i][j]);
}
result += "\n";
}
return result;
}
/**
* Realiza a multiplicação entre duas matrizes.
*
* @param matriz1
* @param matriz2
* @return Matriz
*/
public static Matriz multiplicarMatrizes(Matriz matriz1, Matriz matriz2) {
Matriz matrizProduto = null;
if (matriz1 != null && matriz2 != null) {// verifica se as matrizes
// não são nulas
if (matriz1.colunas == matriz2.linhas) {// verifica se as matrizes
// podem ser multiplicadas
matrizProduto = new Matriz(matriz1.linhas, matriz2.colunas);// cria
// a
// matriz
// produto que deve ter o número de linhas da primeira matriz e
// o número de colunas da segunda.
for (int i = 0; i < matrizProduto.elements.length; i++) {// percorre
// as
// linhas
// da
// matrizProduto
for (int j = 0; j < matrizProduto.elements[0].length; j++) {// percorre
// as
// colunas
// da
// matrizProduto
double elementoMatrizProduto = 0;// armazena cada
// elemento da
// matriz produto
// de acordo com a multiplicação
// da linha da
// matriz1 pela
// coluna da
// matriz2.
for (int k = 0; k < matriz2.linhas; k++) {// loop para
// realizar
// a
// multiplicação
// das
// linhas(matriz1)
// pelas
// colunas(matriz2).
elementoMatrizProduto += matriz1.elements[i][k]
* matriz2.elements[k][j];
}
matrizProduto.elements[i][j] = elementoMatrizProduto;// atribui
// o
// resultado
// do
// produto
// ao
// respectivo
// elemento(i,j)
// da
// matrizProduto.
}
}
} else {
System.err
.println("Erro: as matrizes não podem ser multiplicadas!");
System.err
.println("Verifique se o número de colunas da Matriz 1 é igual ao número de linhas da Matriz 2.");
}
} else {
System.err.println("Erro: Matriz(es) nula(s)!");
}
return matrizProduto;
}
}
import java.util.InputMismatchException;
import java.util.Scanner;
public class Main {
/**
* Ponto de execução inicial.
* @param args
*/
public static void main(String[] args) {
/*
* //testes
* Matriz matriz1 = new Matriz(2, 2);
* matriz1.preencherMatriz(3, 1,1,4); Matriz matriz2 = new Matriz(2, 2);
* matriz2.preencherMatriz(3, 1,1,4); int inteiro = 3;
* System.out.println("Matriz 1"); System.out.println(matriz1);
* System.out.println("Matriz 2"); System.out.println(matriz2);
* System.out.println("Matriz 1 e Matriz 2 são iguais?");
* System.out.println(Matriz.saoIguais(matriz1, matriz2));
* System.out.println("Resultado de Matriz 1 + Matriz 2");
* System.out.println(Matriz.somarMatrizes(matriz1,
* matriz2).toString()); System.out.println("Resultado de Matriz 1 -
* Matriz 2"); System.out.println(Matriz.subtrairMatrizes(matriz1,
* matriz2).toString()); System.out.println("Resultado de (Matriz 1) X " +
* inteiro);
* System.out.println(Matriz.mutiplicarMatrizPorInteiro(matriz1,
* inteiro).toString()); System.out.println("Resultado de (Matriz 2) X " +
* inteiro);
* System.out.println(Matriz.mutiplicarMatrizPorInteiro(matriz2,
* inteiro).toString()); System.out.println("Resultado de Matriz 1 X
* Matriz 2"); System.out.println(Matriz.multiplicarMatrizes(matriz1,
* matriz2).toString());
*/
Scanner input = new Scanner(System.in);
Matriz matrizes[] = new Matriz[2];
for (int i = 0; i < 2; i++) {
int lin = 0, col = 0;
System.out.println("Matriz " + (i + 1));
try {
System.out.print("digite o numero de linhas: ");
lin = input.nextInt();
System.out.print("digite o numero de colunas: ");
col = input.nextInt();
} catch (InputMismatchException e) {
System.err.println("NUMERO DE LINHAS INVALIDO");
lin = 3;
col = 3;
}
double[] elements = new double[lin * col];
matrizes[i] = new Matriz(lin, col);
System.out.println("preencha a matriz");
int elementsIndex = 0;
for (int j = 0; j < matrizes[i].getElements().length; j++) {
for (int k = 0; k < matrizes[i].getElements()[0].length; k++) {
System.out.print("a(" + (j + 1) + "," + (k + 1) + "): ");
try {
elements[elementsIndex++] = input.nextDouble();
} catch (InputMismatchException e) {
// TODO: handle exception
System.err.println("ELEMENTO INVALIDO!");
elements[elementsIndex++] = 0;
}
}
}
System.out.println();
matrizes[i].preencherMatriz(elements);
System.out.println(matrizes[i].toString());
}
boolean condition = true;
do {
int op = 0;
System.out.println("Opcoes:");
System.out.println("1 - calcular Matriz 1 + Matriz 2");
System.out.println("2 - calcular Matriz 1 - Matriz 2");
System.out.println("3 - calcular Matriz 1 X inteiro");
System.out.println("4 - calcular Matriz 2 X inteiro");
System.out.println("5 - calcular Matriz 1 X Matriz 2");
System.out
.println("6 - Verificar a igualdade entre Matriz 1 e Matriz 2");
System.out.println("7 - sair");
System.out.print("Digite a opcao: ");
try {
op = input.nextInt();
} catch (InputMismatchException e) {
// TODO: handle exception
System.err.println("OPCAO INVALIDA!" );
op = 7;
}
switch (op) {
case 1:
System.out.println("Matriz 1 + Matriz 2");
Matriz matrizSoma = Matriz.somarMatrizes(matrizes[0],
matrizes[1]);
System.out.println(matrizSoma);
System.out.println();
break;
case 2:
System.out.println("Matriz 1 - Matriz 2");
Matriz matrizSubtracao = Matriz.subtrairMatrizes(matrizes[0],
matrizes[1]);
System.out.println(matrizSubtracao);
System.out.println();
break;
case 3:
System.out.println("Matriz 1 X inteiro");
int inteiro = 0;
try {
System.out.print("Digite o inteiro: ");
inteiro = input.nextInt();
} catch (InputMismatchException e) {
// TODO: handle exception
System.err.println("ERRO: NUMERO INVALIDO!");
inteiro = 1;
}
Matriz matrizProdutoPorInteiro = Matriz
.mutiplicarMatrizPorInteiro(matrizes[0], inteiro);
System.out.println(matrizProdutoPorInteiro);
System.out.println();
break;
case 4:
System.out.println("Matriz 2 X inteiro");
int inteiro2 = 0;
try {
System.out.print("Digite o inteiro: ");
inteiro2 = input.nextInt();
} catch (InputMismatchException e) {
// TODO: handle exception
System.err.println("ERRO: NUMERO INVALIDO!");
inteiro2 = 1;
}
System.out.print("Digite o inteiro: ");
inteiro2 = input.nextInt();
Matriz matrizProdutoPorInteiro2 = Matriz
.mutiplicarMatrizPorInteiro(matrizes[1], inteiro2);
System.out.println(matrizProdutoPorInteiro2);
System.out.println();
break;
case 5:
System.out.println("Matriz 1 X Matriz 2");
Matriz matrizProduto = Matriz.multiplicarMatrizes(matrizes[0],
matrizes[1]);
System.out.println(matrizProduto);
System.out.println();
break;
case 6:
System.out.print("A Matriz 1 e igual a Matriz 2: ");
System.out.println(Matriz.saoIguais(matrizes[0], matrizes[1]));
System.out.println();
break;
case 7:
System.out.println("APLICACAO FINALIZADA!");
System.exit(0);
break;
default:
condition = false;
break;
}
} while (condition);
}
}
Vc pode retirar apenas a parte que te interessa (multiplicação entre matrizes). Espero ter ajudado!
