为什么Java会在这种情况下将double类型转换为float类型？

Question

Today, I defined two float variable f1 and f2 . Then I perform an addition, "+", arithmetic operation and assign to float variable f .

float f1 = 0.5048076923076923F;
float f2 = 0.5048076923076923F;
float f = f1 + f2;

This is the output:

According to this picture, All floating point values ( float and double ) in an arithmetic operation ( +, −, *, / ) are converted to double type: picture source: http://www.mathcs.emory.edu/~cheung/Courses/170/Syllabus/04/mixed.html

I found an identical question but it hasn't explain why. Why doesn't eclipse have any issue tips? Is it the reason why the value of "f1 + f2" is a float type? And, why will Java auto convert the double to float type if like the above picture saying?

Answer 1

You seem to be saying that there is a conversion to float in the following.

float f1 = 0.5048076923076923F;
float f2 = 0.5048076923076923F;
float f = f1 + f2;

In fact, there is no conversion. The values are all float .

In particular, the literal 0.5048076923076923F is a float . The trailing F makes it a float . If you want a double literal, leave off the F or replace it with D .

When your teacher says "all floating point values are converted to double " he is wrong. The JLS says (in effect) that a numeric primitive operand will be converted to double when the other operand is a double . If both operands are float , then the operation will performed using single-precision floating point arithmetic.

The JLS reference is JLS 5.6.2: Binary Numeric Promotion .

---

It has been pointed out that there may be additional conversions happening at the hardware level. For example, the JLS says this:

Within an expression that is not FP-strict, some leeway is granted for an implementation to use an extended exponent range to represent intermediate results; the net effect, roughly speaking, is that a calculation might produce "the correct answer" in situations where exclusive use of the float value set or double value set might result in overflow or underflow.

However:

• This is only allowed if the expression is not strictfp .
• These are not the "conversions" that the JLS talks about in JLS 5.6.2.
• This still contradicts what the OP's teacher is saying. He (or she) states that the all floating point calculations are done using double . The JLS states that under certain circumstances , a hardware platform may use extended precision arithmetic (possibly with more precision than 64 bit floating point), and in other circumstances it must not do this .

Answer 2

Your teacher is incorrect, kindly refer him to section 5.6.2 of the Java Language Specification , which states:

• Widening primitive conversion (§5.1.2) is applied to convert either or both operands as specified by the following rules:

  • If either operand is of type double, the other is converted to double.

  • Otherwise, if either operand is of type float, the other is converted to float.

  • Otherwise, if either operand is of type long, the other is converted to long.

  • Otherwise, both operands are converted to type int.

As you can see, floats are only converted to double if the other operand is a double , not in all cases as your syllabus incorrectly states.

That is, the sum of two floats is a float, but the sum of a float and a double is a double.

PS: And no, Java will never convert a double to a float unless you explicitly ask it to, as in:

float f = (float) Math.PI;

Answer 3

Hi for floating points values JVM uses instructions like this:

'+' : fadd : pops two floats, adds them, and pushes the float result
'-' : fsub : pops two floats, subtracts them and pushes the flot result

similarly for there are other instructions set for other operators like * and / etc.

So as per JVM implementation point of view float + float will result to float.
But float + double will result to double.

For more information, you can read chapter 14. Floating-Point Arithmetic of the book "Inside Java Virtual Machine"

Answer 4

What the other answers are missing is the hardware level. Floating point processors, in general, convert all operations to double (or quad), and then return the result in the requested precision. The Java specification may not recognize the conversion, but if it uses the floating point hardware then the conversion happens.