How can I read a Java long as unsigned and store its value in a BigInteger?

Question

I have to handle an 8-byte unsigned integer type in Java somehow.

My 8-byte unsigned integer is stored in a byte array wrapped by ByteBuffer. It comes from a data logger database and contains very big numbers.

This is how I deal with 4-byte integers to read them them as unsigned:

((long) (bytebuffer.getInt() & 0xFFFFFFFFL));

Unfortunately this:

((BigInteger) (bytebuffer.getLong() & 0xFFFFFFFFFFFFFFFFL));

doesn't work.

How can I store the number 2^64-1 and read it as 2^64-1?

Answer 1

You can convert it to an unsigned string and then parse it to BigInteger:

new BigInteger(Long.toUnsignedString(bytebuffer.getLong()))

Probably not the most efficient solution, but possibly the simplest.

Or you can borrow this implementation out of the Long class:

static BigInteger toUnsignedBigInteger(long i) {
    if (i >= 0L)
        return BigInteger.valueOf(i);
    else {
        int upper = (int) (i >>> 32);
        int lower = (int) i;

        // return (upper << 32) + lower
        return (BigInteger.valueOf(Integer.toUnsignedLong(upper))).shiftLeft(32).
            add(BigInteger.valueOf(Integer.toUnsignedLong(lower)));
    }
}

Answer 2

In Java's signed longs, the most significant bit is worth -(2⁶³). If it were unsigned, then that bit would be worth positive 2⁶³. The difference is 2⁶⁴.

First, create a BigInteger using the long value. Then, if it's negative, apply the unsigned correction by adding 2⁶⁴, or 1 << 64, to the BigInteger.

BigInteger result = BigInteger.valueOf(bytebuffer.getLong());
if (result.compareTo(BigInteger.ZERO) < 0) {
    result = result.add(BigInteger.ONE.shiftLeft(64));
}