Section 2.12 Type Conversions
Back in Section 2.8 we mentioned that Java binary operators require both operands to have the same type. Remember to pay close attention to operand types when dividing integers. A common source of errors occurs when dividing two integers, which will drop the fractional part in the resulting quotient.
What happens if two dissimilar types are passed as operands to an operator? For example, what happens if we add an int and a double? And what happens if we add a String and a double, or subtract a double from a String? Let’s find out.
jshell> int a = 2; double b = 2.0; a ==> 2 | created variable a : int b ==> 2.0 | created variable b : double jshell> a + b; $3 ==> 4.0 | created scratch variable $3 : double jshell> "a" + b; $4 ==> "a2.0" | created scratch variable $4 : String jshell> "a" - b; | Error: | bad operand types for binary operator '-' | first type: java.lang.String | second type: double | "a" - b; | ^-----^ jshell>
In the first test above, the result produced is a double. Apparently, the int
a was converted to a double automatically before the addition was performed. In the second test, we added the String "a" to the double b. This time the value of b was converted to a String first and then the + operator was executed on the String types, which results in String concatenation. The third test failed. Apparently it is not possible to subtract a double from a String in Java.In fact, this demonstrates a general rule for evaluating mixed type expressions in Java. When two operands of a binary operator are NOT of the same type, Java tries to promote one of the operands to the type of the other operand before it performs the operation indicated by the operator. This is not always successful. The error printed by the third test above clearly indicates that the
- binary operator is not valid for the operand types provided.How do we know when and which operand will be promoted? The answer is that automatic type conversions generally take place for widening primitive conversions. A widening primitive conversion occurs when the initial data type requires less memory than the converted type. In the case of adding an integer and a double, we know from Table 2.3.1 and Table 2.5.1 that a double consumes 8 bytes of memory while an int consumes only 4 bytes of memory. Consequently, automatic promotion will occur from an int to a double, but not the other way around.
The following table shows all valid widening primitive type conversions. The type listed in the FROM column may be promoted to any type in the TO column. Notice that in general the amount of memory used by the types in the TO column increases progressively from left to right. Note especially the expection that a long is promoted to a float, and not the other way around. A long consumes 8 bytes while a float consumes only 4 bytes.
| FROM | TO |
|---|---|
byte |
short, int, long, float, double
|
short |
int, long, float, double
|
int |
long, float, double
|
long |
float, double
|
float |
double |
char |
int, long, float, double
|
There are a few other special cases to consider.
In the previous example we added a String and a double. As we know, a String is not primitive type. Yet, a primitive type may be promoted to a String automatically in an expression when the operator can take String operands. This type of conversion is called String conversion. Any type in Java may be converted to a String. This may occur automatically as part of the evaluation of an expression, or explicitly. The best way to perform the explicit convertion of a primitive type to a String is to use the built-in
String.valueOf(…) static method. For example, the expression String.valueOf(3.14) evaluates to the String "3.14". But the automatic type conversion performed by expression evaluation gives us another way to convert anything to a String. Just add "" to any individual data. See the session below, for an example.jshell> String.valueOf(3.14); $1 ==> "3.14" | created scratch variable $1 : String jshell> 3.14 + ""; $2 ==> "3.14" | created scratch variable $2 : String jshell>
When you perform arithmetic operations like
+ on byte or short integers, you’ll notice that the result is always of type int, and not byte or short. The reason for this is that Java does not define arithmetic operators for byte and short integer types. Instead, it promotes both operands to an int before performing the operation. This is the reason the result is always an int. If you really want the result to be a byte or a short integer expression, you’ll have to explicitly convert the result back to the desired type. This is the subject of the next section.
Narrowing primitive conversions occur when converting a value of a data type that consumes more memory to one that consumes less memory. In narrowing primitive conversions, there is a potential loss of information or precision. Clearly this is case when we force more bytes into less memory. Narrowing primitive conversions must be performed explicitly using a technique called casting. To cast an expression, precede the expression with the desired type surrounded with parentheses.
For example, converting a double to an int requires explicit casting:
jshell> double pi = 3.14; pi ==> 3.14 | created variable pi : double jshell> (int)pi; // Narrowing primitive conversion cast double to int $2 ==> 3 | created scratch variable $2 : int jshell>
In the above example, the value of
pi (a double) is explicitly cast to int using the (int) cast. The double stored in 8 bytes was reformulated and copied to the 4 bytes of memory available to the int.The following table shows all valid narrowing primitive conversions of primitive types, which can be performed using a cast.
| FROM | TO |
|---|---|
byte |
char |
short |
byte, char
|
int |
byte, short, char
|
long |
byte, short, char, int
|
float |
byte, short, char, int, long
|
double |
byte, short, char, int, long, float
|
char |
byte, short
|
It’s important to remember that narrowing conversions may result in data loss or truncation. For example, when converting a floating-point value to an integer, the fractional part is discarded, leading to the potential loss of precision. It is also worth pointing out that we can convert freely between seven of the eight primitive types. In Java, even a
char may be converted to a numeric type. Only the boolean primitive type cannot be converted to a numeric type.There is a way to reverse a String conversion, that is, to turn a String representation of a primitive back into a primitive type. This process is more sophisticated, requiring careful parsing of the characters in the String. For most Java primitives (all except
char) Java provides a class equivalent for the primitive type that implements a static method that starts with parse…. These methods take a String parameter and attempt to parse it, returning a value having the corresponding primitive type. The following table lists the class equivalents of each primitive type and demonstrates the use of the relevant static method.| Primitive | Class | Parse method | Evaluates to |
|---|---|---|---|
byte |
Byte |
Byte.parseByte("1") |
1 (byte) |
short |
Short |
Short.parseShort("1") |
1 (short) |
int |
Integer |
Integer.parseInt("1") |
1 (int) |
long |
Long |
Long.parseLong("1") |
1 (long) |
float |
Float |
Float.parseFloat("3.15") |
3.14 (float) |
double |
Double |
Double.parseDouble("3.15") |
3.14 (double) |
boolean |
Boolean |
Boolean.parseBoolean("true") |
true (boolean) |
As we’ve seen, type conversions (e.g. primitive promotion and String conversion) take place automatically during expression evaluation. The specific conversion that occurs depends entirely on the types that operands have at the moment the operator is evaluated. This might not be obvious by looking at an expression before evaluation. Prediction of the type from the evaluation of a given expression requires a careful tracking of the expression evaluation process intermixed with necessary types conversions. The order of subexpression evaluation must follow operator precedence and left-to-right evaluation.
Consider the following expressions and their evaluated value and type. Can you explain how each value and type of the evaluation result is obtained?
| Expression | Evaluated Value | Evaluated Type |
|---|---|---|
1 + 1.0 |
2.0 |
double |
1.0F + 1 |
2.0F |
float |
1 + 1L |
2L |
long |
(long)1.5 + 1F |
2.0 |
float |
1 + "1" |
"11" |
String |
"2" + 2 |
"22" |
String |
1 + 1 + "1" |
"21" |
String |
"1" + 1 + 1 |
"111" |
String |
"1" + (1 + 1) |
"12" |
String |
(2 > 1) + "blue" |
"trueblue" |
String |
Type promotion and conversions are essential in Java for maintaining compatibility between different data types and enabling operations involving different types. Understanding the rules and implications of type promotion and conversions is crucial to ensure correct and reliable behavior in Java programs.
