Java deepToString到数组-矩阵乘法

有人能帮我做点什么吗？ 我正在尝试将最初使用

deepToString（）

方法创建的字符串转换回数组。我已经尝试了几乎所有我能在堆栈溢出上找到的东西…但是没有运气

这就是我现在拥有的：

import java.util.*;

public class Test3 {
    static int matrix [][] = new int[2][2];

    public static int[][] matrixGenerator() {
        Random r = new Random( );
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                matrix[i][j] = r.nextInt( 10000 );
            }
        }
        return matrix;
    }
    public static void main(String args[]){
        String matrix1 = Arrays.deepToString(matrixGenerator());
        String matrix2 = Arrays.deepToString(matrixGenerator());
        System.out.println(matrix1 + '\n' + matrix2);
    }
}

import java.util.*；
公共类Test3{
静态整数矩阵[][]=新整数[2][2]；
公共静态int[][]矩阵生成器（）{
Random r=新的Random（）；
对于（int i=0；i

这个输出

[[60303761]，[6605582]]

及

[[1799461]，[11971012]]

这正是我需要的。现在我试着用这段代码做一个矩阵乘法

int m1rows = matrix1.length;
int m1cols = matrix1[0].length;
int m2cols = matrix2[0].length;

int[][] result = new int[m1rows][m2cols];
    for (int i = 0; i < m1rows; i++) {
       for (int j = 0; j < m2cols; j++) {
          for (int k = 0; k < m1cols; k++) {
             result[i][j] += matrix1[i][k] * matrix2[k][j];
       }
    }
 }

int m1rows=matrix1.length；
int m1cols=matrix1[0]。长度；
int m2cols=matrix2[0]。长度；
int[][]结果=新的int[m1rows][m2cols]；
对于（int i=0；i

---

问题是我不能循环遍历数组，因为它实际上不是数组，而是字符串。这是有道理的。有人能告诉我怎么循环吗？我尝试将字符串转换回数组，但没有成功

为什么需要将矩阵转换为字符串，然后再转换回矩阵？ 你能简单地使用吗

public static void main(String[] args) {
        int matrix1 [][] = matrixGenerator();
        int matrix2 [][] = matrixGenerator();
        int matrix3 [][] = matrixMultiplication(matrix1, matrix2);
        String matrix1Str = Arrays.deepToString(matrix1);
        String matrix2Str = Arrays.deepToString(matrix2);
        String matrix3Str = Arrays.deepToString(matrix3);
        System.out.println(matrix1Str+'\n'+matrix2Str+'\n'+matrix3Str);
    }

    public static int[][] matrixGenerator(){
        int matrix [][] = new int[2][2];
        Random r = new Random( );
        for(int i=0; i < matrix.length; i++){
            for(int j=0; j < matrix[i].length; j++){
                matrix[i][j] = r.nextInt( 10000 );
            }
        }
        return matrix;
    }

    public static int[][] matrixMultiplication(int[][] matrix1, int[][] matrix2) {
        int m1rows = matrix1.length;
        int m1cols = matrix1[0].length;
        int m2cols = matrix2[0].length;

        int[][] result = new int[m1rows][m2cols];
            for (int i=0; i< m1rows; i++){
               for (int j=0; j< m2cols; j++){
                  for (int k=0; k< m1cols; k++){
                     result[i][j] += matrix1[i][k] * matrix2[k][j];
               }
            }
         }
        return result;
    }

publicstaticvoidmain（字符串[]args）{
int matrix1[][]=matrixGenerator（）；
int matrix2[][]=matrixGenerator（）；
int matrix3[][]=矩阵乘法（matrix1，matrix2）；
字符串matrix1Str=Arrays.deepToString（matrix1）；
字符串matrix2Str=Arrays.deepToString（matrix2）；
字符串matrix3Str=Arrays.deepToString（matrix3）；
System.out.println（matrix1Str+'\n'+matrix2Str+'\n'+matrix3Str）；
}
公共静态int[][]矩阵生成器（）{
整数矩阵[][]=新整数[2][2]；
Random r=新的Random（）；
对于（int i=0；i

为什么需要将矩阵转换为字符串，然后再转换回矩阵？ 你能简单地使用吗

public static void main(String[] args) {
        int matrix1 [][] = matrixGenerator();
        int matrix2 [][] = matrixGenerator();
        int matrix3 [][] = matrixMultiplication(matrix1, matrix2);
        String matrix1Str = Arrays.deepToString(matrix1);
        String matrix2Str = Arrays.deepToString(matrix2);
        String matrix3Str = Arrays.deepToString(matrix3);
        System.out.println(matrix1Str+'\n'+matrix2Str+'\n'+matrix3Str);
    }

    public static int[][] matrixGenerator(){
        int matrix [][] = new int[2][2];
        Random r = new Random( );
        for(int i=0; i < matrix.length; i++){
            for(int j=0; j < matrix[i].length; j++){
                matrix[i][j] = r.nextInt( 10000 );
            }
        }
        return matrix;
    }

    public static int[][] matrixMultiplication(int[][] matrix1, int[][] matrix2) {
        int m1rows = matrix1.length;
        int m1cols = matrix1[0].length;
        int m2cols = matrix2[0].length;

        int[][] result = new int[m1rows][m2cols];
            for (int i=0; i< m1rows; i++){
               for (int j=0; j< m2cols; j++){
                  for (int k=0; k< m1cols; k++){
                     result[i][j] += matrix1[i][k] * matrix2[k][j];
               }
            }
         }
        return result;
    }

publicstaticvoidmain（字符串[]args）{
int matrix1[][]=matrixGenerator（）；
int matrix2[][]=matrixGenerator（）；
int matrix3[][]=矩阵乘法（matrix1，matrix2）；
字符串matrix1Str=Arrays.deepToString（matrix1）；
字符串matrix2Str=Arrays.deepToString（matrix2）；
字符串matrix3Str=Arrays.deepToString（matrix3）；
System.out.println（matrix1Str+'\n'+matrix2Str+'\n'+matrix3Str）；
}
公共静态int[][]矩阵生成器（）{
整数矩阵[][]=新整数[2][2]；
Random r=新的Random（）；
对于（int i=0；i

如果它是一个字符串，您不能通过在[]上拆分来构建一个数组吗？拆分它，然后将其解析为整数（t执行您的操作：）请问如何操作？只是我的大脑现在处于“锁定”状态：（你的

matrixGenerator（）

返回一个

int[]

。为什么不使用这些数组，而不是将它们转换为

字符串

？为什么要将数组转换为字符串，然后再转换回数组？有什么特殊需要吗？如果它是字符串，你不能通过在[]上拆分来构建数组吗？拆分后再将其解析为整数？不要进行操作：）我可以问一下如何操作吗？只是我的大脑现在处于“锁定”状态：（你的

matrixGenerator（）

返回一个

int[]

。为什么不使用这些数组而不是将它们转换为字符串呢？为什么要将数组转换为字符串，然后再转换回数组？有什么特殊需要吗？你是明星！这正是我需要的！谢谢！你是明星！这正是我需要的！谢谢！