Introduzione alla moltiplicazione di matrici in Java
Le matrici in Java sono archiviate in array. Sono presenti matrici monodimensionali e matrici bidimensionali che memorizzano valori sotto forma di matrici nelle dimensioni note come matrici. Negli array monodimensionali, ci sono solo numeri memorizzati in una dimensione, mentre negli array bidimensionali i numeri sono memorizzati sotto forma di righe e colonne. Le matrici possono essere utilizzate per aggiungere, sottrarre e moltiplicare i numeri nel linguaggio di programmazione Java. La moltiplicazione delle matrici è una delle attività più complicate nella metodologia di programmazione Java. In questo articolo dobbiamo eseguire la moltiplicazione delle matrici in Java e mostrare come possiamo moltiplicare due matrici e fornire un risultato ragionevole.
Metodologia generale
La moltiplicazione delle matrici nel linguaggio di programmazione Java viene eseguita in modo molto semplice. Innanzitutto, inseriamo i numeri nella prima matrice bidimensionale e poi inseriamo i numeri degli elementi nella seconda matrice bidimensionale. I numeri vengono aggiunti per riga, il che significa che viene creata la prima riga, quindi vengono creati i numeri nella seconda riga e così via. Quindi la seconda matrice viene creata in modo simile e quindi iniziamo a moltiplicare i numeri nelle matrici.
Esempi di moltiplicazione di matrici in Java
Di seguito sono riportati gli esempi sulla moltiplicazione delle matrici
Esempio 1
Nell'esempio di codifica, vediamo come vengono immesse due matrici per riga e quindi viene eseguita la moltiplicazione della matrice. Il codice per la moltiplicazione di due matrici è mostrato di seguito. Esistono tre array dichiarati. Il prodotto della prima e seconda matrice è mostrato all'interno della terza matrice. Quindi la matrice viene mostrata come output che è un prodotto di due matrici nell'array.
import java.util.Scanner;
public class MatixMultiplication
(
public static void main(String args())
(
int n;
Scanner input = new Scanner(System.in);
System.out.println("Enter the number of rows and columns of the matrices. They must be equal.");
n = input.nextInt();
int()() a = new int(n)(n);
int()() b = new int(n)(n);
int()() c = new int(n)(n);
System.out.println("Enter the numbers of the first matrix. Numbers will be added row wise \n");
for (int i = 0; i < n; i++)
(
for (int j = 0; j < n; j++)
(
a(i)(j) = input.nextInt();
)
)
System.out.println("Enter the numbers of the 2nd matrix. Numbers will be added row wise. \n");
for (int i = 0; i < n; i++)
(
for (int j = 0; j < n; j++)
(
b(i)(j) = input.nextInt();
)
)
System.out.println("Generating the multiplication of matrices…..");
for (int i = 0; i < n; i++)
(
for (int j = 0; j < n; j++)
(
for (int k = 0; k < n; k++)
(
c(i)(j) = c(i)(j) + a(i)(k) * b(k)(j);
)
)
)
System.out.println("The product of the matrices is shown as below");
for (int i = 0; i < n; i++)
(
for (int j = 0; j < n; j++)
(
System.out.print(c(i)(j) + " ");
)
System.out.println();
)
input.close();
)
)
Viene mostrato l'output per una matrice 2 * 2. La prima matrice è composta da elementi come (1, 2
3, 4)
e la seconda matrice contiene anche gli stessi elementi. Nell'output del campione, notiamo la moltiplicazione delle matrici e l'output del campione. Gli elementi della matrice sono prodotti in un modo molto piacevole. L'output prodotto
(1, 2 (1, 2 (7, 10
3, 4) * 3, 4) = 15, 22)
Produzione
Esempio n. 2
Nell'esempio di codifica 2, abbiamo lo stesso programma, ma ora utilizziamo array tridimensionali per la moltiplicazione. Ora usiamo la moltiplicazione di matrice 3 * 3 e mostriamo l'output in un altro array tridimensionale.
import java.util.Scanner;
public class Matix
(
public static void main(String args())
(
int n;
Scanner input = new Scanner(System.in);
System.out.println("Enter the number of rows and columns of the matrices. They must be equal.");
n = input.nextInt();
int()() a = new int(n)(n);
int()() b = new int(n)(n);
int()() c = new int(n)(n);
System.out.println("Enter the numbers of the first matrix. Numbers will be added row wise \n");
for (int i = 0; i < n; i++)
(
for (int j = 0; j < n; j++)
(
a(i)(j) = input.nextInt();
)
)
System.out.println("Enter the numbers of the 2nd matrix. Numbers will be added row wise. \n");
for (int z = 0; z < n; z++)
(
for (int k = 0; k < n; k++)
(
b(z)(k) = input.nextInt();
)
)
System.out.println("Generating the multiplication of matrices…..");
for (int i = 0; i < n; i++)
(
for (int j = 0; j < n; j++)
(
for (int k = 0; k < n; k++)
(
c(i)(j) = c(i)(j) + a(i)(k) * b(k)(j);
)
)
)
System.out.println("The product of the matrices is shown as below");
for (int k = 0; k < n; k++)
(
for (int l = 0; l < n; l++)
(
System.out.print(c(k)(l) + " ");
)
System.out.println();
)
input.close();
)
)
Dal secondo codice di esempio, stampiamo due matrici 3 * 3. La prima matrice è (1, 1, 1
1, 1, 1
1, 1, 1)
e anche la seconda matrice è la stessa. La moltiplicazione della matrice viene generata nei modi seguenti
(1, 1, 1 (1, 1, 1 (3, 3, 3
1, 1, 1 * 1, 1, 1 = 3, 3, 3
1, 1, 1) 1, 1, 1) 3, 3, 3)
Produzione
Conclusione
In questo articolo, vediamo la moltiplicazione di una matrice 2 * 2 e una matrice 3 * 3, nonché l'output mostrato in modo molto piacevole. Le uscite sono chiaramente indicate. Usando la moltiplicazione matrice, possiamo anche creare una moltiplicazione 4 * 4 di una matrice. La base viene richiesta nella prima fase del programma. Possiamo anche creare matrici 5 * 5, 6 * 6. Più la base è la complessità del programma.
Tuttavia, la semplice moltiplicazione delle matrici è molto utile nel calcolo della riflessione di un punto con l'asse X, l'asse Y o l'asse Z come asse di riflessione. Questi semplici concetti vengono utilizzati nella geometria delle coordinate e vengono utilizzati nella modellizzazione matematica delle applicazioni della geometria.
Articoli consigliati
Questa è una guida alla moltiplicazione di matrici in Java. Qui discutiamo l'introduzione, la metodologia generale e gli esempi di moltiplicazione di matrici in Java. Puoi anche consultare i nostri altri articoli suggeriti per saperne di più–
- Convenzioni di denominazione Java
- Sovraccarico e override in Java
- Parola chiave statica in Java
- Variabili in JavaScript