Convert byte array (signed bytes) to int array of corresponding unsigned bytes

Question

Having given a command line parameter which is a hex string I use org.apache.commons.codec.binary.Hex.decodeHex to get a byte[].

But of course Java bytes are signed. I'd like to treat this as a bunch of unsigned bytes (so where I have a byte value of, say, -128 I want it to be 0x80 = 128, or for -103 I want it to be 0x99 = 153.

It's not going to fit in a byte[] anymore, so let's make it a char[] (short[] would also work).

What is the way to do this in Java. I can write the obvious loop (or better: stream pipeline) but is there something better, built-in, e.g. some library method that I'm unaware of?

• This isn't something java.nio.ByteBuffer does
• java.nio.charset.CharsetDecoder has an API with the right signature but I don't know if there is (or how to get) an "identity" decoder.

(No work to show: internet searches turned up nothing like this.)

Answer 1

I can write the obvious loop (or better: stream pipeline) but is there something better, built-in, e.g. some library method that I'm unaware of?

AFAIK, no.

There is no builtin "library method or something better" to do this. Just do it the clunky way. (FWIW, using a loop will most likely be more efficient than using streams.)

Better still, figure out a way to avoid doing it at all; e.g. keep the byte[] and use Byte.toUnsignedInt whenever you want to use the individual bytes in the array as unsigned.

Answer 2

Try this.

byte[] byteArray = {0, 1, -128, -103};
int[] intArray = IntStream.range(0, byteArray.length)
    .map(i -> byteArray[i] & 0xff)
    .toArray();
System.out.println(Arrays.toString(intArray));

output:

[0, 1, 128, 153]

Answer 3

You're starting from a hex String so you could take this approach, quite an 'old school' one since Java is not particularly good at streaming byte[]:

import java.io.IOException;
import java.util.Arrays;
import java.io.StringReader;

public class HexInts {
    public static void main(String[] args) throws IOException {
        String s = args[0];
        int[] ints = new int[s.length() / 2];
        char[] buf = new char[2];
        int ix = 0;
        StringReader in = new StringReader(s);
        while ((in.read(buf)) > -1) {
            ints[ix++] = Integer.parseInt(String.valueOf(buf), 16);
        }
        System.out.println(Arrays.toString(ints));
    }
}

Answer 4

In general, to convert a single value to unsigne is enought to mask with & 0xFF. You can do it natively like b & 0xFF or use method from Byte.toUnsignedInt(b).

public static int[] convert(byte[] byteArray) {
    int[] intArray = new int[byteArray.length];

    for (int i = 0; i < byteArray.length; i++) {
        intArray[i] = byteArray[i] & 0xFF;
        // or this
        // intArray[i] = Byte.toUnsignedInt(byteArray[i]);
    }

    return intArray;
}

I think it's not a good idea to use Stream, because use less memory. I think POJO is much better in this case.

Answer 5

I ended up with this loop - just FYI:

    private @NotNull short[] toUnsignedBuffer(@NotNull byte[] signedBuffer) {
        short[] r = new short[signedBuffer.length];
        int i = 0;
        for (byte b : signedBuffer) r[i++] = (short) toUnsignedInt(b);
        return r;

        // Q: Why doesn't `Arrays` have a `static void SetAll(byte[] array, IntToShortFunction
        // generator)`?
        // A: Because `short` is the bastard stepchild of Java's framework libraries.  P.S., there's
        // no `IntToShortFunction` interface either ... or `ShortStream` class,  or
        // `Streams::toArray` overload that'll give you a `short[]`, etc. etc. etc.
    }