在 Java 中将整数文字赋给双精度变量

发布于 2025-01-03 19:44:43 字数 147 浏览 0 评论 0原文

如果我执行以下操作

double d = 0;

，因为 0 是一个整数文字，它使用 32 位，而 d 是一个使用 64 位的双精度变量，那么剩余的 32 位是否会被随机垃圾填充，或者 Java 是否正确提升文字？

原文

If I do the following

double d = 0;

since 0 is an integer literal, which uses 32 bits, and d is a double variable that uses 64 bits, will the remaining 32 bits be filled with random garbage, or does Java promote the literal correctly?

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

你的笑 2025-01-10 19:44:44

Java 正确地推广了它，否则会有相当大的代码体出现问题:-)

Java 语言规范的第 5.1.2 节详细介绍了这一点：

以下 19 种基元类型的特定转换称为拓宽基元转换：

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

扩大基元转换不会丢失有关数值总体大小的信息。事实上，从整型到另一种整型以及从 float 到 double 的转换根本不会丢失任何信息；数值被准确保留。 strictfp 表达式中从 float 到 double 的转换也能准确保留数值；但是，此类不严格的转换可能会丢失有关转换值的总体大小的信息。
将 int 或 long 值转换为 float，或者将 long 值转换为 double，可能会导致精度损失，即结果可能会丢失该值的一些最低有效位。在这种情况下，生成的浮点值将是整数值的正确舍入版本，使用 IEEE 754 舍入到最近模式。

从 32 位 Java int 转换为 double（在 Java 中，其精度为 50+ 位），不会丢失大小或任何精度。如果您使用的常量因其值而被强制为 long，您可能会丢失精度，因为 long 具有 64 位精度。

Java promotes it correctly, otherwise there'd be a rather large body of code that was problematic :-)

Section 5.1.2 of the Java language spec details this:

The following 19 specific conversions on primitive types are called the widening primitive conversions:

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

Widening primitive conversions do not lose information about the overall magnitude of a numeric value. Indeed, conversions widening from an integral type to another integral type and from float to double do not lose any information at all; the numeric value is preserved exactly. Conversions widening from float to double in strictfp expressions also preserve the numeric value exactly; however, such conversions that are not strictfp may lose information about the overall magnitude of the converted value.
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.

Converting from a 32-bit Java int to a double (which, in Java, has 50+ bits of precision), will not lose the magnitude or any precision. If the constant you use is forced to a long due to its value, you may lose precision, since a long has 64 bits of precision.

回复收藏 0 原文