矩阵和java代码

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

/**

*?矩阵：由?m?X?n?个数Aij排成的m行n列的数表称为m行n列的矩阵,简称m?X?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)?{

//两个矩阵的乘法仅当第一个矩阵A的列数和另一个矩阵B的行数相等时才能定义.如A是mXn矩阵和B是nXp矩阵,它们的乘积C是一个mXp矩阵?

int?col?=?summand[0].length;

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

}?

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]);

java中求两个矩阵相乘,编写的代码不知道哪里错了,求大神指点一下.

应该改为：

System.out.print("The multiplication of the matrices is"这行代码的前面就可以了.

用JAVA写一个矩阵类

昨天刚帮一个网友改编的,输出矩阵并且在矩阵求幂后输出矩阵的一个类,直接可以运行.

注释都有的.希望你用的得到.import java.util.Scanner;

public class JuZhen {

//定义计算方法

public static int calc(int x, int y,int score){

if(x==0 y==0){

score = 0;

}else {

score = 1;

return score;

//输入矩阵

public static void shuru(){

Scanner input = new Scanner(System.in);//Scanner是用来接纳系统控制台输的字符串的

System.out.print("请输入矩阵的阶数：");

int n = input.nextInt(); //取一个输入的字符赋值给n

int M[][] = new int[n][n]; //定义数组维数.初始化数组,定义了一个双向的长度为

//n的

System.out.print("请输入矩阵的的值(0-1)：");

for(int i=0;iM.length ;i++){ //不能以0开始

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

M[i][j] = input.nextInt();

System.out.println("你输入的矩阵为：");

for(int i=0;iM.length ;i++){ //显示矩阵

System.out.print("\n");

System.out .print(M[i][j] + "\t") ;

//仅仅是一个求幂的递归.

int myPow(int x, int y) {

int pow = 0;

if (y 0) {

pow = 1 / x * myPow(x, y + 1);

if (y == 0) {

pow = 1;

return pow;

//程序入口

public static void main(String[] args){

Scanner input = new Scanner(System.in);

int n = input.nextInt();//这个相当于确定行数.

int M[][] = new int[n][n];

//定义数组维数

for(int i=0;iM.length ;i++){ //外循环表示行,在外循环已知的情况下去填内循环,内循环表示列

int temp[][] =new int[n][n];

int m[][] =new int[n][n];

for(int i=0;iM.length ;i++){ //显示矩阵

System.out.print("\n"); //执行完外循环也就是打印出一行后换行

temp[i][j] = M[i][j] ; //赋给矩阵temp

System.out .print(M[i][j] + "\t") ;//执行完内循环也就是一列时空两格.\t为tab键起退格作用

System.out.print("\n\n你想求几次方：");

int c =input.nextInt(); //获得幂次

for (int k=0; kc;k++){ //最外层的循环和里边的两层循环也就是二维数组里的每个都有交集,也就是每个都要求幂

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

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

m[i][j]= new JuZhen().myPow(temp[i][j],c);

}//for k

for(int i=0;im.length ;i++){ //显示矩阵

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

System.out .print(m[i][j] + "\t") ;

}//main

}//class JuZhen

用java编程:实现两个矩阵相加.

封装性不用担心,java正是以其良好的封装性著称.

小可献丑了：

//没有仔细调试,按照提示输入数据

//每一行(Row)数据用空格隔开,结束后回车

import java.io.*;

import java.util.*;

public class Arrtest{

public static void main(String args[]){

try{

System.out.print("set the row of the arr:\n");

BufferedReader in=new BufferedReader(

new InputStreamReader(System.in));

String row=in.readLine();

System.out.print("set the line of the arr:\n");

int R=Integer.parseInt(row);

int L=Integer.parseInt(line);

Arr arr=new Arr();

System.out.print("Great the first arr:\n");

double arr1[][]=arr.greatArr(R,L);

System.out.print("Great the second arr:\n");

}catch(Exception e){e.getMessage(); }

class Arr {

double[][] greatArr(int row,int line){

double arr[][]=new double[row][line];

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

System.out.print("input the row("+(i+1)+") numbers:\n");

String s=in.readLine();

StringTokenizer s_part=new StringTokenizer(s," ");

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

arr[i][j]=Double.parseDouble(s_part.nextToken());

return arr;

return arr1;

void showArr(double[][] arr,int row,int line){

System.out.print("the result:\r\n");

System.out.print(arr[i][j]+" ");

System.out.print("\r\n");

用java：利用二维数组,任意给出一个矩阵,编写实现矩阵转置的代码

借花献佛

*?实现二维数组的转置

*

public?static?void?main(String[]?args)?{

/*StaticTest?st1=new?StaticTest();

/*****定义要用于转置的二维数组*******/

/*****构造结果新二维数组用于存放转置结果*******/

/*定义结果数组变量,注意?一定要先开辟一个内存,

否则只是地址传递,也就是说两个数组名实际上指向的是同一块内存*/

//而构造二维数组可以为维度来进行,不一定是一个矩阵,即每一行的长度不一定相同

//上面这个命令行行不通！

/*****输出用于转置的二维数组*******/

for(int?e:x){

System.out.print(e+"?");

System.out.println();

/*******进行元素倒置******/

/*****show?the?result?in?the?result?matrix*******/

for?(int?x[]:result_arr){

//import?java.util.Arrays;

//

//public?static?void?main(String[]?args)?{

///*定义结果数组变量,注意?一定要先开辟一个内存,

//否则只是地址传递,也就是说两个数组名实际上指向的是同一块内存*/

//}

//??//?进行元素倒置

//??}

//??

//??//?show?the?result?in?matrix

//??for?(int?x[]:result_arr){

//??for(int?e:x){

//??System.out.print(e);

//??System.out.println();

以上就是土嘎嘎小编为大家整理的矩阵和java代码相关主题介绍,如果您觉得小编更新的文章只要能对粉丝们有用,就是我们最大的鼓励和动力,不要忘记讲本站分享给您身边的朋友哦！！