Question

目前，我正在尝试实现一种能够在Java中使用向量乘法和矩阵乘法的方法，现在我有了代码：

package ai2;

public class MyMatrix {
    int[][] alpha;
    int a;
    int b;
    int rowsB;
    int colsB;

    public MyMatrix(int a, int b) {
        this.a = a;
        this.b = b;
        alpha = new int[a][b];
        for (int k = 0; k < a; k++) {
            for (int l = 0; l < b; l++) {
                alpha[k][l] = 0;
            }
        }
    }

    public void insertValue(int o, int q, int z) {
        this.alpha[o][q] = z;
    }

    public void print() {
        for (int k = 0; k < a; k++) {
            for (int l = 0; l < b; l++) {
                System.out.print(this.alpha[k][l] + " ");
            }
            System.out.println();
        }
    }

    public void multiplyMatrix(MyMatrix B) {
        MyMatrix created = new MyMatrix(this.a, B.b);
        for (int m = 0; m < a; m++) {
            for (int k = 0; k < b; k++) {
                for (int l = 0; k < this.a; l++) {
                    myMatrixC[i][j] += myMatrixA[i][k] * myMatrixB[k][j];
                }
            }
        }
    }

    public static void main(String[] args) {
        MyMatrix a = new MyMatrix(2, 2);
        a.insertValue(0, 0, 1);
        a.insertValue(1, 1, 1);
        a.print();
        MyMatrix b = new MyMatrix(2, 2);
        b.insertValue(0, 0, 1);
        b.insertValue(1, 0, 1);
        // System.out.println(a);
    }
}

问题是我的multipleMatrix方法，它使用一个MyMatrix对象，但是我无法使用例如以下值来达到该值：

MyMatrixA[k][l]

我需要某种想法来达到这些值，或者可能是一个更聪明的实现，我不能使用java之外的软件包，感谢您的帮助！

Answer 1

Java中的方括号仅用于访问数组元素。

您的语法将无法编译，并且您无法以这种方式访问矩阵元素。

为什么不只在getAlpha类中实现MyMatrix的getter来返回alpha的值（或者更好的是，以确保不变性）？

然后您可以使用theMatrixInstance.getAlpha()[k][l]来引用它。

您还可以简化一点并实现采用两个索引的get方法。

这将使您可以检查给定的索引是否在二维数组的范围内，并引发自定义异常（或返回一些默认值），而不是您将得到的ArrayIndexOutOfBoundsException。

Answer 2

替换此行

myMatrixC[i][j] += myMatrixA[i][k] * myMatrixB[k][j];

使用

created.alpha[i][j] += this.alpha[i][k] * B.alpha[k][j];

或者更好，替换

MyMatrix created = new MyMatrix(this.a, B.b);

与

MyMatrix A = this;
MyMatrix C = new MyMatrix(this.a, B.b);

那你就可以做

C.alpha[i][j] += A.alpha[i][k] * B.alpha[k][j];

读起来更清晰些

最后，无需在构造函数中用0初始化alpha，这会自动发生。

在Java中实现向量乘法

2 个答案: