Convert int to Unsigned byte in Java | Baeldung

1. Introduction

In Java, the byte type is a signed 8-bit integer. This means it can hold values from -128 to 127. However, there are situations where we might need to work with bytes as if they were unsigned, representing values from 0 to 255. This can be especially important when dealing with binary data, networking, and file I/O where unsigned bytes are common.

In this tutorial, we’ll discover two approaches to converting an int to an unsigned byte in Java.

2. Using Type Casting and Bit Masking

The most common approach is to use type casting combined with bit masking. Let’s explore the implementation:

int value = 200;

@Test
public void givenInt_whenUsingTypeCastingAndBitMasking_thenConvertToUnsignedByte() {
    byte unsignedByte = (byte) (value & 0xFF);

    assertEquals(value, Byte.toUnsignedInt(unsignedByte));
}

In this test, we begin by initializing an integer value of 200. Then, we employ the expression (value & 0xFF) to convert this integer into an unsigned byte representation. This operation involves a bitwise AND operation between the integer value and the hexadecimal value 0xFF, which corresponds to 255 in decimal or 11111111 in binary.

By executing this bitwise AND operation, we ensure that only the least significant 8 bits of the integer value are retained, effectively discarding any higher-order bits. Consequently, the resulting value of (value & 0xFF) represents an unsigned byte within the range of 0 to 255. Furthermore, this resultant unsigned byte value is then cast to a byte datatype using (byte), facilitating compatibility with Java’s byte type.

Subsequently, after obtaining this byte representation, we utilize the Byte.toUnsignedInt() method to correctly interpret it as an unsigned value.

3. Using ByteBuffer

Another approach involves using the ByteBuffer class to convert an int to a byte array and then extract the byte:

@Test
public void givenIntInRange_whenUsingByteBuffer_thenConvertToUnsignedByte() {
    int value = 200;
    ByteBuffer buffer = ByteBuffer.allocate(4).putInt(value);
    byte unsignedByte = buffer.array()[3];

    assertEquals(value, Byte.toUnsignedInt(unsignedByte));
}

Here, we allocate a ByteBuffer of 4 bytes to store the integer value. Then, we utilize the putInt(value) method to store the integer in the buffer. Since the buffer stores the value in big-endian order by default, the least significant byte (which we need) is the fourth byte in the buffer (index 3).

4. Conclusion

In conclusion, while Java lacks an unsigned byte type, various techniques such as type casting combined with bit masking or using ByteBuffer provide effective means for converting an int to an unsigned byte, which is crucial for scenarios requiring the representation of values from 0 to 255.

As always, the complete code samples for this article can be found over on GitHub.