JavaSE基础之矩阵运算

Posted 2020-09-08 勇闯天涯zfc

JavaSE基础之矩阵运算

1、矩阵类：Matrix.java

包括矩阵的加、乘运算，行列式的求解，最大最小元素等

 

package cn.com.zfc.help;

 

import java.text.DecimalFormat;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;

 

/**
*
* @title Matrix
* @describe 矩阵运算
* @author 张富昌
* @date 2017年3月21日下午6:45:00
*/
public class Matrix {
　　// 使用二维数组模拟矩阵
　　private int[][] matrix;
　　private int row;
　　private int cel;

 

　　/**
　　* 构造方法
　　*
　　* @param row：矩阵的行数
　　* @param cel：矩阵的列数
　　*/
　　public Matrix(int row, int cel) {
　　　　this.row = row;
　　　　this.cel = cel;
　　　　// 初始化数组
　　　　matrix = new int[this.row][this.cel];
　　}

 

　　// 为私有属性添加 setter()和getter()方法：赋值，取值
　　public int getRow() {
　　　　return row;
　　}

 

　　public void setRow(int row) {
　　　　this.row = row;
　　}

 

　　public int getCel() {
　　　　return cel;
　　}

 

　　public void setCel(int cel) {
　　　　this.cel = cel;
　　}

 

　　public int[][] getMatrix() {
　　　　return matrix;
　　}

 

　　public void setMatrix(int[][] matrix) {
　　　　this.matrix = matrix;
　　}

 

　　/**
　　* 快速初始化矩阵中的成员变量：二维数组
　　*/
　　public void initMatrix() {
　　　　Scanner scanner = new Scanner(System.in);
　　　　for (int i = 0; i < this.getRow(); i++) {
　　　　　　for (int j = 0; j < this.getCel(); j++) {
　　　　　　　　// 自己输入
　　　　　　　　// matrix[i][j] = scanner.nextInt();
　　　　　　　　// 生成一个 0-100 的随机数
　　　　　　　　matrix[i][j] = (int) (Math.random() * 100 + 1);
　　　　　　　　// 在测试矩阵中元素的种类及其个数时，不用随机赋值，即注释上一行代码
　　　　　　　　// matrix[i][j] = i;
　　　　　　}
　　　　}
　　}

 

　　/**
　　* 输出矩阵
　　*/
　　public void printMatrix() {
　　　　for (int i = 0; i < this.getRow(); i++) {
　　　　　　for (int j = 0; j < this.getCel(); j++) {
　　　　　　　　System.out.print(matrix[i][j] + "\t");
　　　　　　}
　　　　　　System.out.println();
　　　　}
　　}

 

　　/**
　　*
　　* @param matrix1：第一个矩阵
　　* @param matrix2：第二个矩阵
　　* @return：两个矩阵相加之后的矩阵
　　*/
　　public Matrix addMatrix(Matrix matrix1, Matrix matrix2) {
　　　　if ((matrix1.getRow() == matrix2.getRow()) && (matrix1.getCel() == matrix2.getCel())) {
　　　　　　// 中间矩阵，相加之后的结果
　　　　　　Matrix m = new Matrix(matrix1.getRow(), matrix2.getCel());

 

　　　　　　for (int i = 0; i < m.getRow(); i++) {
　　　　　　　　for (int j = 0; j < m.getCel(); j++) {
　　　　　　　　　　m.getMatrix()[i][j] = matrix1.getMatrix()[i][j] + matrix2.getMatrix()[i][j];
　　　　　　　　}
　　　　　　}
　　　　　　return m;
　　　　} else {
　　　　　　return null;
　　　　}

 

　　}

 

　　/**
　　*
　　* @param matrix1：第一个矩阵
　　* @param matrix2：第二个矩阵
　　* @return：两个矩阵相乘之后的矩阵
　　*/
　　public Matrix mulMatrix(Matrix matrix1, Matrix matrix2) {
　　　　if (matrix1.getRow() == matrix2.getCel()) {

 

　　　　　　Matrix m = new Matrix(matrix1.getRow(), matrix2.getCel());

 

　　　　　　for (int i = 0; i < matrix1.getRow(); i++) {
　　　　　　　　for (int j = 0; j < matrix2.getCel(); j++) {
　　　　　　　　　　int sum = 0;
　　　　　　　　　　for (int k = 0; k < matrix1.getCel(); k++) {
　　　　　　　　　　　　sum += matrix1.getMatrix()[i][k] * matrix2.getMatrix()[k][j];
　　　　　　　　　　}
　　　　　　　　　　m.getMatrix()[i][j] = sum;
　　　　　　　　}
　　　　　　}
　　　　　　return m;
　　　　} else {
　　　　　　return null;
　　　　}
　　}

 

　　/**
　　* 矩阵转置
　　*
　　* @param matrix
　　* @return 转置后的矩阵
　　*/
　　public Matrix reverse(Matrix matrix) {

 

　　　　Matrix m = new Matrix(matrix.getCel(), matrix.getRow());

 

　　　　for (int i = 0; i < m.getCel(); i++) {

 

　　　　　　for (int j = 0; j < m.getRow(); j++) {

 

　　　　　　　　m.getMatrix()[j][i] = matrix.getMatrix()[i][j];
　　　　　　}
　　　　}
　　　　return m;
　　}

 

　　/**
　　*
　　* @param matrix
　　* @return：返回最大的值
　　*/
　　public int getMaxNumber(Matrix matrix) {
　　　　// 设置假设的默认的最大值（一般不是）
　　　　int max = matrix.getMatrix()[0][0];

 

　　　　for (int i = 0; i < matrix.getRow(); i++) {
　　　　　　for (int j = 0; j < matrix.getCel(); j++) {
　　　　　　　　if (max < matrix.getMatrix()[i][j]) {
　　　　　　　　　　max = matrix.getMatrix()[i][j];
　　　　　　　　}
　　　　　　}
　　　　}
　　　　return max;
　　}

 

　　/**
　　*
　　* @param matrix
　　* @return：返回最小的值
　　*/
　　public int getMinNumber(Matrix matrix) {
　　　　int min = matrix.getMatrix()[0][0];
　　　　for (int i = 0; i < matrix.getRow(); i++) {
　　　　　　for (int j = 0; j < matrix.getCel(); j++) {
　　　　　　　　if (min > matrix.getMatrix()[i][j]) {
　　　　　　　　　　min = matrix.getMatrix()[i][j];
　　　　　　　　}
　　　　　　}
　　　　}
　　　　return min;
　　}

 

　　/**
　　*
　　* @param matrix
　　* @return：每一行元素的最大值组成的数组
　　*/
　　public int[] getEachRowMax(Matrix matrix) {
　　　　int[] arr = new int[matrix.getRow()];
　　　　for (int i = 0; i < matrix.getRow(); i++) {
　　　　　　// 找出每一行的最大值
　　　　　　// 中间变量
　　　　　　int temp = matrix.getMatrix()[i][0];
　　　　　　for (int j = 0; j < matrix.getCel(); j++) {
　　　　　　　　if (temp < matrix.getMatrix()[i][j]) {
　　　　　　　　　　temp = matrix.getMatrix()[i][j];
　　　　　　　　}
　　　　　　}
　　　　　　arr[i] = temp;
　　　　}
　　　　return arr;
　　}

 

　　/**
　　*
　　* @param matrix
　　* @return：每一行的最小值
　　*/
　　public int[] getEachRowMin(Matrix matrix) {
　　　　int[] arr = new int[matrix.getRow()];
　　　　for (int i = 0; i < matrix.getRow(); i++) {
　　　　　　// 找出每一行的最小值
　　　　　　// 中间变量
　　　　　　int temp = matrix.getMatrix()[i][0];
　　　　　　for (int j = 0; j < matrix.getCel(); j++) {
　　　　　　　　if (temp > matrix.getMatrix()[i][j]) {
　　　　　　　　　　temp = matrix.getMatrix()[i][j];
　　　　　　　　}
　　　　　　}
　　　　　　arr[i] = temp;
　　　　　}
　　　　return arr;
　　　}

 

　　/**
　　*
　　* @param matrix
　　* @return：每一列元素的最小值组成的数组
　　*/
　　public int[] getEachCelMin(Matrix matrix) {
　　　　// 先转置
　　　　Matrix m = matrix.reverse(matrix);
　　　　// 后求每一行的最小值
　　　　int[] arr = m.getEachRowMin(m);
　　　　return arr;
　　}

 

　　public Matrix sort(Matrix matrix) {
　　　　Matrix m = new Matrix(matrix.getRow(), matrix.getCel());
　　　　m.setMatrix(matrix.getMatrix());
　　　　// 中间变量，用来存放矩阵的元素
　　　　int[] arr = new int[m.getRow() * m.getCel()];
　　　　int count = 0;
　　　　// 将二维数组转化为一维数组
　　　　for (int i = 0; i < m.getRow(); i++) {
　　　　　　for (int j = 0; j < m.getCel(); j++) {
　　　　　　　　arr[count] = m.getMatrix()[i][j];
　　　　　　　　count++;
　　　　　　}
　　　　}
　　　　// 对一维数组进行排序：冒泡排序
　　　　arr = bubbleSort(arr);
　　　　for (int i = 0; i < m.getRow(); i++) {
　　　　　　for (int j = 0; j < m.getCel(); j++) {
　　　　　　　　count--;
　　　　　　　　m.getMatrix()[i][j] = arr[count];
　　　　　　}
　　　　}
　　　　return m;
　　}

 

　　/**
　　*
　　* 功能：冒泡排序的基本思想就是不断比较相邻的两个数，让较大的元素不断地往后移。经过一轮比较，就选出最大的数；经过第2轮比较，就选出次大的数，
　　* 以此类推。
　　*
　　*
　　* 参数：int[] array
　　*
　　* 返回类型：int[]
　　*/
　　public int[] bubbleSort(int[] array) {
　　　　// 使用临时数组，替代原始数组
　　　　int[] arr = array;
　　　　for (int i = 0; i < arr.length; i++) {
　　　　　　for (int j = 0; j < arr.length - 1 - i; j++) {
　　　　　　　　if (arr[j] < arr[j + 1]) {
　　　　　　　　　　int temp = arr[j];
　　　　　　　　　　arr[j] = arr[j + 1];
　　　　　　　　　　arr[j + 1] = temp;
　　　　　　　　}
　　　　　　}
　　　　}
　　　　return arr;
　　}

 

　　public Map<Integer, Integer> getElementAndCount(Matrix matrix) {
　　　　// 存放的是键值对， 1-3 ，2-4
　　　　Map<Integer, Integer> map = new HashMap<>();
　　　　// 判断重复的元素
　　　　Set<Integer> set = new HashSet<>();
　　　　for (int i = 0; i < matrix.getRow(); i++) {
　　　　　　for (int j = 0; j < matrix.getCel(); j++) {
　　　　　　　　if (set.add(matrix.getMatrix()[i][j])) {
　　　　　　　　　　map.put(matrix.getMatrix()[i][j], 1);
　　　　　　　　} else {
　　　　　　　　　　map.replace(matrix.getMatrix()[i][j], map.get(matrix.getMatrix()[i][j]) + 1);
　　　　　　　　}
　　　　　　}
　　　　}
　　　　return map;
　　}

 

　　public void showType() {
　　　　System.out.println("-------------------------------------");
　　}

 

　　/***
　　* 求行列式的算法
　　*
　　* @param value
　　* 需要算的行列式
　　* @return 计算的结果
　　*/
　　public int mathDeterminantCalculation(int[][] value) throws Exception {
　　　　if (value.length == 1) {
　　　　　　// 当行列式为1阶的时候就直接返回本身
　　　　　　return value[0][0];
　　　　} else if (value.length == 2) {
　　　　　　// 如果行列式为二阶的时候直接进行计算
　　　　　　return value[0][0] * value[1][1] - value[0][1] * value[1][0];
　　　　}
　　　　// 当行列式的阶数大于2时
　　　　int result = 1;
　　　　for (int i = 0; i < value.length; i++) {
　　　　　　// 检查数组对角线位置的数值是否是0，如果是零则对该数组进行调换，查找到一行不为0的进行调换
　　　　　　if (value[i][i] == 0) {
　　　　　　　　value = changeDeterminantNoZero(value, i, i);
　　　　　　　　result *= -1;
　　　　　　}
　　　　　　for (int j = 0; j < i; j++) {
　　　　　　　　// 让开始处理的行的首位为0处理为三角形式
　　　　　　　　// 如果要处理的列为0则和自己调换一下位置，这样就省去了计算
　　　　　　　　if (value[i][j] == 0) {
　　　　　　　　　　continue;
　　　　　　　　}
　　　　　　　　// 如果要是要处理的行是0则和上面的一行进行调换
　　　　　　　　if (value[j][j] == 0) {
　　　　　　　　　　int[] temp = value[i];
　　　　　　　　　　value[i] = value[i - 1];
　　　　　　　　　　value[i - 1] = temp;
　　　　　　　　　　result *= -1;
　　　　　　　　　　continue;
　　　　　　　　}
　　　　　　　　int ratio = -(value[i][j] / value[j][j]);
　　　　　　　　value[i] = addValue(value[i], value[j], ratio);
　　　　　　}
　　　　}
　　　　DecimalFormat df = new DecimalFormat(".##");
　　　　return Integer.parseInt(df.format(mathValue(value, result)));
　　}

 

　　/**
　　* 计算行列式的结果
　　*
　　* @param value
　　* @return
　　*/
　　public int mathValue(int[][] value, int result) throws Exception {
　　　　for (int i = 0; i < value.length; i++) {
　　　　　　// 如果对角线上有一个值为0则全部为0，直接返回结果
　　　　　　if (value[i][i] == 0) {
　　　　　　　　return 0;
　　　　　　}
　　　　　　result *= value[i][i];
　　　　}
　　　　return result;
　　}

 

　　/***
　　* 将i行之前的每一行乘以一个系数，使得从i行的第i列之前的数字置换为0
　　*
　　* @param currentRow
　　* 当前要处理的行
　　* @param frontRow
　　* i行之前的遍历的行
　　* @param ratio
　　* 要乘以的系数
　　* @return 将i行i列之前数字置换为0后的新的行
　　*/
　　public int[] addValue(int[] currentRow, int[] frontRow, int ratio) throws Exception {
　　　　for (int i = 0; i < currentRow.length; i++) {
　　　　　　currentRow[i] += frontRow[i] * ratio;
　　　　}
　　　　return currentRow;
　　}

 

　　/**
　　* 指定列的位置是否为0，查找第一个不为0的位置的行进行位置调换，如果没有则返回原来的值
　　*
　　* @param determinant
　　* 需要处理的行列式
　　* @param line
　　* 要调换的行
　　* @param row
　　* 要判断的列
　　*/
　　public int[][] changeDeterminantNoZero(int[][] determinant, int line, int row) throws Exception {
　　　　for (int j = line; j < determinant.length; j++) {
　　　　　　// 进行行调换
　　　　　　if (determinant[j][row] != 0) {
　　　　　　　　int[] temp = determinant[line];
　　　　　　　　determinant[line] = determinant[j];
　　　　　　　　determinant[j] = temp;
　　　　　　　　return determinant;
　　　　　　}
　　　　}
　　　　return determinant;
　　}

 

}

