Java BigInteger的256位数据文件存取指南

import java.math.BigInteger;
import java.util.Arrays;

public class BigIntegerFileHandler {

    /**
     * 将BigInteger转换为固定32字节的字节数组。
     * 对于小于32字节的数字，会进行填充；对于大于32字节的数字（或因符号位导致33字节），会进行截断。
     *
     * @param n 要转换的BigInteger。
     * @return 长度为32的字节数组。
     */
    public static byte[] toFixed32Bytes(BigInteger n) {
        // 获取BigInteger的最小两补码表示
        byte[] b = n.toByteArray();

        if (b.length == 32) {
            // 已经是32字节，直接返回
            return b;
        } else if (b.length < 32) {
            // 小于32字节，需要填充
            byte[] paddedBytes = new byte[32];
            // 确定填充值：正数用0x00，负数用0xFF（进行符号扩展）
            byte padValue = (byte) (n.signum() == -1 ? 0xFF : 0x00);

            // 填充前导字节
            Arrays.fill(paddedBytes, 0, 32 - b.length, padValue);
            // 复制实际的数字字节
            System.arraycopy(b, 0, paddedBytes, 32 - b.length, b.length);
            return paddedBytes;
        } else { // b.length > 32
            // 如果 BigInteger 的字节表示超过 32 字节。
            // 常见情况是正数且其最高位是0，导致 toByteArray() 返回 33 字节（前导0x00）。
            // 此时，我们取其后32字节。
            if (b.length == 33 && b[0] == 0x00) {
                return Arrays.copyOfRange(b, 1, 33); // 移除前导的0x00
            } else {
                // 如果是其他情况（例如，数字本身超过256位），则进行截断，取最后32字节。
                // 这意味着高位会被丢弃。根据实际需求，也可以选择抛出异常。
                return Arrays.copyOfRange(b, b.length - 32, b.length);
            }
        }
    }

    // 示例：将单个BigInteger写入文件
    public static void writeBigIntegerToFile(BigInteger n, String filePath) throws Exception {
        byte[] data = toFixed32Bytes(n);
        java.nio.file.Files.write(java.nio.file.Paths.get(filePath), data, java.nio.file.StandardOpenOption.APPEND, java.nio.file.StandardOpenOption.CREATE);
    }
}

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.math.BigInteger;

public class BigIntegerFileHandler {
    // ... (toFixed32Bytes 和 writeBigIntegerToFile 方法如上)

    /**
     * 从文件中读取所有固定32字节的BigInteger。
     *
     * @param filePath 文件路径。
     * @return 包含所有读取到的BigInteger的列表。
     * @throws IOException 如果文件读取失败。
     */
    public static List<BigInteger> readBigIntegersFromFile(String filePath) throws IOException {
        Path path = Path.of(filePath);
        byte[] fileBytes = Files.readAllBytes(path);

        // 每个BigInteger占用32字节
        final int BYTES_PER_BIGINTEGER = 32;
        if (fileBytes.length % BYTES_PER_BIGINTEGER != 0) {
            throw new IOException("文件大小不是32字节的整数倍，可能存在损坏或格式错误。");
        }

        int numberCount = fileBytes.length / BYTES_PER_BIGINTEGER;
        List<BigInteger> numbers = new ArrayList<>(numberCount);

        // 使用ByteBuffer高效地分割字节数组
        ByteBuffer buf = ByteBuffer.wrap(fileBytes);
        byte[] bytes = new byte[BYTES_PER_BIGINTEGER];

        for (int i = 0; i < numberCount; ++i) {
            buf.get(bytes); // 从ByteBuffer中读取32字节
            numbers.add(new BigInteger(bytes)); // 使用字节数组构造BigInteger
        }
        return numbers;
    }
}

import java.math.BigInteger;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.List;

public class BigIntegerFileOperations {

    // (此处应包含上述 BigIntegerFileHandler 类的 toFixed32Bytes 和 readBigIntegersFromFile 方法)
    // 为了代码的简洁性，这里省略了重复的代码，假设它们在同一个类或可访问。

    public static void main(String[] args) {
        String filePath = "big_integers.bin";
        Path path = Path.of(filePath);

        try {
            // 1. 生成一些BigInteger数据
            BigInteger num1 = new BigInteger("1234567890123456789012345678901234567890123456789012345678901234"); // 超过64位
            BigInteger num2 = new BigInteger("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 16); // 256位最大正数
            BigInteger num3 = new BigInteger("-1"); // 负数
            BigInteger num4 = BigInteger.ZERO; // 零
            BigInteger num5 = new BigInteger("1"); // 小数

            // 2. 将BigInteger写入文件
            // 为了演示，每次写入前清空文件，或者使用CREATE_NEW防止覆盖
            Files.deleteIfExists(path); // 如果文件存在，先删除
            Files.createFile(path); // 创建新文件

            System.out.println("写入 BigInteger 到文件...");
            Files.write(path, BigIntegerFileHandler.toFixed32Bytes(num1), StandardOpenOption.APPEND);
            Files.write(path, BigIntegerFileHandler.toFixed32Bytes(num2), StandardOpenOption.APPEND);
            Files.write(path, BigIntegerFileHandler.toFixed32Bytes(num3), StandardOpenOption.APPEND);
            Files.write(path, BigIntegerFileHandler.toFixed32Bytes(num4), StandardOpenOption.APPEND);
            Files.write(path, BigIntegerFileHandler.toFixed32Bytes(num5), StandardOpenOption.APPEND);
            System.out.println("写入完成。文件大小: " + Files.size(path) + " 字节。");

            // 3. 从文件读取BigInteger
            System.out.println("\n从文件读取 BigInteger...");
            List<BigInteger> readNumbers = BigIntegerFileHandler.readBigIntegersFromFile(filePath);

            System.out.println("读取到的 BigInteger