「矩阵计算java」矩阵计算题及答案

admin 2022-11-22 17:49:08 166

今天给各位分享矩阵计算java的知识，其中也会对矩阵计算题及答案进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

1、用java语言做矩阵运算，输入一个m×n的矩阵，再输入一个n×o的矩阵，求其乘积。
2、用Java线程编写矩阵相乘的计算程序.
3、用java怎么写矩阵乘法？
4、Java编写一个程序实现矩阵的运算加减乘除，（并对其中的异常进行处理）
5、Java矩阵算法？
6、java实现矩阵相加、相乘，判断是否上（下）三角矩阵、对称矩阵、相等的算法

用java语言做矩阵运算，输入一个m×n的矩阵，再输入一个n×o的矩阵，求其乘积。

这应该是线性数学的矩阵

逻辑思路是：取A矩阵的每一行的各个项去乘以B矩阵每个列的各个项

为了测试，我现在假设A矩阵是4*3， B矩阵是3*2，你要做的乘操作是4*3*2=24次

import java.util.*;

import java.lang.*;

import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */

class Ideone

{

public static void main (String[] args) throws java.lang.Exception

{

int[][]A=new int[][]{{1,2,3},{4,5,6},{7,8,9},{10,11,12}};

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

int len_A=A[0].length;//a每行元素数，这里是3

int col_A=A.length;//a每列元素数，这里是4

int len_B=B[0].length;//b每行元素数，这里是2

int col_B=B.length;//b每列元素数，这里是3

int len_a=0;

int col_a=0;

int len_b=0;

int col_b=0;

int sum=0;

while(len_blen_B)//使B的下一列被A乘

{

col_a=0;

while(col_acol_A)//使A可以移动至下一行

{

len_a=0;

col_b=0;

while(len_alen_A)//使A的当前行乘以B的当前列

{

sum+=A[col_a][len_a]*B[col_b][len_b];

len_a++;

col_b++;

}

col_a++;

}

len_b++;

}

System.out.println(sum);

}

用Java线程编写矩阵相乘的计算程序.

闲来无事，写了以下程序：

public class Matrix

{

private static java.util.Random ran=new java.util.Random();

private int[][] ma,mb;

private int[][] result;

public void initial()

{

ma=new int [10][10];

mb=new int [10][10];

result=new int[10][0];//节省空间

randomM(ma);

randomM(mb);

System.out.println("-----------ma:");

printM(ma);

System.out.println("-----------mb:");

printM(mb);

}

private Thread getLineThread(final int line)

{

return new Thread()

{

public void run()

{

calLine(line);

}

};

}

public void calM ()throws Exception

{

for(int i=0;i10;i++)

{

Thread t=getLineThread(i);

t.start();

t.join();//InterruptedException

}

public void printResult()

{

System.out.println("\u7ED3\u679C\u662F\uFF1A");

printM(result);

}

private void calLine(int line)

{

int [] temp=new int[10];

for(int i=0;i10;i++)

{

for(int j=0;j10;j++)

{

temp[i]+=ma[line][j]*mb[j][i];

}

synchronized(result)

{

result[line]=temp;

}

System.out.println("\u7B2C"+line+"\u8BA1\u7B97\u5B8C\u6BD5\u3002");

}

private static void randomM(int[][]m)

{

for(int i=0;im.length;i++)

{

for(int j=0;jm[i].length;j++)

{

m[i][j]=ran.nextInt()%100;//防止计算溢出

}

private static void printM(int[][] m)

{

for(int i=0;im.length;i++)

{

for(int j=0;jm[i].length;j++)

{

System.out.printf("%8d",m[i][j]);

}

System.out.println();

}

public static void main (String[]args)throws Exception

{

Matrix m=new Matrix();

m.initial();

m.calM();

m.printResult();

}

其中有些汉字字符串被ultraedit处理成编码的数字，运行才能看到。

用java怎么写矩阵乘法？

import java.util.Scanner;

public class Matrix {

public double[][] create() {

Scanner sc = new Scanner(System.in) ;

System.out.print（＂请输入矩阵的行高：＂）；

int a = sc.nextInt() ;

System.out.print（＂请输入矩阵的列宽：＂）；

int b = sc.nextInt() ;

double[][] x = new double[a][b] ;

for(int i=0;ilt;a;i++){

for(int j=0;jlt;b;j++){

System.out.print（＂请输入元素x[＂+i+＂][＂+j+＂]的值：＂）；

x[i][j] = sc.nextDouble() ;

}

return x ;

}

public double[][] multiply(double[][] x,double[][] y){

double[][] result = null ;

int a = x[0].length ;

int b = y.length ;

if(a != b){

System.out.println（＂输入的维数不匹配，不能进行运算＂）；

}else{

int c = x.length ;

int d = y[0].length ;

result = new double[c][d] ;

for(int i=0;ilt;c;i++){

for(int j=0;jlt;d;j++){

double sum = 0 ;

for(int k=0;klt;a;k++){

sum += x[i][k]*y[k][j] ;

}

result[i][j] = sum ;

}

return result ;

}

public void print(double[][] x){

System.out.println（＂矩阵为：＂）；

for(int i=0;ilt;x.length;i++){

for(int j=0;jlt;x[i].length;j++){

System.out.print(x[i][j] + ＂＂) ;

}

System.out.println();

}

测试类：

public class TestMatrix {

public static void main(String[] args) {

Matrix m = new Matrix() ;

//double[][] x = {{1,2},{3,2}} ;

//double[][] y = {{1,2,1},{2,3,3}} ;

System.out.println（＂创建第一个数组：＂）；

double[][] x = m.create() ;

m.print(x) ； //用来验证输入的是否和你一样的，没啥作用

System.out.println（＂创建第二个数组：＂）；

double[][] y = m.create() ;

m.print(y) ； //用来验证输入的是否和你一样的，没啥作用

double[][] result = m.multiply(x, y) ;

if(result == null){

return ； //如果输入的矩阵不能运算就不输出结果了。

}

m.print(result) ;

}

Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。 Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等。

Java编写一个程序实现矩阵的运算加减乘除，（并对其中的异常进行处理）

/**

* 矩阵：由 m × n 个数Aij排成的m行n列的数表称为m行n列的矩阵，简称m × n矩阵

* 说白了就是一个二维数组，下面的程序用整形作为数据类型，其他类型运算大同小异

public class MatrixUtils {

/**

* 矩阵运算：加(减法与之类似)

public static int[][] matrixAdd(int[][] addend, int[][] summand) {

if (addend == null || addend.length == 0) {

throw new IllegalArgumentException("addend matrix is empty!");

}

if (summand == null || summand.length == 0) {

throw new IllegalArgumentException("summand matrix is empty!");

}

//矩阵加减要求两个矩阵类型一致，即行列数相同

int row = addend.length;

int col = addend[0].length;

if (row != summand.length || col != summand[0].length) {

throw new IllegalArgumentException("summand and summand not the same type!");

}

int[][] sum = new int[row][col];

for (int i = 0; i row; i++) {

for (int j = 0; j col; j++) {

sum[i][j] = addend[i][j] + summand[i][j];

// sum[i][j] = addend[i][j] - summand[i][j]; //减法

}

return sum;

}

/**

* 矩阵运算：乘法,没找到除法的运算规则

public static int[][] matrixMultiply(int[][] addend, int[][] summand) {

if (addend == null || addend.length == 0) {

throw new IllegalArgumentException("addend matrix is empty!");

}

if (summand == null || summand.length == 0) {

throw new IllegalArgumentException("summand matrix is empty!");

}

//两个矩阵的乘法仅当第一个矩阵A的列数和另一个矩阵B的行数相等时才能定义。如A是m×n矩阵和B是n×p矩阵，它们的乘积C是一个m×p矩阵

int row = addend.length;

int col = summand[0].length;

if (addend[0].length != summand.length) {

throw new IllegalArgumentException("summand and summand not the same type!");

}

int[][] sum = new int[row][col];

for (int i = 0; i row; i++) {

for (int j = 0; j col; j++) {

for (int z = 0; z addend[0].length; z++) {

sum[i][j] += addend[i][z] * summand[z][j];

System.out.println("sum[" + i+ "]["+ j+"]= " + sum[i][j]);

}

return sum;

}

Java矩阵算法？

//STRASSEN矩阵算法

#include iostream.h

const int N=8; //常量N用来定义矩阵的大小

void main()

{

void STRASSEN(int n,float A[][N],float B[][N],float C[][N]);

void input(int n,float p[][N]);

void output(int n,float C[][N]); //函数声明部分

float A[N][N],B[N][N],C[N][N]; //定义三个矩阵A,B,C

cout"现在录入矩阵A[N][N]:"endlendl;

input(N,A);

coutendl"现在录入矩阵B[N][N]:"endlendl;

input(N,B); //录入数组

STRASSEN(N,A,B,C); //调用STRASSEN函数计算

output(N,C); //输出计算结果

}

void input(int n,float p[][N]) //矩阵输入函数

{

int i,j;

for(i=0;in;i++)

{

cout"请输入第"i+1"行"endl;

for(j=0;jn;j++)

cinp[i][j];

}

void output(int n,float C[][N]) //据矩阵输出函数

{

int i,j;

cout"输出矩阵:"endl;

for(i=0;in;i++)

{

coutendl;

for(j=0;jn;j++)

coutC[i][j]" ";

}

coutendlendl;

}

void MATRIX_MULTIPLY(float A[][N],float B[][N],float C[][N]) //按通常的矩阵乘法计算C=AB的子算法(仅做2阶)

{

int i,j,t;

for(i=0;i2;i++) //计算A*B--C

for(j=0;j2;j++)

{

C[i][j]=0; //计算完一个C[i][j]，C[i][j]应重新赋值为零

for(t=0;t2;t++)

C[i][j]=C[i][j]+A[i][t]*B[t][j];

}

void MATRIX_ADD(int n,float X[][N],float Y[][N],float Z[][N]) //矩阵加法函数X+Y—Z

{

int i,j;

for(i=0;in;i++)

for(j=0;jn;j++)

Z[i][j]=X[i][j]+Y[i][j];

}

void MATRIX_SUB(int n,float X[][N],float Y[][N],float Z[][N]) //矩阵减法函数X-Y—Z

{

int i,j;

for(i=0;in;i++)

for(j=0;jn;j++)

Z[i][j]=X[i][j]-Y[i][j];

}

void STRASSEN(int n,float A[][N],float B[][N],float C[][N]) //STRASSEN函数（递归）

{

float A11[N][N],A12[N][N],A21[N][N],A22[N][N];

float B11[N][N],B12[N][N],B21[N][N],B22[N][N];

float C11[N][N],C12[N][N],C21[N][N],C22[N][N];

float M1[N][N],M2[N][N],M3[N][N],M4[N][N],M5[N][N],M6[N][N],M7[N][N];

float AA[N][N],BB[N][N],MM1[N][N],MM2[N][N];

int i,j;//,x;

if (n==2)

MATRIX_MULTIPLY(A,B,C);//按通常的矩阵乘法计算C=AB的子算法(仅做2阶)

else

{

for(i=0;in/2;i++) //////////

for(j=0;jn/2;j++)

{

A11[i][j]=A[i][j];

A12[i][j]=A[i][j+n/2];

A21[i][j]=A[i+n/2][j];

A22[i][j]=A[i+n/2][j+n/2];

B11[i][j]=B[i][j];

B12[i][j]=B[i][j+n/2];

B21[i][j]=B[i+n/2][j];

B22[i][j]=B[i+n/2][j+n/2];

} //将矩阵A和B式分为四块

MATRIX_SUB(n/2,B12,B22,BB); //////////

STRASSEN(n/2,A11,BB,M1);//M1=A11(B12-B22)

MATRIX_ADD(n/2,A11,A12,AA);

STRASSEN(n/2,AA,B22,M2);//M2=(A11+A12)B22

MATRIX_ADD(n/2,A21,A22,AA);

STRASSEN(n/2,AA,B11,M3);//M3=(A21+A22)B11

MATRIX_SUB(n/2,B21,B11,BB);

STRASSEN(n/2,A22,BB,M4);//M4=A22(B21-B11)

MATRIX_ADD(n/2,A11,A22,AA);

MATRIX_ADD(n/2,B11,B22,BB);

STRASSEN(n/2,AA,BB,M5);//M5=(A11+A22)(B11+B22)

MATRIX_SUB(n/2,A12,A22,AA);

MATRIX_SUB(n/2,B21,B22,BB);

STRASSEN(n/2,AA,BB,M6);//M6=(A12-A22)(B21+B22)

MATRIX_SUB(n/2,A11,A21,AA);

MATRIX_SUB(n/2,B11,B12,BB);

STRASSEN(n/2,AA,BB,M7);//M7=(A11-A21)(B11+B12)

//计算M1,M2,M3,M4,M5,M6,M7（递归部分）

MATRIX_ADD(N/2,M5,M4,MM1); //////////

MATRIX_SUB(N/2,M2,M6,MM2);

MATRIX_SUB(N/2,MM1,MM2,C11);//C11=M5+M4-M2+M6

MATRIX_ADD(N/2,M1,M2,C12);//C12=M1+M2

MATRIX_ADD(N/2,M3,M4,C21);//C21=M3+M4

MATRIX_ADD(N/2,M5,M1,MM1);

MATRIX_ADD(N/2,M3,M7,MM2);

MATRIX_SUB(N/2,MM1,MM2,C22);//C22=M5+M1-M3-M7

for(i=0;in/2;i++)

for(j=0;jn/2;j++)

{

C[i][j]=C11[i][j];

C[i][j+n/2]=C12[i][j];

C[i+n/2][j]=C21[i][j];

C[i+n/2][j+n/2]=C22[i][j];

} //计算结果送回C[N][N]

}

java实现矩阵相加、相乘，判断是否上（下）三角矩阵、对称矩阵、相等的算法

class Matrix

{

private int value[][]; //存储矩阵元素的二维数组

public Matrix(int m, int n) //构造m行n列的空矩阵

{

this.value=new int[m][n];

}

public Matrix(int n) //构造n行n列的空矩阵

{

this(n,n);

}

public Matrix()

{

this(10,10);

}

public Matrix(int mat[][]) //构造矩阵，由数组mat提供矩阵元素

{

this(mat.length,mat[0].length);

for (int i=0; imat.length; i++)

for (int j=0; jmat[i].length; j++)

this.value[i][j] = mat[i][j];

}

public int get(int i, int j) //获得矩阵第i行第j列的元素，O(1)

{

return value[i][j];

}

public void set(int i, int j, int k) //设置矩阵第i行第j列的元素，O(1)

{

value[i][j]=k;

}

public void add(Matrix b) //this和b两个矩阵相加，改变当前矩阵

{

for (int i=0; ithis.value.length; i++)

for (int j=0; jthis.value[i].length; j++)

this.value[i][j] += b.value[i][j];

}

public String toString() //行主序遍历，访问矩阵全部元素

{

String str="";

for (int i=0; ivalue.length; i++)

{

for (int j=0; jvalue[i].length; j++)

str += " "+value[i][j];

str += "\n";

}

return str;

}

public Matrix transpose() //矩阵的转置

{

Matrix trans = new Matrix(value[0].length, value.length);

for (int i=0; ithis.value.length; i++)

for (int j=0; jthis.value[i].length; j++)

trans.value[j][i]=this.value[i][j];

return trans;

}

//判断一个矩阵是否为上三角矩阵

public boolean isUpperTriangularMatrix() {

int i, j = 0;

int c = this.value[1][0];

for(i=1; ithis.value.length; i++)

for(j=0; ji; j++)

if(this.value[i][j] != c)

break;

if(i=this.value.length)

return true;

return false;

}

//判断一个矩阵是否为下三角矩阵

public boolean isLowerTriangularMatrix() {

int i, j = 0;

int c = this.value[0][1];

for(i=0; ithis.value.length-1; i++)

for(j=i+1; jthis.value[0].length; j++)

if(this.value[i][j] != c)

break;

if(i=this.value.length-1)

return true;

return false;

}

//判断一个矩阵是否为对称矩阵

public boolean isSymmetricMatrix () {

int i, j = 0;

for(i=1; ithis.value.length; i++)

for(j=0; ji; j++)

if(this.value[i][j] != this.value[j][i])

break;

if(i=this.value.length)

return true;

return false;

}

//比较两个矩阵是否相等

public boolean equals(Matrix b) {

int i, j = 0;

if(this.value.length != b.value.length || this.value[0].length != b.value[0].length)

return false;

for(i=0; ithis.value.length; i++)

for(j=0; jthis.value[0].length; j++)

if(this.value[i][j] != b.value[j][i])

break;

if(i=this.value.length)

return true;

return false;

}

//计算两个矩阵的乘积

public Matrix multiply(Matrix b){

int i, j, k;

int sum;

Matrix mtr;

if(this.value[0].length != b.value.length) {

return null;

}

mtr = new Matrix(this.value.length, b.value[0].length);

for(i=0; ithis.value.length; i++)

{

for(k=0; kb.value[0].length; k++){

for(sum=0,j=0; jthis.value[0].length; j++){

sum += this.value[i][j] * b.value[j][k];

mtr.value[i][k] = sum;

}

return mtr;

}

public class Test

{

public static void main(String args[])

{

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

Matrix a=new Matrix(m1);

int m2[][]={{1,0,0},{0,1,0}};

Matrix b=new Matrix(m2);

System.out.print("Matrix a:\n"+a.toString());

System.out.print("Matrix b:\n"+b.toString());

a.add(b);

System.out.print("Matrix a:\n"+a.toString());

System.out.println("a的转置矩阵：\n"+a.transpose().toString());

int m3[][] = {{1,2,1},{0,3,1},{0,0,2}};

int m4[][] = {{1,0,0},{2,1,0},{3,2,1}};

int m5[][] = {{1,0,2},{0,1,0},{2,0,2}};

Matrix mtr1 = new Matrix(m3);

Matrix mtr2 = new Matrix(m4);

Matrix mtr3 = new Matrix(m5);

if(mtr1.isUpperTriangularMatrix())

System.out.println("上三角矩阵：\n" + mtr1.toString());

if(mtr2.isLowerTriangularMatrix())

System.out.println("下三角矩阵：\n" + mtr2.toString());

if(mtr3.isSymmetricMatrix())

System.out.println("对称矩阵：\n" + mtr3.toString());

System.out.println(mtr1.toString() + "\n乘以\n" + mtr2.toString() + "\n=\n");

Matrix tempM = mtr1.multiply(mtr2);

System.out.println(tempM.toString());

}

关于矩阵计算java和矩阵计算题及答案的介绍到此就结束了，不知道你从中找到你需要的信息了吗？如果你还想了解更多这方面的信息，记得收藏关注本站。

The End

发布于：2022-11-22，除非注明，否则均为首码项目网原创文章，转载请注明出处。

标签：矩阵计算java

本文目录一览：

用java语言做矩阵运算，输入一个m×n的矩阵，再输入一个n×o的矩阵，求其乘积。

用Java线程编写矩阵相乘的计算程序.

用java怎么写矩阵乘法？

Java编写一个程序实现矩阵的运算加减乘除，（并对其中的异常进行处理）

Java矩阵算法？

java实现矩阵相加、相乘，判断是否上（下）三角矩阵、对称矩阵、相等的算法

相关文章