Java中256位BigInteger的高效文件读写与字节处理指南

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

public class BigIntegerByteConverter {

    /**
     * 将BigInteger转换为指定固定长度的字节数组。
     * 字节数组采用大端序。
     * 如果BigInteger的字节表示长度小于fixedLength，则进行填充。
     * 对于正数，填充0x00；对于负数，填充0xFF（符号扩展）。
     * 如果BigInteger的字节表示长度大于fixedLength，则抛出异常（或根据需求截断）。
     *
     * @param n           要转换的BigInteger。
     * @param fixedLength 目标字节数组的固定长度（例如，256位对应32字节）。
     * @return 固定长度的字节数组。
     * @throws IllegalArgumentException 如果BigInteger需要超过fixedLength的字节来表示。
     */
    public static byte[] toFixedLengthBytes(BigInteger n, int fixedLength) {
        // 获取BigInteger的最小长度二进制补码表示
        byte[] sourceBytes = n.toByteArray();

        // 检查是否超出固定长度
        // 如果是正数且toByteArray()返回的字节数比fixedLength多一个（且第一个字节是0x00），
        // 意味着BigInteger的有效位刚好占据fixedLength字节，且toByteArray()添加了前导0x00作为符号位。
        // 这种情况下，我们可以安全地移除这个前导0x00。
        if (sourceBytes.length == fixedLength + 1 && sourceBytes[0] == 0) {
            sourceBytes = Arrays.copyOfRange(sourceBytes, 1, sourceBytes.length);
        } else if (sourceBytes.length > fixedLength) {
            throw new IllegalArgumentException(
                "BigInteger value requires " + sourceBytes.length + 
                " bytes, which is more than the specified fixed length of " + fixedLength + " bytes.");
        }

        // 创建目标固定长度的字节数组
        byte[] resultBytes = new byte[fixedLength];

        // 确定填充字节：正数填充0x00，负数填充0xFF
        byte paddingByte = (n.signum() == -1) ? (byte) 0xFF : (byte) 0x00;

        // 计算填充的起始位置和需要填充的字节数
        int bytesToPad = fixedLength - sourceBytes.length;

        // 填充前导字节
        for (int i = 0; i < bytesToPad; ++i) {
            resultBytes[i] = paddingByte;
        }

        // 将BigInteger的实际字节复制到结果数组的末尾
        System.arraycopy(sourceBytes, 0, resultBytes, bytesToPad, sourceBytes.length);

        return resultBytes;
    }

    public static void main(String[] args) {
        // 示例：256位（32字节）的BigInteger
        int fixedLength = 32;

        // 正数示例
        BigInteger positiveNum = new BigInteger("1234567890123456789012345678901234567890123456789012345678901234567890");
        byte[] positiveBytes = toFixedLengthBytes(positiveNum, fixedLength);
        System.out.println("Positive BigInteger Bytes (length " + positiveBytes.length + "): " + Arrays.toString(positiveBytes));
        BigInteger reconstructedPositive = new BigInteger(positiveBytes);
        System.out.println("Reconstructed Positive: " + reconstructedPositive.equals(positiveNum));

        // 负数示例
        BigInteger negativeNum = new BigInteger("-9876543210987654321098765432109876543210987654321098765432109876543210");
        byte[] negativeBytes = toFixedLengthBytes(negativeNum, fixedLength);
        System.out.println("Negative BigInteger Bytes (length " + negativeBytes.length + "): " + Arrays.toString(negativeBytes));
        BigInteger reconstructedNegative = new BigInteger(negativeBytes);
        System.out.println("Reconstructed Negative: " + reconstructedNegative.equals(negativeNum));

        // 刚好32字节的BigInteger（正数，最高位为0）
        BigInteger max256BitPositive = new BigInteger("2").pow(255).subtract(BigInteger.ONE); // 2^255 - 1
        byte[] maxPositiveBytes = toFixedLengthBytes(max256BitPositive, fixedLength);