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、加法
2、减法
3、乘法
4、求矩阵的特征值和特征向量
5、退出");
            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”结束，如：
"
                + "1,2,3
"
                + "2,3,4
"
                + "3,4,5
"
                + "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());        
    }
    
    
}

所有的计算封装在在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]+"	");
            }
            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;
    }
}

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

 运行结果为：