Java allows implicit conversion of int to float. Why?

Question

In Java, we can convert an int to float implicitly, which may result in loss of precision as shown in the example code below.

public class Test {
    public  static void main(String [] args) {
        int intVal = 2147483647;
        System.out.println("integer value is " + intVal);
        double doubleVal = intVal;
        System.out.println("double value is " + doubleVal);
        float floatVal = intVal;
        System.out.println("float value is " + floatVal);
        }
}

The output is

integer value is 2147483647
double value is 2.147483647E9
float value is 2.14748365E9

What is the reason behind allowing implicit conversion of int to float, when there is a loss of precision?

Answer 1

Converting an integer type to a floating point type that uses the same number of bits may result in a loss of precision, but will be done automatically. "Loss of precision" means that some of the less significant digits may become zeros, but the most important digits and the size of the number will remain. Recall that float has only about seven decimal digits of precision. For example, converting the int 123456789 to a float 123456700.0 shows a loss of precision.

Answer 2

You are probably wondering:

Why is this an implicit conversion when there is a loss of information? Shouldn't this be an explicit conversion?

And you of course have a good point. But the language designers decided that if the target type has a range large enough then an implicit conversion is allowed, even though there may be a loss of precision. Note that it is the range that is important, not the precision. A float has a greater range than an int, so it is an implicit conversion.

The Java specification says the following:

A widening conversion of an int or a long value to float, or of a long value to double, may result in loss of precision - that is, the result may lose some of the least significant bits of the value. In this case, the resulting floating-point value will be a correctly rounded version of the integer value, using IEEE 754 round-to-nearest mode.