我写的是这段代码：

public static void main(String[] args) {

double g = 1 / 3;

System.out.printf("%.2f", g);

}

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

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

整数除法当然会将除法的真实结果舍入为零。因此，0.333...的结果向下舍入为0。 (请注意，处理器实际上并没有进行任何舍入，但你可以这样想。)

另请注意，如果两个操作数(数字)都以浮点数形式给出; 3.0和1.0，或者甚至只是第一个，然后使用浮点运算，给你0.333...。

+1并且它总是向下舍入。 int i = .99999999将int设置为0.更具体地说，它取整数部分并丢弃其余部分。

它向"向零"舍入，对于大于零的值，它向下"向下"。 (+0.9四舍五入为0，-0.9也四舍五入为0.)

@Byron：是的，确切地说。我不相信处理器实际上会进行任何舍入，因为除法的实现方式非常不同，但是通过这种方式来考虑它是很方便的。

不，不舍入：截断

@BasilBourque在java术语中，舍入DOWN朝向零。舍入FLOOR朝向负无穷大。

作为参考，Java 8 JLS在15.7.2中有这个。其他版本将在相应的分部操作员部分中使用它。

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

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

如果您在输入源代码中的值(如问题)，则可以执行1.0/3; 1.0是双倍的。

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

int x = ...;

int y = ...;

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

明确地将其强制转换为double

double g = 1.0/3.0

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

你应该使用

double g=1.0/3;

要么

double g=1/3.0;

整数除法返回整数。

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

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

结果0.33333333不能表示为整数，因此只将整数部分(0)分配给结果。

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

int n = 1.0 / 3.0;

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

double g = ((double) 1 / 3);

这样做，因为你没有输入1.0 / 3.0，让你手动将它转换为数据类型double，因为Java假设它是整数除法，即使它意味着缩小转换也会这样做。 这就是所谓的演员。

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

If an integer operator other than a shift operator has at least one operand of type long, then the operation is carried out using 64-bit precision, and the result of the numerical operator is of type long. If the other operand is not long, it is first widened (§5.1.5) to type long by numeric promotion (§5.6).

一个例子总是翻译JLS的最佳方式;)

int + long -> long

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

Otherwise, the operation is carried out using 32-bit precision, and the result of the numerical operator is of type int. If either operand is not an int, it is first widened to type int by numeric promotion.

short + int -> int + int -> int

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

short s = 1;

s = s + s;

//possible loss of precision

//  required: short

//  found:    int

这将需要可能损失精度的铸件。

浮点运算符也是如此

If at least one of the operands to a numerical operator is of type double, then the operation is carried out using 64-bit floating-point arithmetic, and the result of the numerical operator is a value of type double. If the other operand is not a double, it is first widened (§5.1.5) to type double by numeric promotion (§5.6).

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

并且整数和浮点值的混合导致浮动值如上所述

If at least one of the operands to a binary operator is of floating-point type, then the operation is a floating-point operation, even if the other is integral.

这适用于二元运算符，但不适用于像+=这样的"赋值运算符"

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

int i = 1;

i += 1.5f;

原因是这里有一个隐式转换，这将执行就像

i = (int) i + 1.5f

i = (int) 2.5f

i = 2

使1成为浮点数并使用浮点除法

public static void main(String d[]){

double g=1f/3;

System.out.printf("%.2f",g);

}

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

要获得您正在寻找的结果，请明确告诉java这些数字是双倍的：

double g = 1.0/3.0;

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

public static void main(String[] args) {

double g = 1 / 3;

System.out.printf("%.2f", g);

}

由于1和3都是整数，因此结果不会舍入，但会被截断。 因此，您忽略分数并仅采用整体。

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

(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 a = 1.0;

double b = 3.0;

double g = a / b;

System.out.printf(""+ g);

}

请不要发布仅代码答案，包括解释您的代码的作用以及解决问题问题的方式(以及原因)。还要考虑这是一个有8年历史的问题，现有的答案是否存在，以及您的答案是否会增加现有答案的任何价值。

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

An operation on only integers casts the result of the operation to an integer.

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

你问的是什么是强制转换(类型转换/类型转换)？

它在语言的实现方面有所不同，但维基百科有一个相当全面的观点，它确实讨论了强制，这是回答你的问题的关键信息。

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

这个答案是有缺陷的。没有类型转换或类型转换涉及像12这样的所有整数转换，而不是目标语言(java)。您只需调用整数除法，这将产生整数结果。类型转换仅仅是因为在分配期间从int向上转换为double。

@YoYo你说0.5是一个整数？我不这么认为，亲爱的。

这个人对0.5没有说什么。简单地说，在Java中，12是一个整数除法，它产生一个零整数。您可以将零指定为double，它仍然为零，尽管0.0为double。

做"双g = 1.0 / 3.0;"代替。

只是好奇......这个答案出了什么问题？我第一次遇到问题时使用了这种方法。对此解决方案的问题的解释将不胜感激。提前致谢。

@ Mr.PortStJoe它没有向提出问题的人提供任何细节。看看评分最高的答案，我们可以看到他们解释了为什么会发生这种情况。虽然答案可能在技术上是正确的，但其有用性可能被视为有限。