整除: 为什么1/3 = = 0的结果？

将其显式强制转换为 double

double g = 1.0/3.0

这是因为 Java 对 1和 3使用整数除法操作，因为您将它们作为整数常量输入。

两个操作数(1和3)是整数，因此使用整数算术(这里除)。将 result 变量声明为 double 只会导致发生隐式转换 “组织”之后。

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

另外，请注意，如果 都有操作数(数字)作为浮点数给出; 3.0和1.0，或者甚至仅仅是 第一，那么将使用浮点数算术，给出 0.333...。

1和3是整数内容，所以 Java 做了一个整数除法，结果是0。如果你想写双常量，你必须写 1.0和 3.0。

改为“ double g = 1.0/3.0;”。

因为你在做整数除法。

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

结果0.33333333不能表示为整数，因此只有整数部分(0)被赋值给结果。

如果任何一个操作符是 double/float，那么将进行浮点运算。但是如果你这样做，你也会有同样的问题:

int n = 1.0 / 3.0;

因为它将1和3视为整数，因此将结果舍入为0，所以它是一个整数。

为了得到你想要的结果，明确地告诉 java 这些数字是双精度的，如下所示:

double g = 1.0/3.0;

使1一个浮动和浮动除法将被使用

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

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

你需要至少其中之一是 float或 double。

如果在源代码中输入类似问题的值，可以执行 1.0/3; 1.0是一个 double。

如果您从其他地方得到的值，您可以使用 (double)将 int转换为 double。

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

你应该用

double g=1.0/3;

或者

double g=1/3.0;

整数除法返回整数。

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

仅针对整数的操作将该操作的结果转换为整数。

这必然意味着浮点结果，即 可以显示为整数，将被截断(删除小数部分)。

你问的 选角(类型转换/类型转换)是什么？

它在语言的实现上有所不同，但是 Wikipedia 有一个相当全面的视图，而且它也谈到了 胁迫，这是回答您的问题的关键信息。

Http://en.wikipedia.org/wiki/type_conversion

JAVA 中的转换非常简单，但是需要一些理解:

如果移位运算符以外的整数运算符具有至少一个 long 类型的操作数，则以64位精度执行该操作，并且该数值运算符的结果为 long 类型。如果另一个操作数不长，则首先通过数值升级(5.6)将其扩大(5.1.5)以输入 long。

例子总是翻译 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 类型的值。如果另一个操作数不是 double，则首先通过数值升级(5.6)将其扩大(5.1.5)以键入 double。

所以升级是在花车上完成的。

整数和浮点值的混合导致浮点值，如上所述

如果二进制运算符的操作数至少有一个是浮点类型的，那么该操作就是浮点操作，即使另一个是整数。

这对于二进制运算符是正确的，但对于像 +=这样的“赋值运算符”是不正确的

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

int i = 1;
i += 1.5f;

原因是有一个隐式强制转换在这里完成，这将被执行为

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

(1/3)表示整数除法，这就是为什么你不能从这个除法中得到十进制值的原因。要解决这个问题，使用:

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

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

因为1和3都是 int，所以结果不是四舍五入的，而是截断的。所以你忽略分数，只取整数。

为了避免这种情况，至少要有一个数字1或3作为小数形式1.0和/或3.0。

最简单的解决办法就是这么做

double g = (double) 1 / 3;

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

试试这个:

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

是我干的。

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

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

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

DR

你可以通过以下方法解决:

double g = 1.0/3.0;

或者

double g = 1.0/3;

或者

double g = 1/3.0;

或者

double g = (double) 1 / 3;

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

一个更完整的答案

双 g = 1/3;

这个结果在 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.6.2. Binary Numeric Promotion

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

如果任何操作数属于引用类型，则对其进行拆箱 转换率(5.1.8)。

将扩展基元转换(5.1.2)应用于转换 按照下列规则指定的两个操作数:

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

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

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

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

我的原则是:

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);

我注意到，这是不知何故没有提到的许多答复，但你也可以做 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);
}
}