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

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]

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));
    }
}

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.

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.
    }