2、测试矩阵的一般性质：MatrixTest.java

package cn.com.zfc.help;

import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.Set;

/**
*
* @title MatrixTest
* @describe 测试矩阵
* @author 张富昌
* @date 2017年4月6日下午1:08:58
*/
public class MatrixTest {
　　public static void main(String[] args) {
　　　　Scanner scanner = new Scanner(System.in);
　　　　// 创建第一个矩阵
　　　　System.out.println("请输入第一个矩阵的行数：");
　　　　int row = scanner.nextInt();
　　　　System.out.println("请输入第一个矩阵的列数：");
　　　　int cel = scanner.nextInt();
　　　　Matrix matrix1 = new Matrix(row, cel);
　　　　// 初始化矩阵
　　　　matrix1.initMatrix();

　　　　System.out.println("第一个矩阵为：");
　　　　matrix1.printMatrix();
　　　　matrix1.showType();

　　　　// 矩阵转置
　　　　Matrix matrix = matrix1.reverse(matrix1);
　　　　System.out.println("转置之后的结果：");
　　　　matrix.printMatrix();
　　　　matrix1.showType();

　　　　// 矩阵中的最大元素
　　　　int max = matrix1.getMaxNumber(matrix1);
　　　　System.out.println("矩阵中的最大元素:" + max);
　　　　matrix1.showType();

　　　　// 矩阵中的最小元素
　　　　int min = matrix1.getMinNumber(matrix1);
　　　　System.out.println("矩阵中的最小元素:" + min);
　　　　matrix1.showType();

　　　　// 每一行的最大值
　　　　int[] maxs = matrix1.getEachRowMax(matrix1);
　　　　for (int i = 0; i < maxs.length; i++) {
　　　　　　System.out.println("第" + (i + 1) + "行的最大值是:" + maxs[i]);
　　　　}
　　　　matrix1.showType();

　　　　// 每一列的最小值
　　　　int[] mins = matrix1.getEachCelMin(matrix1);
　　　　for (int i = 0; i < mins.length; i++) {
　　　　　　System.out.println("第" + (i + 1) + "列的最小值是:" + mins[i]);
　　　　}
　　　　matrix1.showType();

　　　　// 排序
　　　　Matrix m = matrix1.sort(matrix1);
　　　　System.out.println("排序之后的结果：");
　　　　m.printMatrix();
　　　　matrix1.showType();

　　　　// 找矩阵中的元素以及其个数
　　　　System.out.println("矩阵中的元素以及其个数如下：");
　　　　Map<Integer, Integer> map = matrix1.getElementAndCount(matrix1);
　　　　Set<Entry<Integer, Integer>> set = map.entrySet();
　　　　for (Entry<Integer, Integer> entry : set) {
　　　　　　int element = entry.getKey();
　　　　　　int count = entry.getValue();
　　　　　　System.out.println("元素 " + element + " 有" + count + " 个");
　　　　}
　　　　matrix1.showType();

　　}
}

