Understanding Primitive Numeric Type Conversions in Java

Introduction

In Java, there are primitive numeric types that are used to represent numbers. These types include byte, short, int, long, float, and double. Understanding how these types work and how they can be converted between each other is important for writing efficient and correct code.

Understanding Conversions

In Java, there are two types of conversions that can occur between primitive numeric types - widening conversions and narrowing conversions.

Widening conversions occur when a number is converted to a type that has more bits, without losing any precision. For unsigned values, the extra space is filled with zeros, while for signed values, the sign is preserved in the most significant bit and the rest is set to the extended two's complement value.
The following conversions are widening ones:

byte to short, int, long
short to int, long
char to int, long
int to long

Example:

int i = 50;
long l = i;
// l = 50, the long has more bits to store the value without precision loss
float f = 35.5f;
double d = f;
// d = 35.5, the double has more bits to store the value without precision loss

Narrowing conversions occur when a number is converted to a type that has fewer bits, resulting in a potential loss of precision. The most significant bits are discarded, leaving only the lowest part of the number.
The following integer type conversions are the narrowing ones:

short to byte or char
char to byte or short
int to byte, short, or char
long to byte, short, char, or int

Example:

long l = 6000000000L; // 00010110 01101011 11001100 11100000
int i = (int) l;
// i = 11100000, the most significant bits are discarded and the result is -32 (in two's complement form)

Conversions and the Sign Bit

In JVM, an integer can be as small as a 8-bit number or as large as a 64-bit number. The number of bits used corresponds to the size of the number being stored and the most significant bit is always used to indicate the sign. For example, an 8-bit number can store a value between 0 and 255. When the bit value is 0, the number is positive and when it is 1, the number is negative.

For instance, the binary number 0111000 is equal to 56 in decimal system. This is a positive number. However, when the most significant bit is set to 1, such as in the binary number 10111000, the number is considered negative. In this case, the rest of the bits (0111000) represent the two's complement of the number 72 (128-56=72). This is how negative integer numbers are stored in the JVM. The same principle applies to numbers with more bits, with the most significant bit determining the sign and the rest of the bits representing the two's complement of the original number.

Example:

byte b = -120; // 10001000
short s = b; // -120 is preserved in the sign bit of the short (11111111 10001000)
char c = (char) b; // the most significant bits are filled with zeros, resulting in a positive value (00001000)

Conversion Examples and Pitfalls

Converting from a large number to a smaller type can result in unexpected behavior. This is because the overflow of the smaller type can lead to the sign being wrong.

Example:

long a = 4294967295L; // 11111111 11111111 11111111 11111111
// If we try to convert this to an int, we get:
int b = (int) a; // b = -1 (because the most significant bits are discarded)

This can be a problem if you are expecting a positive value and get a negative one. It is important to be aware of these potential pitfalls when working with conversions between different numeric types.

Conclusion

Understanding how primitive numeric type conversions work in Java is important for writing efficient and correct code. Knowing the difference between widening and narrowing conversions and how the sign bit affects conversions can prevent unexpected behavior. Make sure to pay attention to potential precision loss and be aware of any potential pitfalls when converting between different numeric types.