Deep dive into bits, bytes, shorts, ints, longs, signed, and unsigned with Java
On the Pi4J discussion list, someone recently asked what the best and easiest way is in Java to convert a byte value. In Java, there is no distinction between signed and unsigned bytes, which can be confusing. My book “Getting Started with Java on the Raspberry Pi” contains an explanation about this, and I am happy to share it in this post with some more info and code examples…
You can find all the code of this post on GitHub.
The Basics: Bits
Let’s start with the basics: bits, 0 or 1.
A bit (binary digit) is the smallest unit of data in a computer, and has two possible values: 0 or 1. Bits are the foundation of everything that happens in a computer. All instructions or data stored in memory are represented as combinations of bits. Bits are mostly grouped together into larger units such as bytes or words, so they can represent numbers, characters, or control signals, depending on the context in which they are used.
In everyday life, we are used to decimal values where we group everything by 10, 20, 30,… In programming, hexadecimal (or hex) values are often used, which group numbers by sixteen. Hexadecimal values range from 0 to 15, which matches perfectly with the maximum value of four bits (1111 in binary). Each hex digit can represent a value from 0 to F, where F is 15 in decimal. A hex value is typically written as 0x0 to 0xF to distinguish it from decimal notation.
Each binary digit (bit) represents a power of 2, starting from the rightmost bit (which is 2^0) and moving left. The value of the binary number is the sum of the powers of 2 where there is a bit 1.
The following table shows all possible combinations of 4 bits ranging from “0000” to “1111”.
| Bits | 2^3 | 2^2 | 2^1 | 2^0 | + | Number | HEX |
|---|---|---|---|---|---|---|---|
| 8 | 4 | 2 | 1 | ||||
| 0000 | 0 | 0 | 0 | 0 | 0+0+0+0 | 0 | 0x0 |
| 0001 | 0 | 0 | 0 | 1 | 0+0+0+1 | 1 | 0x1 |
| 0010 | 0 | 0 | 1 | 0 | 0+0+2+0 | 2 | 0x2 |
| 0011 | 0 | 0 | 1 | 1 | 0+0+2+1 | 3 | 0x3 |
| 0100 | 0 | 1 | 0 | 0 | 0+4+0+0 | 4 | 0x4 |
| 0101 | 0 | 1 | 0 | 1 | 0+4+0+1 | 5 | 0x5 |
| 0110 | 0 | 1 | 1 | 0 | 0+4+2+0 | 6 | 0x6 |
| 0111 | 0 | 1 | 1 | 1 | 0+4+2+1 | 7 | 0x7 |
| 1000 | 1 | 0 | 0 | 0 | 8+0+0+0 | 8 | 0x8 |
| 1001 | 1 | 0 | 0 | 1 | 8+0+0+1 | 9 | 0x9 |
| 1010 | 1 | 0 | 1 | 0 | 8+0+2+0 | 10 | 0xA |
| 1011 | 1 | 0 | 1 | 1 | 8+0+2+1 | 11 | 0xB |
| 1100 | 1 | 1 | 0 | 0 | 8+4+0+0 | 12 | 0xC |
| 1101 | 1 | 1 | 0 | 1 | 8+4+0+1 | 13 | 0xD |
| 1110 | 1 | 1 | 1 | 0 | 8+4+2+0 | 14 | 0xE |
| 1111 | 1 | 1 | 1 | 1 | 8+4+2+1 | 15 | 0xF |
This video by Mathmo14159 very nicely illustrates how this works.
And we can achieve the same result with the following Java code:
System.out.println("Value\tBits\tHex");
for (int i = 0; i <= 15; i++) {
System.out.println(i
+ "\t" + String.format("%4s", Integer.toBinaryString(i)).replace(' ', '0')
+ "\t0x" + Integer.toHexString(i).toUpperCase());
}
// Output
Value Bits Hex
0 0000 0x0
1 0001 0x1
2 0010 0x2
3 0011 0x3
4 0100 0x4
5 0101 0x5
6 0110 0x6
7 0111 0x7
8 1000 0x8
9 1001 0x9
10 1010 0xA
11 1011 0xB
12 1100 0xC
13 1101 0xD
14 1110 0xE
15 1111 0xF
Bits to Byte
A byte consists of 8 bits and has the range of 0x00 (= 0) to 0xFF (= 255).
So we need to extend the table above to have 8 bits. Let’s take a few examples:
| Bits | 2^7 | 2^6 | 2^5 | 2^4 | 2^3 | 2^2 | 2^1 | 2^0 | + | Total | HEX |
|---|---|---|---|---|---|---|---|---|---|---|---|
| 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 | ||||
| 00000001 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 1 | 1 | x01 |
| 00000010 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 2 | 2 | x02 |
| 00000011 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 1 | 2+1 | 3 | x03 |
| 00000100 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 4 | 4 | x04 |
| 00001111 | 0 | 0 | 0 | 0 | 1 | 1 | 1 | 1 | 8+4+2+1 | 15 | x0F |
| 00011111 | 0 | 0 | 0 | 1 | 1 | 1 | 1 | 1 | 16+…+1 | 31 | x1F |
| 00100000 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 32 | 32 | x20 |
| 11111111 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 128+…+1 | 255 | xFF |
Again, outputting the same with Java code:
System.out.println("Value\tBits\tHex");
for (int i = 0; i <= 255; i++) {
System.out.println(i
+ "\t" + String.format("%8s", Integer.toBinaryString(i)).replace(' ', '0')
+ "\t0x" + Integer.toHexString(i).toUpperCase());
}
// Output
Value Bits Hex
0 00000000 0x0
1 00000001 0x1
2 00000010 0x2
3 00000011 0x3
...
15 00001111 0xF
16 00010000 0x10
17 00010001 0x11
...
253 11111101 0xFD
254 11111110 0xFE
255 11111111 0xFF
Value Ranges in Java
A bit doesn’t really exist as a data type in Java. However, the closest match is a boolean type, which can represent two states: true (equivalent to 1) and false (equivalent to 0). To store numeric whole values (without decimals), Java provides different primitive types, each with its own range and characteristics.
Difference between Byte, Short, Integer and Long
All these are numeric objects and each uses a fixed number of bytes in memory:
| Type | N° of bits | N° of bytes | Minimum | Maximum |
|---|---|---|---|---|
| byte | 8 | 1 | 0x00 | 0xFF |
| short | 16 | 2 | 0x0000 | 0xFFFF |
| int | 32 | 4 | 0x00000000 | 0xFFFFFFFF |
| long | 64 | 8 | 0x0000000000000000 | 0xFFFFFFFFFFFFFFFF |
Minimum and maximum values in Java
Let’s go back to Java and check how values are represented with the following code:
System.out.println("Byte");
System.out.println(" Min: " + Byte.MIN_VALUE);
System.out.println(" Max: " + Byte.MAX_VALUE);
System.out.println("Short");
System.out.println(" Min: " + Short.MIN_VALUE);
System.out.println(" Max: " + Short.MAX_VALUE);
System.out.println("Integer");
System.out.println(" Min: " + Integer.MIN_VALUE);
System.out.println(" Max: " + Integer.MAX_VALUE);
System.out.println("Long");
System.out.println(" Min: " + Long.MIN_VALUE);
System.out.println(" Max: " + Long.MAX_VALUE);
As a result, we get these values:
Byte
Min: -128
Max: 127
Short
Min: -32768
Max: 32767
Integer
Min: -2147483648
Max: 2147483647
Long
Min: -9223372036854775808
Max: 9223372036854775807
Hmm, this is unexpected! Does a byte have the range of -128 to 127, instead of 0 to 255?! That’s why we need to understand the difference between signed and unsigned values.
Signed versus Unsigned
- Signed Byte: The most significant bit (MSB = the most left one) is used as the sign bit, indicating whether the value is positive or negative. This results in a range for a byte of -128 to 127.
- Unsigned Byte: All bits are used for the value, without a sign bit. This results in a range for a byte of 0 to 255.
Java does not have a native unsigned byte type, but you can achieve unsigned behavior by treating a byte as an int or using bitwise operations.
When you calculate the byte value to a signed number value, the major bit (the most left one) is handled as an indicator for a negative number (1) or a positive number (0). Let’s try a few examples:
System.out.println("Bits to byte");
System.out.println("Byte value 00000001: " + ((byte) Integer.parseInt("00000001", 2)));
System.out.println("Byte value 00001111: " + ((byte) Integer.parseInt("00001111", 2)));
System.out.println("Byte value 01111111: " + ((byte) Integer.parseInt("01111111", 2)));
System.out.println("Byte value 10000000: " + ((byte) Integer.parseInt("10000000", 2)));
System.out.println("Byte value 10000001: " + ((byte) Integer.parseInt("10000001", 2)));
System.out.println("Byte value 10001111: " + ((byte) Integer.parseInt("10001111", 2)));
// Output
Bits to byte
Byte value 00000001: 1
Byte value 00001111: 15
Byte value 01111111: 127
Byte value 10000000: -128
Byte value 10000001: -127
Byte value 10001111: -113
Using Masks
A mask is a value used in bitwise operations to extract or manipulate specific bits of another value. By applying a mask in the format byte & 0xFF, we can convert a byte value to it’s unsigned integer value. By applying the mask 0xFF, which has only 8 bits, you effectively keep only the lower 8 bits of the byte value when it’s converted to an integer.
As you can see from the following code example, applying a mask converts a byte to an integer, and shows the unsigned value for 10001111.
System.out.println("Byte to Integer with mask");
var b = (byte) Integer.parseInt("10001111", 2);
System.out.println("Byte value: " + b);
var bWithMask = b & 0xff;
System.out.println("Byte value with mask: " + bWithMask);
System.out.println("Object Type: " + printObjectType(bWithMask));
// Helper method to show the type of object
private static String printObjectType(Object obj) {
if (obj != null) {
return obj.getClass().getName();
} else {
return "NULL";
}
}
// Output
Byte value: -113
Byte value with mask: 143
Object Type: java.lang.Integer
Using Helper Methods
Applying a mask is a short piece of code and you can easily add it to your code to convert a signed byte to its unsigned integer equivalent. However, there are also built-in helper methods available in Java that return the same result but are more readable. This is important for code reviews or when you or someone else need to mainten or extend the code: Byte.toUnsignedInt(b) and Byte.toUnsignedLong(b).
System.out.println("Byte to Integer with toUnsignedInt");
var unsignedInt = Byte.toUnsignedInt(b);
System.out.println("Byte to unsigned integer: " + unsignedInt);
System.out.println("Object Type: " + printObjectType(unsignedInt));
// In case you need it as a Long...
System.out.println("Byte to Long with toUnsignedLong");
var unsignedLong = Byte.toUnsignedLong(b);
System.out.println("Byte to unsigned long: " + unsignedLong);
System.out.println("Object Type: " + printObjectType(unsignedLong));
// Output
Byte to Integer with toUnsignedInt
Byte to unsigned integer: 143
Object Type: java.lang.Integer
Byte to Long with toUnsignedLong
Byte to unsigned long: 143
Object Type: java.lang.Long
Same Approach for Short
A short in Java uses 16 bits (or 2 bytes) and can be handled similarly when converting from its binary representation. A short is also a signed data type, with a range of -32,768 to 32,767.
System.out.println("Example with short");
short s1 = (short) Integer.parseInt("1000000000000000", 2);
System.out.println("Short value 1000000000000000: " + s1);
System.out.println("Short value 1000000000000000 with mask: " + (s1 & 0xFFFF));
System.out.println("Using Short.toUnsignedLong: " + Short.toUnsignedInt(s1));
short s2 = (short) Integer.parseInt("1111111111111111", 2);
System.out.println("Short value 1111111111111111: " + s2);
System.out.println("Short value 1111111111111111 to unsigned: " + Short.toUnsignedInt(s2));
// Output
Example with short
Short value 1000000000000000: -32768
Short value 1000000000000000 with mask: 32768
Using Short.toUnsignedLong: 32768
Short value 1111111111111111: -1
Short value 1111111111111111 to unsigned: 65535
Example use of Bits
A nice example of the use of bits and bytes, is included in my book. A LED number display is a typical component used in a lot of experiments with electronics and is also used in e.g. alarm clocks. Such a display has 7 segments to for the number, and one for the dot. So a total of 8 true/false values to define what must be displayed. This makes it the perfect example of how 8 booleans can be combined into one byte.
In 2019, I even published a JavaFX library with a component to visualize such a display, as you can read here: “LED number display JavaFX library published on Maven”.
Conclusion
Understanding how to work with bits, bytes and shorts in Java is essential for effective programming, especially when dealing with low-level data manipulation for electronic components, such as with Raspberry Pi and Pi4J projects. The way Java handles signed data types can sometimes be confusing, but by using masks and/or the helper methods like Byte.toUnsignedInt() and Short.toUnsignedInt(), you can efficiently convert these values.
Remark
This is a returning question, so also this blog post is not completely new ;-) A shorter version was published on October 25, 2019. I created this new post to provide deeper explanation, a video, and more Java code examples.