Convert byte to int Type in Java

1. Overview

Converting byte to int is a common operation, especially when dealing with low-level data manipulation, file I/O, or network communication. In this article, we’ll explore various methods through which we can achieve the byte to int conversion.

2. byte and int

In Java, byte and int are fundamental data types that serve distinct purposes in the representation of numerical values. A byte is an 8-bit signed data type with values ranging from -128 to 127. An int data type is a 32-bit signed integer, offering a wider range than byte, from -2³¹ to 2³¹-1 (-2,147,483,648 to 2,147,483,647).

3. Using Type Casting

One of the most straightforward and common approaches to performing the conversion is to simply typecast the byte variable to an int variable:

class ByteToIntConversion {
    static int usingTypeCasting(byte b) {
        int i = b;
        return i;
    }
}

In this example, we’re directly converting a byte to an int variable through assignment. Let’s test it out:

@Test
void givenByte_whenUsingTypeCasting_thenConvertToInt() {
    byte b = -51;
    int result = ByteToIntConversion.usingTypeCasting(b);
    assertEquals(-51, result);
}

4. Using Integer.valueOf()

The Integer class offers convenient methods for converting values from other primitive data types. We can employ its static method Integer.valueOf(), which facilitates the conversion of a byte to an int:

static int usingIntegerValueOf(byte b){ 
    return Integer.valueOf(b);
}

The above code example takes a byte as an input and will return an Integer instance of the specified byte value. The Java Compiler will automatically apply the unboxing since the Integer class serves as a wrapper for the primitive data type int. We can perform a test to verify its expected behavior:

@Test 
void givenByte_whenUsingIntegerValueOf_thenConvertToInt() { 
    byte b = -51; 
    int result = ByteToIntConversion.usingIntegerValueOf(b); 
    assertEquals(-51, result); 
}

5. Using the Byte Class

Byte class is a wrapper class for the primitive data type byte. It provides methods to work with byte values as objects, including conversion methods for handling byte values.

5.1. Using intValue()

The Byte class offers an indirect approach to convert a byte to an int data type through its intValue() method. To make this method effective, we transform the primitive value to its object representation and then proceed with the conversion process:

static int usingByteIntValue(byte b){
    Byte byteObj = new Byte(b);
    return byteObj.intValue();
}

In this example, the intValue() method returns an int value after performing a widening primitive conversion. Let’s test this out:

@Test
void givenByte_whenUsingByteIntValue_thenConvertToInt() { 
    byte b = -51; 
    int result = ByteToIntConversion.usingByteIntValue(b); 
    assertEquals(-51, result); 
}

5.2. Byte.toUnsignedInt()

Beginning with Java 8, the Byte class offers a utility method called toUnsignedInt for converting a byte to an unsigned integer. This method internally performs bitwise AND operation of the byte value with 0xff:

static int usingByteUnsignedInt(byte b){
    return Byte.toUnsignedInt(b);
}

It’s important to observe that by default, byte-to-int conversion retains the sign of the value. However, the above method treats the byte value as if it were an unsigned byte, producing the equivalent unsigned integer representation:

@Test 
void givenByte_whenUsingByteUnsignedInt_thenConvertToInt() { 
    byte b = -51; 
    int result = ByteToIntConversion.usingByteUnsignedInt(b); 
    assertEquals(205, result); 
}

6. Conclusion

In this tutorial, we’ve delved into different approaches for converting a byte to an int data type. Each approach provides a reliable way to perform the conversion. The choice depends on selecting the most suitable method for our specific use case.

When working with negative numbers and aiming for their signed representation, we can consider using typecasting, Integer.valueOf(), or Byte class intValue() method. Alternatively, for unsigned conversion, we can opt for Byte.toUnsignedInt()  approach.

As always, the full source code is available over on GitHub.