整数除法：为什么1/3==0的结果是0？

Question

我正在写这段代码：

public static void main(String[] args) {
    double g = 1 / 3;
    System.out.printf("%.2f", g);
}

结果是0。这是为什么，我该如何解决这个问题？

Answer 1

两个操作数（1 和 3）都是整数，因此使用整数运算（此处为除法）。将结果变量声明为 double 只会导致除法后发生隐式转换。

整数除法当然返回除法的真实结果，四舍五入为零。因此，0.333... 的结果在此向下舍入为 0。 （请注意，处理器实际上并不进行任何舍入，但您仍然可以这样想。）

此外，请注意，如果两个操作数（数字）都以浮点数形式给出； 3.0 和 1.0，甚至只是第一个，然后使用浮点运算，得到 0.333...。

Answer 2

1/3 使用整数除法，因为两边都是整数。

您至少需要其中一个为 float 或 double。

如果您像您的问题一样在源代码中输入值，则可以执行 1.0/3 ； 1.0 是双精度值。

如果您从其他地方获取值，则可以使用 (double) 将 int 转换为 double。

int x = ...;
int y = ...;
double value = ((double) x) / y;

Answer 3

显式地将其转换为 double

double g = 1.0/3.0

发生这种情况是因为 Java 对 1 和 3 使用整数除法运算，因为您将它们作为整数常量输入。

Answer 4

因为你正在进行整数除法。

正如@Noldorin 所说，如果两个运算符都是整数，则使用整数除法。

结果 0.33333333 无法表示为整数，因此仅将整数部分 (0) 分配给结果。

如果任何运算符是双精度/浮点型，则将进行浮点运算。但如果你这样做，你会遇到同样的问题：

int n = 1.0 / 3.0;

Answer 5

最简单的解决方案就是这样做

double g = (double) 1 / 3;

，因为您没有输入 1.0 / 3.0，所以它的作用是让您手动将其转换为数据类型 double，因为 Java 假定它是整数除法，即使这意味着缩小，它也会这样做转换。这就是所谓的强制转换运算符。
这里我们只转换一个操作数，这足以避免整数除法（向零舍入）

Answer 6

结果是0。这是为什么，如何解决这个问题？

TL;DR

您可以通过执行以下操作来解决此问题：

double g = 1.0/3.0; 

or or

double g = 1.0/3; 

or

double g = 1/3.0; 

or

double g = (double) 1 / 3;

当您使用变量时，需要使用最后一个选项，例如 int a = 1, b = 3;双 g = (双) a / b;。

更完整的答案

双 g = 1 / 3;

这导致 0 因为

• 首先被除数 0除数;
• 两个变量都是 int 类型，因此导致 int (5.6.2. JLS) 自然无法表示 0.333333.. 等浮点值。
• “整数除法向 0 舍入。” 15.17.2 JLS

为什么 double g = 1.0/3.0; 和 double g = ((double) 1) / 3; 有效？

来自第 5 章. 转化和促销一可以阅读：

一个转换上下文是数字运算符的操作数，例如 +
或者 *。此类操作数的转换过程称为数值
晋升。促销的特殊之处在于，在二进制的情况下
运算符，为一个操作数选择的转换可能部分取决于
另一个操作数表达式的类型。

和5.6.2。二进制数字促销

当运算符将二进制数字提升应用于一对
操作数，每个操作数必须表示一个可转换为
数字类型，以下规则按顺序适用：

如果任何操作数是引用类型，则对其进行拆箱
转换（§5.1.8）。

加宽基元转换（第 5.1.2 节）适用于转换或
两个操作数均由以下规则指定：

如果其中一个操作数为 double 类型，则另一个操作数将转换为 double。

否则，如果其中一个操作数为 float 类型，则另一个将被转换
漂浮。

否则，如果其中一个操作数为 long 类型，则另一个将被转换
太长了。

否则，两个操作数都将转换为 int 类型。

Answer 7

您应该使用

double g=1.0/3;

或

double g=1/3.0;

整数除法返回整数。

Answer 8

JAVA中的转换非常简单，但需要一些理解。正如 JLS 中对 的解释整数运算：

如果除移位运算符之外的整数运算符至少有一个 long 类型的操作数，则使用 64 位精度进行运算，并且数值运算符的结果为 long 类型。如果另一个操作数不长，则首先将其加宽（第 5.1.5 节），通过数字提升（第 5.6 节）键入长整型。

例子始终是翻译 JLS 的最佳方式；）

