java语言编写矩阵的四则运算

题目要求如下：

　　设计程序实现矩阵的四则运算

　　设计要求：

　　(1) 实现矩阵的四则运算。

　　(2) 考虑实现带变元的矩阵计算。

　　(3)考虑实现矩阵的特征值和特征向量的计算。

我使用java语言写的

目录结构如下所示：

　　

Matrix类是对矩阵的建模，我用一个String类型的二维数组存放矩阵的元素，除此之外还有矩阵的行数和列数两个属性。代码如下：

 package org.java.pojo;

 public class Matrix {
     private String matrix[][];
     private int row;
     private int line;
     public String[][] getMatrix() {
         return matrix;
     }
     public void setMatrix(String[][] matrix) {
         this.matrix = matrix;
     }
     public int getRow() {
         return row;
     }
     public void setRow(int row) {
         this.row = row;
     }
     public int getLine() {
         return line;
     }
     public void setLine(int line) {
         this.line = line;
     }
 }

所有的调用逻辑写在在Begin.java里面，这里根据用户的选择，调用相应的方法。

具体的代码为：

 package org.java.main;

 import java.util.Scanner;

 import org.java.dao.Caculate;
 import org.java.pojo.Matrix;
 public class Begin {
     public static Scanner scan = new Scanner(System.in);
     public static void main(String[] args){
         int chooseChar=0;
         while(chooseChar!=5){
             System.out.println("请选择要执行的运算");
             System.out.println("1、加法\n2、减法\n3、乘法\n4、求矩阵的特征值和特征向量\n5、退出");
             try {
                 chooseChar=scan.nextInt();
                 scan.nextLine();//用于处理输入结束之后的回车，否则会影响后面的输入
             } catch (Exception e) {
                 e.printStackTrace();
             }
             Begin beg=new Begin();
             switch(chooseChar){
                 case 1:{
                     beg.addOperation();
                     break;
                 }
                 case 2:{
                     beg.reduceOperation();
                     break;
                 }
                 case 3:{
                     beg.multiplyOperation();
                     break;
                 }
                 case 4:{
                     beg.complexOperation();
                     break;
                 }
             }
             if(chooseChar==5){
                 System.out.println("已停止工作");
             }
         }
     }
     public static void  publicPrint() {
         System.out.println("请输入矩阵，元素之间用逗号隔开，可以有变元，输入“quit”结束，如：\n"
                 + "1,2,3\n"
                 + "2,3,4\n"
                 + "3,4,5\n"
                 + "quit");
     }

     /**
      * 65~90:A~Z
      * 97~122:a~z
      * 选择加
      * @param list
      */
     public void addOperation(){
         System.out.println("您选择的是矩阵的加法运算，注意两个矩阵行数和列数要相等");
         Caculate caculate=new Caculate();
         publicPrint();
         Matrix matrix1=caculate.inputMatrix();
         System.out.println("请输入下一个矩阵：");
         Matrix matrix2=caculate.inputMatrix();
         Matrix matrix=null;
         try {
             matrix=caculate.addOperation(matrix1, matrix2);//调用封装方法计算
         } catch (Exception e) {
             e.printStackTrace();
         }
         System.out.println("运算结果为：");
         caculate.printMatrix(matrix);
     }

     /**
      * 65~90:A~Z
      * 97~122:a~z
      * 选择减
      * @param list
      */
     public void reduceOperation(){
         System.out.println("您选择的是矩阵的减法运算，注意两个矩阵行数和列数要相等");
         Caculate caculate=new Caculate();
         publicPrint();
         Matrix matrix1=caculate.inputMatrix();
         System.out.println("请输入下一个矩阵：");
         Matrix matrix2=caculate.inputMatrix();
         Matrix matrix=null;
         try {
             matrix=caculate.reduceOperation(matrix1, matrix2);//调用封装方法计算
         } catch (Exception e) {
             e.printStackTrace();
         }
         System.out.println("运算结果为：");
         caculate.printMatrix(matrix);
     }

     /**
      * 65~90:A~Z
      * 97~122:a~z
      * 选择乘
      * @param list
      */
     public void multiplyOperation(){
         System.out.println("您选择的是矩阵的乘法运算，注意第一个矩阵的列数要和第二个矩阵的行数相等");
         Caculate caculate=new Caculate();
         publicPrint();
         Matrix matrix1=caculate.inputMatrix();
         System.out.println("请输入下一个矩阵：");
         Matrix matrix2=caculate.inputMatrix();
         Matrix matrix=null;
         try {
             matrix=caculate.multiplyOperation(matrix1, matrix2);//调用封装方法计算
         } catch (Exception e) {
             e.printStackTrace();
         }
         System.out.println("运算结果为：");
         caculate.printMatrix(matrix);
     }
     /**
      * 65~90:A~Z
      * 97~122:a~z
      * 选择特征值特征向量
      * @param list
      */
     public void complexOperation(){
         System.out.println("您选择的是计算矩阵的特征值特征向量");
         Caculate caculate=new Caculate();
         publicPrint();
         Matrix matrix=caculate.inputMatrix();
         System.out.println("运算结果为：");
         MatrixEigenValue.caculateEigen(matrix.getMatrix());
     }

 }

