JavaSE基础之矩阵运算

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("不是正确的行列式！！");
 　　　　}
 　　}
 }