Java矩阵操作终极教程：手写实现与EJML实战

在科学计算和机器学习领域，矩阵运算是最基础的数学工具之一。作为一门通用编程语言，Java提供了多种实现矩阵运算的方式。本文将全面讲解Java中矩阵操作的各类方法，包括基础实现、性能优化以及主流矩阵库的应用。

一、Java矩阵基础实现

1.1 二维数组表示法

最简单的矩阵表示方式是使用二维数组：

double[][] matrix = {
    {1.0, 2.0, 3.0},
    {4.0, 5.0, 6.0},
    {7.0, 8.0, 9.0}
};

这种方式的优点是直观简单，但缺乏专业的矩阵操作方法。

1.2 自定义矩阵类

我们可以创建专门的Matrix类来封装矩阵操作：

public class Matrix {
    private final double[][] data;
    private final int rows;
    private final int cols;

    public Matrix(int rows, int cols) {
        this.rows = rows;
        this.cols = cols;
        this.data = new double[rows][cols];
    }

    // 矩阵加法
    public Matrix add(Matrix other) {
        // 实现代码...
    }

    // 矩阵乘法
    public Matrix multiply(Matrix other) {
        // 实现代码...
    }
}

二、核心矩阵算法实现

2.1 矩阵乘法优化

朴素矩阵乘法的时间复杂度为O(n³)，我们可以通过分块算法优化：

public Matrix blockedMultiply(Matrix other, int blockSize) {
    Matrix result = new Matrix(rows, other.cols);

    for (int i = 0; i < rows; i += blockSize) {
        for (int j = 0; j < other.cols; j += blockSize) {
            for (int k = 0; k < cols; k += blockSize) {
                // 分块计算
                for (int ii = i; ii < Math.min(i + blockSize, rows); ii++) {
                    for (int jj = j; jj < Math.min(j + blockSize, other.cols); jj++) {
                        for (int kk = k; kk < Math.min(k + blockSize, cols); kk++) {
                            result.data[ii][jj] += data[ii][kk] * other.data[kk][jj];
                        }
                    }
                }
            }
        }
    }
    return result;
}

2.2 LU分解实现

LU分解是解线性方程组的重要方法：

public LUDecompositionResult luDecompose() {
    double[][] lu = Arrays.copyOf(data, rows);
    int[] pivot = new int[rows];

    for (int i = 0; i < rows; i++) {
        // 部分主元选择
        int maxRow = i;
        for (int j = i + 1; j < rows; j++) {
            if (Math.abs(lu[j][i]) > Math.abs(lu[maxRow][i])) {
                maxRow = j;
            }
        }

        // 交换行
        if (maxRow != i) {
            double[] temp = lu[i];
            lu[i] = lu[maxRow];
            lu[maxRow] = temp;
        }

        // 消元
        for (int j = i + 1; j < rows; j++) {
            lu[j][i] /= lu[i][i];
            for (int k = i + 1; k < cols; k++) {
                lu[j][k] -= lu[j][i] * lu[i][k];
            }
        }
    }

    return new LUDecompositionResult(lu, pivot);
}

三、高性能矩阵库应用

3.1 EJML库基础使用

Efficient Java Matrix Library (EJML) 是Java中最快的矩阵库之一：

// 创建矩阵
SimpleMatrix A = new SimpleMatrix(new double[][]{
    {1, 2},
    {3, 4}
});

// 矩阵运算
SimpleMatrix B = A.plus(A);
SimpleMatrix C = A.mult(A);

// 线性方程组求解
SimpleMatrix x = A.solve(b);

3.2 ND4J在大数据中的应用

ND4J适合处理大规模矩阵计算：

INDArray matrix = Nd4j.create(new double[][]{
    {1, 2, 3},
    {4, 5, 6}
});

// GPU加速计算
INDArray result = matrix.mmul(matrix.transpose());

四、性能对比与选择建议

我们对比了不同实现的性能（测试环境：Intel i7-10750H）：

选择建议：
1. 学习目的：从基础实现开始
2. 中小规模计算：EJML
3. 大规模/深度学习：ND4J
4. 需要GPU加速：ND4J+CUDA

五、矩阵应用实例：图像卷积

用矩阵运算实现图像模糊效果：

public BufferedImage applyBlur(BufferedImage image) {
    int width = image.getWidth();
    int height = image.getHeight();

    // 创建图像矩阵
    SimpleMatrix[] channels = convertImageToMatrices(image);

    // 定义3x3高斯核
    SimpleMatrix kernel = new SimpleMatrix(new double[][]{
        {1/16.0, 2/16.0, 1/16.0},
        {2/16.0, 4/16.0, 2/16.0},
        {1/16.0, 2/16.0, 1/16.0}
    });

    // 对每个通道应用卷积
    for (int c = 0; c < 3; c++) {
        channels[c] = convolve2D(channels[c], kernel);
    }

    return convertMatricesToImage(channels, width, height);
}