Begin.java

所有的计算封装在在Caculate.java里面，这里包含了矩阵的输入生成和矩阵的运算。里面的方法为：

具体的代码为：

 package org.java.dao;

 import java.util.ArrayList;
 import java.util.Scanner;

 import org.java.pojo.Matrix;

 public class Caculate {
     /**
      * 从输入到创建一个矩阵
      * @return
      */
     public Matrix inputMatrix(){
         @SuppressWarnings("resource")
         Scanner scan = new Scanner(System.in);
         ArrayList<String> list=new ArrayList<String>();//用来存放用户的输入
         String firstString=scan.nextLine();
         while(!firstString.equals("quit")){
             if(!"".equals(firstString))
                 list.add(firstString);
             firstString=scan.nextLine();
         }
         int row=list.size();//获得矩阵的行数
         int line=list.get(0).split(",").length;//获得矩阵列数
         for(int i=1;i<row;++i){
             if(line!=(list.get(i).split(",").length)){
                 System.out.println("每行的元素个数不相等");
                 System.exit(0);
                 return null;
             }
         }
         Matrix matrix=new Matrix();
         matrix.setRow(row);
         matrix.setLine(line);
         String matrixString[][]=new String[row][line];
         int i=0,j=0;
         for (String string : list) {//分出每一行
             String tempString[]=string.split(",");
             for (String str : tempString) {
                 matrixString[i][j]=str.trim();//删除空格
                 ++j;
             }
             if(j==line)
                 j=0;
             ++i;
         }
         matrix.setMatrix(matrixString);
         return matrix;
     }

     /**
      * 输出矩阵
      * @param matrix
      */
     public void printMatrix(Matrix matrix){
         String matrixString[][]=matrix.getMatrix();
         for(int i=0;i<matrix.getRow();++i){
             for(int j=0;j<matrix.getLine();++j){
                 System.out.print(matrixString[i][j]+"\t");
             }
             System.out.println();
         }
     }

     /**
      * 矩阵加法
      * @param matrix1
      * @param matrix2
      * @return
      * @throws Exception
      */
     @SuppressWarnings("null")
     public Matrix addOperation(Matrix matrix1,Matrix matrix2) throws Exception{
         //如果输入有误，则停止运算
         if(matrix1==null){
             throw new Exception();
         }
         //如果输入有误，则停止运算
         if(matrix2==null){
             throw new Exception();
         }
         //计算---首先判断一下两个矩阵行和列的关系是否可以计算
         if(matrix1.getRow()!=matrix2.getRow()||matrix1.getLine()!=matrix2.getLine()){
             System.out.println("两个矩阵行不满足运算要求");
             throw new Exception();
         }
         Matrix matrix=new Matrix();
         matrix.setRow(matrix1.getRow());
         matrix.setLine(matrix1.getLine());
         //执行运算
         String[][]matString1=matrix1.getMatrix();
         String[][]matString2=matrix2.getMatrix();
         String[][]matString=new String[matrix.getRow()][matrix.getLine()];//结果矩阵的数组
         for(int i=0;i<matrix.getRow();++i){
             for(int j=0;j<matrix.getLine();++j){
                 if(!isNumber(matString1[i][j])||!isNumber(matString2[i][j])){
                     matString[i][j]=matString1[i][j]+"+"+matString2[i][j];
                 }else{
                     //将结果再转换成string
                     //转换成float的值相加减
                     float result=Float.parseFloat(matString1[i][j])+Float.parseFloat(matString2[i][j]);
                     matString[i][j]=String.valueOf(result);
                 }
             }

         }
         matrix.setMatrix(matString);
         return matrix;
     }
     /**
      *
      * 减
      * @param matrix1
      * @param matrix2
      * @return
      * @throws Exception
      */
     public Matrix reduceOperation(Matrix matrix1,Matrix matrix2)throws Exception{
         //如果输入有误，则停止运算
         if(matrix1==null){
             throw new Exception();
         }
         //如果输入有误，则停止运算
         if(matrix2==null){
             throw new Exception();
         }
         //计算---首先判断一下两个矩阵行和列的关系是否可以计算
         if(matrix1.getRow()!=matrix2.getRow()||matrix1.getLine()!=matrix2.getLine()){
             System.out.println("两个矩阵行不满足运算要求");
             throw new Exception();
         }
         Matrix matrix=new Matrix();
         matrix.setRow(matrix1.getRow());
         matrix.setLine(matrix1.getLine());
         //执行运算
         String[][]matString1=matrix1.getMatrix();
         String[][]matString2=matrix2.getMatrix();
         String[][]matString=new String[matrix.getRow()][matrix.getLine()];//结果矩阵的数组
         for(int i=0;i<matrix.getRow();++i){
             for(int j=0;j<matrix.getLine();++j){
                 if(!isNumber(matString1[i][j])||!isNumber(matString2[i][j])){
                     matString[i][j]=matString1[i][j]+"-"+matString2[i][j];
                 }else{
                     //将结果再转换成string
                     //转换成float的值相加减
                     float result=Float.parseFloat(matString1[i][j])-Float.parseFloat(matString2[i][j]);
                     matString[i][j]=String.valueOf(result);
                 }
             }

         }
         matrix.setMatrix(matString);
         return matrix;
     }

     /**
      * 乘
      * @param matrix1
      * @param matrix2
      * @return
      * @throws Exception
      */
     public Matrix multiplyOperation(Matrix matrix1,Matrix matrix2)throws Exception{
         //如果输入有误，则停止运算
                 if(matrix1==null){
                     throw new Exception();
                 }
                 //如果输入有误，则停止运算
                 if(matrix2==null){
                     throw new Exception();
                 }
                 //计算---首先判断一下两个矩阵行和列的关系是否可以计算
                 if(matrix1.getLine()!=matrix2.getRow()){
                     System.out.println("两个矩阵行不满足运算要求");
                     throw new Exception();
                 }
                 Matrix matrix=new Matrix();
                 matrix.setRow(matrix1.getRow());//结果矩阵行数等于第一个矩阵行数，列数等于第二个矩阵列数
                 matrix.setLine(matrix2.getLine());
                 //执行运算
                 String[][]matString1=matrix1.getMatrix();
                 String[][]matString2=matrix2.getMatrix();
                 String[][]matString=new String[matrix.getRow()][matrix.getLine()];//结果矩阵的数组
                 int sameNum=matrix1.getLine();//=matrix2.getRow()
                 for(int i=0;i<matrix.getRow();++i){
                     for(int j=0;j<matrix.getLine();++j){
                         matString[i][j]="";
                         for(int k=0;k<sameNum;++k){
                             matString[i][j]+=matString1[i][k]+"*"+matString2[k][j]+"+";
                         }
                         matString[i][j]=doAnalyze(matString[i][j]);//把计算式合并同类项并计算，重新赋给矩阵相应元素
                     }
                 }
                 matrix.setMatrix(matString);
                 return matrix;
     }

     /**
      * 把形如“1*1+2*1+3*1+”的式子进行分析计算
      * 返回处理结果
      * @param toAnalizeString
      * @return
      */
     public String doAnalyze(String toAnalizeString){
         String disAdd[]=toAnalizeString.split("\\+");//“+”是转义字符
         int addLength=disAdd.length;//获取有几项相加
         String disMul[][]=new String[addLength][2];//所有项都在这一个二维数组里面了
         for (int i = 0; i < disAdd.length; i++) {
             disMul[i]=disAdd[i].split("\\*");
         }
         //移项，先不考虑系数为0的情况
         for(int i = 0; i < disMul.length; i++){

             if(isNumber(disMul[i][0])){
                 if(isNumber(disMul[i][1])){
                     //都是数字，让第一项等于两数运算结果，第二项等于0
                     float result=Float.parseFloat(disMul[i][0])*Float.parseFloat(disMul[i][1]);
                     disMul[i][0]=String.valueOf(result);
                     disMul[i][1]="0";
                 }else{
                     //一是二不是，不用做什么
                 }
             }else{
                 if(isNumber(disMul[i][1])){
                     //一不是二是，互换
                     String tempString=disMul[i][0];
                     disMul[i][0]=disMul[i][1];
                     disMul[i][1]=tempString;
                 }else{
                     //都不是数字，让第一项等于1，第二项等于两数运算结果
                     if(disMul[i][0].equals(disMul[i][1])){
                         disMul[i][1]=disMul[i][1]+"^2";
                     }else{//按abc顺序写
                         if(disMul[i][0].compareTo(disMul[i][1])>0){
                             disMul[i][1]=disMul[i][1]+""+disMul[i][0];
                         }else{
                             disMul[i][1]=disMul[i][0]+""+disMul[i][1];
                         }
                     }
                     disMul[i][0]="1";
                 }
             }
         }//移项完成

         //合并同类项，算法会处理系数为0的情况
         for(int i = 0; i < disMul.length-1; i++){
             for(int j=i+1;j<disMul.length;j++){
                 if(!disMul[i][0].equals("0")){
                     if(disMul[i][1].equals(disMul[j][1])){//如果是同类项，系数相加，赋值给上面的系数，下面的系数置为0
                         disMul[i][0]=String.valueOf(Float.parseFloat(disMul[i][0])+Float.parseFloat(disMul[j][0]));
                         disMul[j][0]="0";
                     }
                 }
             }
         }//合并同类项完成

         //写成多项式的形式，用result拼接
         String result="";
         for(int i = 0; i < disMul.length; i++){
             if(!disMul[i][0].equals("0")){//忽略为0的项
                 if(disMul[i][1].equals("0")){//如果是常数项
                     result+=disMul[i][0]+"+";
                 }else{
                     result+=disMul[i][0]+disMul[i][1]+"+";
                 }
             }
         }
         result=result.substring(0, result.length()-1);//删除最后一个“+”号
         return result;
     }

     /**
      * 判断矩阵的一个元素是字母还是数字
      * @param str
      * @return
      */
     public boolean isNumber(String str){
         for (int i = 0; i < str.length(); i++){
             if (!Character.isDigit(str.charAt(i))){
                 return false;
             }
         }
         return true;
     }
 }

Caculate.java

程序的亮点是矩阵的元素可以是字母，计算的时候能合并同类项，缺点是由于存储结构的限制不能计算有负数元素的矩阵，这个在后面如果有时间我会改，补发一个。

运行结果为：