3、测试矩阵相加：AddMatrix.java

package cn.com.zfc.help;

import java.util.Scanner;

/**
*
* @title AddMatrix
* @describe 计算矩阵相加
* @author 张富昌
* @date 2017年4月6日下午12:59:43
*/
public class AddMatrix {
　　public static void main(String[] args) {
　　　　Scanner scanner = new Scanner(System.in);
　　　　// 创建第一个矩阵
　　　　System.out.println("请输入第一个矩阵的行数：");
　　　　int row = scanner.nextInt();
　　　　System.out.println("请输入第一个矩阵的列数：");
　　　　int cel = scanner.nextInt();
　　　　Matrix matrix1 = new Matrix(row, cel);
　　　　// 初始化矩阵
　　　　matrix1.initMatrix();

　　　　System.out.println("第一个矩阵为：");
　　　　matrix1.printMatrix();
　　　　matrix1.showType();

　　　　// 创建第二个矩阵
　　　　System.out.println("请输入第二个矩阵的行数：");
　　　　row = scanner.nextInt();
　　　　System.out.println("请输入第二个矩阵的列数：");
　　　　cel = scanner.nextInt();
　　　　Matrix matrix2 = new Matrix(row, cel);
　　　　// 初始化矩阵
　　　　matrix2.initMatrix();
　　　　System.out.println("第二个矩阵为：");
　　　　matrix2.printMatrix();
　　　　matrix1.showType();

　　　　// 两个矩阵相加（两个矩阵的行数和列数要一致）
　　　　Matrix m = matrix1.addMatrix(matrix1, matrix2);
　　　　System.out.println("两个矩阵相加之后的结果矩阵：");
　　　　if (m != null) {
　　　　　　m.printMatrix();
　　　　　　matrix1.showType();
　　　　} else {
　　　　　　System.out.println("两个矩阵的行数和列数不一致");
　　　　}
　　}
}

