Question

无论如何都要使数组保持2d数组吗？

我想以某种方式根据用户输入的内容保存matrixFinal的值，以便以后可以使用它。我想如果我能在数组中保存这些值，我就能做到这一点，但这些是2d数组......

我将如何做到这一点？

public class Driver {
public static void main(String[] args) {
    int i, j, k, l ;
    int sum = 0 ;
    int matrixAColumnSize   ;
    int matrixARowSize      ;
    int raiseByPower        ;


    // Querying user
    matrixARowSize      =   Tools.queryForInt("Enter the row size of Matrix A: ") ;
    matrixAColumnSize   =   Tools.queryForInt("Enter the column size of Matrix A: ") ;
    Tools.verifyMatrixSize(matrixAColumnSize, matrixARowSize) ;  // Verification of matrix size 10x10 max
    Tools.verifyMultiplication(matrixARowSize, matrixAColumnSize) ; // Verification of matrix size
    raiseByPower        =   Tools.queryForInt("By what power would you like to raise the matrix? ") ; 
    Tools.verifyMatrixPower(raiseByPower) ; // Verification of power. ^6 max

    //Making matrices
    int matrixA[][] = new int[matrixARowSize][matrixAColumnSize] ;
    int matrixFinal[][] = new int [matrixARowSize][matrixAColumnSize] ; 

    // Querying for elements of Matrix A
            for (i = 0; i < matrixARowSize; i++) {
                for (j = 0; j < matrixAColumnSize; j++) {
                    matrixA[i][j] = Tools.queryForInt("Enter element in Matrix A" + (i+1) + "," + (j+1) + " :" ) ; }}

    // Multiplying matrices
            if (raiseByPower == 1) {
                for (i = 0; i < matrixARowSize; i++) {
                    for (j = 0; j < matrixAColumnSize; j++) {
                        matrixFinal[i][j] = matrixA[i][j] ;
                    }
                }

            } else if (raiseByPower == 2) {
            for (i = 0; i < matrixARowSize; i++)
            {
                for (j = 0; j < matrixAColumnSize; j++) 
                {
                    for (k = 0; k < matrixARowSize; k++) 
                    {
                        sum = sum + matrixA[i][j] * matrixA[i][j] ;
                    }

                    matrixFinal[i][j] = sum ;
                    sum = 0 ;
                }
            }

            } else if (raiseByPower == 3) {
                for (i = 0; i < matrixARowSize; i++)
                {
                    for (j = 0; j < matrixAColumnSize; j++) 
                    {
                        for (k = 0; k < matrixARowSize; k++) 
                        {
                            sum += matrixA[i][j] * matrixA[i][j] * matrixA[i][j] ;
                            sum = 0 ;
                        }
                        matrixFinal[i][j] = sum ;

                    }
                    }
            } else if (raiseByPower == 4) {
                for (i = 0; i < matrixARowSize; i++)
                {
                    for (j = 0; j < matrixAColumnSize; j++) 
                    {
                        for (k = 0; k < matrixARowSize; k++) 
                        {
                            sum += matrixA[i][j] * matrixA[i][j] * matrixA[i][j] * matrixA[i][j] ;
                        }
                        matrixFinal[i][j] = sum ;
                        sum = 0 ;
            }
                }} else if ( raiseByPower == 5) {
                    for (i = 0; i < matrixARowSize; i++)
                    {
                        for (j = 0; j < matrixAColumnSize; j++) 
                        {
                            for (k = 0; k < matrixARowSize; k++) 
                            {
                                sum += matrixA[i][j] * matrixA[i][j] * matrixA[i][j] * matrixA[i][j] * matrixA[i][j] ;
                            }
                            matrixFinal[i][j] = sum ;
                            sum = 0 ;
                }
                }
                } else if ( raiseByPower == 6) {
                    for (i = 0; i < matrixARowSize; i++)
                    {
                        for (j = 0; j < matrixAColumnSize; j++) 
                        {
                            for (k = 0; k < matrixARowSize; k++) 
                            {
                                sum += matrixA[i][j] * matrixA[i][j] * matrixA[i][j] * matrixA[i][j] * matrixA[i][j] * matrixA[i][j] ;
                            }
                            matrixFinal[i][j] = sum ;
                            sum = 0 ;
                }
                }
                } 

            System.out.println("Matrix A to the power of " + raiseByPower + " is: ") ;

            for (i = 0; i < matrixARowSize; i++) {
                for (j = 0; j < matrixAColumnSize; j++) 
                    System.out.print(matrixFinal[i][j] + "\t") ;

                System.out.println();
            }

}}

Answer 1

你可以根据需要嵌套数组，这样就可以使用像int [] [] []这样的二维数组。

好吧，你已经有一个int [] []所以你可以做一个

int[][][] container = new int[numberofmatrixes][matrixsize][matrixsize];

然后添加你的matrixA或matrixFinal：

container[index] = matrixA;

并从matrixA获取值：

int a = container[index][index2][index3];

之前您将使用

int a = matrixA[index2][index3];

您对待＆＃39;容器＆＃39;数组与任何其他数组一样，因此第一个矩阵将被添加到容器[0]，第二个矩阵将被添加到容器[1]，依此类推。你必须记住自己的索引是哪个矩阵。

Answer 2

在C中，2d数组和1d数组是“相同的”，因为它们都是从某个存储器地址（指针，p）计算出的偏移量。例如，要在32位编译器上获取int数组的第5个元素，您需要多个（5-1）x4并将其添加到地址p，写为p [4]（假设类型p是一个指向int的指针，int是一个4字节的单词）。在Java中，如果p是一个int数组，那么你也可以通过p [4]访问第五个数组。

在C中，您可以以相同的方式访问二维数组，例如P [4] [2]。例如，请参阅：http://www.tutorialspoint.com/cprogramming/c_multi_dimensional_arrays.htm

它在C中的工作方式是第一个数字乘以行中数组的大小，然后加到第二个数字，然后乘以元素大小。所以p [4] [2]是（（void *）p）+168，如果数组是10x10而“int”（又名字大小）是32位，即它是第42个元素。

现在在Java中执行“数组上的二维数组”有点复杂，因为编译器不会为您做数学运算，但您可以这样做。只需创建一个名为Matrix的类，即可获取行和列。构造函数中的列，创建基础的1维数组，并有两个方法：

public T get(int row, int column)
put(int row, int column, T value)

等

另一个数组里面的2d数组？

2 个答案: