float[][] 矩阵序列化：用 Base64 二进制编码替代 JSON 文本，避免 OOM

import java.nio.ByteBuffer;
import java.util.Base64;

public class FloatMatrixCodec {

    /**
     * 将 float[][] 编码为 Base64 字符串
     * 二进制格式：[rows(4B)][cols(4B)][float 数据(rows*cols*4B)]
     */
    public static String encode(float[][] matrix) {
        int rows = matrix.length;
        int cols = (rows > 0) ? matrix[0].length : 0;

        // 精确计算字节数：8（维度头）+ rows * cols * 4（数据区）
        // 使用 long 防止 int 溢出（rows * cols * 4 可能超过 Integer.MAX_VALUE）
        long size = 8L + (long) rows * cols * 4;
        if (size > Integer.MAX_VALUE) {
            throw new IllegalArgumentException(
                "Matrix too large for single buffer, use chunk encoding");
        }
        ByteBuffer buffer = ByteBuffer.allocate((int) size);
        buffer.putInt(rows);
        buffer.putInt(cols);

        for (float[] row : matrix) {
            for (float val : row) {
                buffer.putFloat(val);
            }
        }

        return Base64.getEncoder().encodeToString(buffer.array());
    }

    /**
     * 将 Base64 字符串解码为 float[][]
     */
    public static float[][] decode(String base64Str) {
        byte[] bytes = Base64.getDecoder().decode(base64Str);
        if (bytes.length < 8) {
            throw new IllegalArgumentException("Invalid encoded data: too short");
        }
        ByteBuffer buffer = ByteBuffer.wrap(bytes);

        int rows = buffer.getInt();
        int cols = buffer.getInt();
        if (rows < 0 || cols < 0 || 8 + (long) rows * cols * 4 != bytes.length) {
            throw new IllegalArgumentException("Invalid encoded data: size mismatch");
        }

        float[][] matrix = new float[rows][cols];
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                matrix[i][j] = buffer.getFloat();
            }
        }

        return matrix;
    }
}

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

class FloatMatrixCodecTest {

    @Test
    void encodeAndDecodeShouldBeIdentical() {
        float[][] original = {{1.1f, 2.2f, 3.3f}, {4.4f, 5.5f, 6.6f}};
        String encoded = FloatMatrixCodec.encode(original);
        float[][] decoded = FloatMatrixCodec.decode(encoded);
        assertArrayEquals(original, decoded);
    }

    @Test
    void emptyMatrixShouldRoundtrip() {
        float[][] empty = new float[0][0];
        assertArrayEquals(empty, FloatMatrixCodec.decode(FloatMatrixCodec.encode(empty)));
    }
}

// ❌ 千万不要这样做！
String json = objectMapper
    .writerWithDefaultPrettyPrinter()
    .writeValueAsString(matrix);

import java.io.*;
import java.nio.ByteBuffer;
import java.util.Base64;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;

public class FloatMatrixCodecGzip {

    public static String encodeWithGzip(float[][] matrix) throws IOException {
        // Step 1：float[][] → byte[]（内联 ByteBuffer 编码，跳过 Base64 步骤）
        int rows = matrix.length;
        int cols = (rows > 0) ? matrix[0].length : 0;
        ByteBuffer buf = ByteBuffer.allocate(8 + rows * cols * 4);
        buf.putInt(rows);
        buf.putInt(cols);
        for (float[] row : matrix) {
            for (float v : row) buf.putFloat(v);
        }
        byte[] raw = buf.array();

        // Step 2：GZIP 压缩
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try (GZIPOutputStream gz = new GZIPOutputStream(baos)) {
            gz.write(raw);
        }

        // Step 3：Base64 编码
        return Base64.getEncoder().encodeToString(baos.toByteArray());
    }

    public static float[][] decodeWithGzip(String base64Str) throws IOException {
        byte[] compressed = Base64.getDecoder().decode(base64Str);

        // Step 1：GZIP 解压
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try (GZIPInputStream gz = new GZIPInputStream(new ByteArrayInputStream(compressed))) {
            byte[] tmp = new byte[4096];
            int len;
            while ((len = gz.read(tmp)) != -1) baos.write(tmp, 0, len);
        }

        // Step 2：byte[] → float[][]
        ByteBuffer buf = ByteBuffer.wrap(baos.toByteArray());
        int rows = buf.getInt();
        int cols = buf.getInt();
        float[][] matrix = new float[rows][cols];
        for (int i = 0; i < rows; i++)
            for (int j = 0; j < cols; j++)
                matrix[i][j] = buf.getFloat();

        return matrix;
    }
}

// 仅在 DEBUG 级别打印可读预览，不影响生产性能
if (log.isDebugEnabled()) {
    log.debug("Matrix preview [{},{},...] size={}x{}",
        matrix[0][0], matrix[0][1],
        matrix.length, matrix[0].length);
}
String encoded = FloatMatrixCodec.encode(matrix);

// 示例：按行分块，每块最多 N 行
public static List<String> encodeInChunks(float[][] matrix, int chunkRows) {
    List<String> chunks = new ArrayList<>();
    for (int start = 0; start < matrix.length; start += chunkRows) {
        int end = Math.min(start + chunkRows, matrix.length);
        float[][] chunk = Arrays.copyOfRange(matrix, start, end);
        chunks.add(FloatMatrixCodec.encode(chunk));
    }
    return chunks;
}