4、测试矩阵相乘：MulMatrix.java

package cn.com.zfc.help;

import java.util.Scanner;

/**
*
* @title MulMatrix
* @describe 两矩阵相乘
* @author 张富昌
* @date 2017年4月6日下午1:04:08
*/
public class MulMatrix {
　　public static void main(String[] args) {
　　　　Scanner scanner = new Scanner(System.in);
　　　　// 创建第一个矩阵
　　　　System.out.println("请输入第一个矩阵的行数：");
　　　　int row = scanner.nextInt();
　　　　System.out.println("请输入第一个矩阵的列数：");
　　　　int cel = scanner.nextInt();
　　　　Matrix matrix1 = new Matrix(row, cel);
　　　　// 初始化矩阵
　　　　matrix1.initMatrix();

　　　　System.out.println("第一个矩阵为：");
　　　　matrix1.printMatrix();
　　　　matrix1.showType();

　　　　// 创建第二个矩阵
　　　　System.out.println("请输入第二个矩阵的行数：");
　　　　row = scanner.nextInt();
　　　　System.out.println("请输入第二个矩阵的列数：");
　　　　cel = scanner.nextInt();
　　　　Matrix matrix2 = new Matrix(row, cel);
　　　　// 初始化矩阵
　　　　matrix2.initMatrix();
　　　　System.out.println("第二个矩阵为：");
　　　　matrix2.printMatrix();
　　　　matrix1.showType();

　　　　// 两个矩阵相乘（第一个矩阵的列数和第二个矩阵的行数要一致）
　　　　Matrix m = matrix1.mulMatrix(matrix1, matrix2);
　　　　System.out.println("两个矩阵相乘之后的结果矩阵：");
　　　　if (m != null) {
　　　　　　m.printMatrix();
　　　　　　m.printMatrix();
　　　　} else {
　　　　　　System.out.println("第一个矩阵的列数和第二个矩阵的行数不一致");
　　　　}
　　}
}

5、测试行列式计算：CalculateMatrix.java

package cn.com.zfc.help;

import java.util.Scanner;

/**
*
* @title CalculateMatrix
* @describe 计算行列式
* @author 张富昌
* @date 2017年4月6日下午1:08:40
*/
public class CalculateMatrix {
　　public static void main(String[] args) {
　　　　Scanner scanner = new Scanner(System.in);
　　　　// 创建第一个矩阵
　　　　System.out.println("请输入第一个矩阵的行数：");
　　　　int row = scanner.nextInt();
　　　　System.out.println("请输入第一个矩阵的列数：");
　　　　int cel = scanner.nextInt();
　　　　Matrix matrix1 = new Matrix(row, cel);
　　　　// 初始化矩阵
　　　　matrix1.initMatrix();

　　　　System.out.println("第一个矩阵为：");
　　　　matrix1.printMatrix();
　　　　matrix1.showType();

　　　　// 计算行列式
　　　　int result;
　　　　try {
　　　　　　result = matrix1.mathDeterminantCalculation(matrix1.getMatrix());
　　　　　　System.out.println("方阵行列式的结果是：" + result);
　　　　} catch (Exception e) {
　　　　　　System.out.println("不是正确的行列式！！");
　　　　}
　　}
}