int + long -> long
int(1) + long(2) + int(3) -> long(1+2) + long(3)

否则，使用32位精度进行运算，数值运算符的结果为int类型。如果任一操作数不是 int，则首先通过数字提升将其扩展为 int 类型。

short + int -> int + int -> int

使用 Eclipse 的一个小示例表明，即使添加两个 short 也不会那么容易：

short s = 1;
s = s + s; <- Compiling error

//possible loss of precision
//  required: short
//  found:    int

这将需要进行可能会损失精度的转换。

也是如此浮点运算符

如果数值运算符的至少一个操作数是 double 类型，则该运算使用 64 位浮点算术执行，并且数值运算符的结果是 double 类型的值。如果另一个操作数不是双精度数，则首先通过数字提升将其扩展（第 5.1.5 节）以键入双精度型（第 5.6 节）。

所以促销是在浮动上完成的。

如上所述，整数和浮点值的混合会产生浮点值

如果二元运算符的至少一个操作数是浮点类型，则该运算是浮点运算，即使另一个是整数也是如此。

这对于二元运算符是正确的，但对于像 += 这样的“赋值运算符”则不然。

一个简单的工作示例足以证明这一点。

int i = 1;
i += 1.5f;

原因是这里完成了隐式转换，这将像这样执行

i = (int) i + 1.5f
i = (int) 2.5f
i = 2

Answer 9

我这样做了。

double g = 1.0/3.0;
System.out.printf("%gf", g);

在进行双重计算时使用 .0，否则 Java 会假设您使用的是整数。如果计算使用任意数量的双精度值，则输出将是双精度值。如果都是整数，那么输出将是一个整数。

Answer 10

将 1 设置为浮点型并使用浮点除法

public static void main(String d[]){
    double g=1f/3;
    System.out.printf("%.2f",g);
}

Answer 11

1 和 3 是整数常量，因此 Java 进行整数除法，结果为 0。如果要编写双精度常量，则必须编写 1.0 和 3.0。

Answer 12

因为它将 1 和 3 视为整数，因此将结果向下舍入为 0，使其成为整数。

要获得您正在寻找的结果，请显式告诉 java 这些数字是双精度数，如下所示：

double g = 1.0/3.0;

Answer 13

(1/3) 表示整数除法，这就是为什么您不能从此除法中获得小数值。要解决此问题，请使用：

public static void main(String[] args) {
        double g = 1.0 / 3;
        System.out.printf("%.2f", g);
    }

Answer 14

public static void main(String[] args) {
    double g = 1 / 3;
    System.out.printf("%.2f", g);
}

由于 1 和 3 都是整数，因此结果不会四舍五入，而是会被截断。所以你忽略分数而只取整数。

为了避免这种情况，至少将数字 1 或 3 之一作为十进制形式 1.0 和/或 3.0。

Answer 15

我注意到许多回复中都没有提到这一点，但您也可以执行 1.0 * 1 / 3 来获得浮点除法。当您的变量不能仅在其后添加 .0 时，这会更有用，例如

import java.io.*;

public class Main {
    public static void main(String[] args) {
        int x = 10;
        int y = 15;
        System.out.println(1.0 * x / y);
    }
}

Answer 16

执行“双 g=1.0/3.0;”反而。

Answer 17

试试这个：

public static void main(String[] args) {
    double a = 1.0;
    double b = 3.0;
    double g = a / b;
    System.out.printf(""+ g);
}

Answer 18

我的代码是：

System.out.println("enter weight: ");
int weight = myObj.nextInt();

System.out.println("enter height: ");
int height = myObj.nextInt();

double BMI = weight / (height *height)
System.out.println("BMI is: " + BMI);

如果用户输入体重（分子）= 5，身高（分母）= 7，
BMI 为 0，其中分母 >分子与它返回整数 (5/7 = 0.71 ) 所以结果是 0 （没有小数值）

解决方案：

选项 1：

doubleouble  BMI = (double) weight / ((double)height * (double)height);

选项 2：

double  BMI = (double) weight / (height * height);

Answer 19

许多其他人未能指出真正的问题：

仅对整数进行运算会将运算结果转换为整数。

这必然意味着可以显示为整数的浮点结果将被截断（去掉小数部分）。

您问什么是强制转换（类型转换/类型转换）？

它因语言的实现而异，但维基百科有一个相当全面的视图，并且它也讨论了强制，这是回答您的问题的关键信息。

http://en.wikipedia.org/wiki/Type_conversion