blocks|key|4279611|text|两个操作数(1和3)是整数，因此使用整数运算(这里是除法)。将结果变量声明为double只会导致除法后发生隐式转换。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4279612|当然，整数除法返回四舍五入为零的除法的真实结果。因此，0.333...的结果在这里四舍五入为0。(请注意，处理器实际上并不进行任何舍入，但您仍然可以这样认为。)|offset|length|style|CODE|4279613|另外，请注意，如果两个操作数(数字)都是以浮点数形式给出的:+3.0和1.0，甚至是第一个，则使用浮点算术，从而得到0.333...。|4279614|entityMap^0|0|R|8|0|1M|8|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@$D|Q|E|R|F|G]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|K|$]]

The two operands (1 and 3) are integers, therefore integer arithmetic (division here) is used. Declaring the result variable as double just causes an implicit conversion to occur after division.

Integer division of course returns the true result of division rounded towards zero. The result of <code>0.333...</code> is thus rounded down to 0 here. (Note that the processor doesn't actually do any rounding, but you can think of it that way still.)

Also, note that if both operands (numbers) are given as floats; 3.0 and 1.0, or even just the first, then floating-point arithmetic is used, giving you <code>0.333...</code>.

blocks|key|610226|text|1/3使用整数除法，因为两边都是整数。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|610227|您至少需要其中一个是float或double。|610228|如果像您的问题一样在源代码中输入值，则可以执行1.0/3；1.0是一个双精度型。|610229|如果您从其他地方获得值，则可以使用(double)将int转换为double。|610230|int+x+=+...;
int+y+=+...;
double+value+=+((double)+x)+/+y;|code-block|syntax|javascript|610231|entityMap^0|0|3|0|A|5|G|6|0|N|5|T|3|0|H|8|Q|3|W|6|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|V|8|@$9|W|A|X|B|C]|$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|15|8|@$9|16|A|17|B|C]|$9|18|A|19|B|C]|$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|L|3|M|5|N|7|1C|8|@]|D|@]|E|$O|P]]|$1|Q|3|-4|5|6|7|1D|8|@]|D|@]|E|$]]]|R|$]]

<code>1/3</code> uses integer division as both sides are integers.

You need at least one of them to be <code>float</code> or <code>double</code>.

If you are entering the values in the source code like your question, you can do <code>1.0/3</code> ; the <code>1.0</code> is a double.

If you get the values from elsewhere you can use <code>(double)</code> to turn the <code>int</code> into a <code>double</code>.

<pre><code>int x = ...;
int y = ...;
double value = ((double) x) / y;
</code></pre>

blocks|key|2676951|text|将其显式转换为double|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2676952|double+g+=+1.0/3.0|code-block|syntax|javascript|2676953|这是因为Java对1和3使用了整数除法运算，因为它们是作为整数常量输入的。|2676954|entityMap^0|7|6|0|0|9|1|B|1|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|N|$]]

Explicitly cast it as a <code>double</code>

<pre><code>double g = 1.0/3.0
</code></pre>

This happens because Java uses the integer division operation for <code>1</code> and <code>3</code> since you entered them as integer constants.

blocks|key|4279715|text|因为你在做整数除法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4279716|正如@Noldorin所说，如果两个运算符都是整数，则使用整数除法。|4279717|结果0.33333333不能表示为整数，因此只将整数部分(0)赋值给结果。|4279718|如果任何运算符是double+/+float，则将进行浮点运算。但是如果你这样做了，你也会遇到同样的问题：|offset|length|style|CODE|4279719|int+n+=+1.0+/+3.0;|code-block|syntax|javascript|4279720|entityMap^0|0|0|0|8|6|H|5|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|U|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|V|8|@$H|W|I|X|J|K]|$H|Y|I|Z|J|K]]|9|@]|A|$]]|$1|L|3|M|5|N|7|10|8|@]|9|@]|A|$O|P]]|$1|Q|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|R|$]]

Because you are doing integer division.

As @Noldorin says, if both operators are integers, then integer division is used.

The result 0.33333333 can't be represented as an integer, therefore only the integer part (0) is assigned to the result.

If any of the operators is a <code>double</code> / <code>float</code>, then floating point arithmetic will take place. But you'll have the same problem if you do that:

<pre><code>int n = 1.0 / 3.0;
</code></pre>

blocks|key|4279850|text|你应该使用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4279851|double+g=1.0/3;|code-block|syntax|javascript|4279852|或|4279853|double+g=1/3.0;|4279854|整数除法返回integer。|4279855|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

you should use

<pre><code>double g=1.0/3;
</code></pre>

or

<pre><code>double g=1/3.0;
</code></pre>

Integer division returns integer.

blocks|key|2677490|text|最简单的解决方案就是这样做。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2677491|double+g+=+(double)+1+/+3;|code-block|syntax|javascript|2677492|由于您没有输入1.0+/+3.0，这样做的目的是让您手动将其转换为数据类型double，因为Java假定它是Integer除法，即使这意味着缩小转换范围，它也会这样做。这就是所谓的强制转换运算符。这里我们只强制转换一个操作数，这足以避免整数除法(向零舍入)|2677493|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

The easiest solution is to just do this
<pre><code>double g = (double) 1 / 3;
</code></pre>
What this does, since you didn't enter 1.0 / 3.0, is let you manually convert it to data type double since Java assumed it was Integer division, and it would do it even if it meant narrowing the conversion. This is what is called a cast operator.
Here we cast only one operand, and this is enough to avoid integer division (rounding towards zero)

blocks|key|1654906|text|1和3是整数常数，所以Java做了一个整数除法，结果是0。如果你想写双常量，你必须写1.0和3.0。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1654907|entityMap^0|16|3|1A|3|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

1 and 3 are integer contants and so Java does an integer division which's result is 0. If you want to write double constants you have to write <code>1.0</code> and <code>3.0</code>.

blocks|key|610167|text|因为它将1和3视为整数，因此将结果向下舍入为0，因此它是一个整数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|610168|为了得到您想要的结果，显式地告诉java数字是双精度，如下所示：|610169|double+g+=+1.0/3.0;|code-block|syntax|javascript|610170|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Because it treats 1 and 3 as integers, therefore rounding the result down to 0, so that it is an integer.

To get the result you are looking for, explicitly tell java that the numbers are doubles like so:

<pre><code>double g = 1.0/3.0;
</code></pre>

blocks|key|610198|text|将1设为浮点数，将使用浮点数除法|type|unstyled|depth|inlineStyleRanges|entityRanges|data|610199|public+static+void+main(String+d[]){
++++double+g=1f/3;
++++System.out.printf("%25.2f",g);
}|code-block|syntax|javascript|610200|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Make the 1 a float and float division will be used

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

blocks|key|610365|text|JAVA中的转换非常简单，但需要一些理解。正如integer+operations的JLS中所解释的那样。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|610366|610367|如果非移位运算符的整数运算符至少有一个long类型的操作数，则使用64位精度执行运算，并且数值运算符的结果为long类型。如果另一个操作数不长，则首先通过数值升级将其扩展(§5.1.5)为long类型(§5.6)。|blockquote|610368|610369|610370|示例始终是翻译JLS的最佳方式;)|610371|int+%2B+long+->+long
int(1)+%2B+long(2)+%2B+int(3)+->+long(1%2B2)+%2B+long(3)|code-block|syntax|javascript|610372|否则，将使用32位精度执行运算，并且数值运算符的结果为|610373|类型。如果任一操作数不是int类型，则首先通过数值提升将其扩展为int类型。|610374|610375|610376|short+%2B+int+->+int+%2B+int+->+int|610377|使用Eclipse的一个小示例表明，即使是添加两个short也不会那么容易：|style|CODE|610378|short+s+=+1;
s+=+s+%2B+s;+<-+Compiling+error

//possible+loss+of+precision
//++required:+short
//++found:++++int|610379|这将需要一个可能会损失精度的铸造。|610380|floating+point+operators也是如此|610381|610382|如果数值运算符的至少一个操作数属于double类型，则使用64位浮点算术执行运算，并且数值运算符的结果是double类型的值。如果另一个操作数不是double，则首先通过数值提升(§5.6)将其扩展为double类型(§5.1.5)。|610383|610384|610385|所以提升是在浮点数上进行的，变成了双精度。|610386|整数和浮点值的混合产生浮点值，如上所述|610387|610388|如果二元运算符的操作数中至少有一个是浮点类型的，则该操作是浮点操作，即使另一个是整数也是如此。|610389|610390|610391|这适用于二元运算符，但不适用于像%2B=这样的“赋值运算符”|610392|一个简单的工作示例就足以证明这一点。|610393|int+i+=+1;
i+%2B=+1.5f;|610394|原因是这里有一个隐式类型转换，这将像这样执行|610395|i+=+(int)+i+%2B+1.5f
i+=+(int)+2.5f
i+=+2|610396|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/javase/specs/jls/se7/html/jls-4.html#jls-4.2.2|1|https://docs.oracle.com/javase/specs/jls/se7/html/jls-4.html#jls-4.2.4^0|N|I|0|0|0|0|0|0|0|0|0|0|0|0|0|P|5|0|0|0|0|O|1|0|0|0|0|0|0|0|0|0|0|0|G|2|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|26|8|@]|9|@$A|27|B|28|1|29]]|C|$]]|$1|D|3|-4|5|6|7|2A|8|@]|9|@]|C|$]]|$1|E|3|F|5|G|7|2B|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|2C|8|@]|9|@]|C|$]]|$1|I|3|-4|5|6|7|2D|8|@]|9|@]|C|$]]|$1|J|3|K|5|6|7|2E|8|@]|9|@]|C|$]]|$1|L|3|M|5|N|7|2F|8|@]|9|@]|C|$O|P]]|$1|Q|3|R|5|6|7|2G|8|@]|9|@]|C|$]]|$1|S|3|T|5|G|7|2H|8|@]|9|@]|C|$]]|$1|U|3|-4|5|6|7|2I|8|@]|9|@]|C|$]]|$1|V|3|-4|5|6|7|2J|8|@]|9|@]|C|$]]|$1|W|3|X|5|N|7|2K|8|@]|9|@]|C|$O|P]]|$1|Y|3|Z|5|6|7|2L|8|@$A|2M|B|2N|10|11]]|9|@]|C|$]]|$1|12|3|13|5|N|7|2O|8|@]|9|@]|C|$O|P]]|$1|14|3|15|5|6|7|2P|8|@]|9|@]|C|$]]|$1|16|3|17|5|6|7|2Q|8|@]|9|@$A|2R|B|2S|1|2T]]|C|$]]|$1|18|3|-4|5|6|7|2U|8|@]|9|@]|C|$]]|$1|19|3|1A|5|G|7|2V|8|@]|9|@]|C|$]]|$1|1B|3|-4|5|6|7|2W|8|@]|9|@]|C|$]]|$1|1C|3|-4|5|6|7|2X|8|@]|9|@]|C|$]]|$1|1D|3|1E|5|6|7|2Y|8|@]|9|@]|C|$]]|$1|1F|3|1G|5|6|7|2Z|8|@]|9|@]|C|$]]|$1|1H|3|-4|5|6|7|30|8|@]|9|@]|C|$]]|$1|1I|3|1J|5|G|7|31|8|@]|9|@]|C|$]]|$1|1K|3|-4|5|6|7|32|8|@]|9|@]|C|$]]|$1|1L|3|-4|5|6|7|33|8|@]|9|@]|C|$]]|$1|1M|3|1N|5|6|7|34|8|@$A|35|B|36|10|11]]|9|@]|C|$]]|$1|1O|3|1P|5|6|7|37|8|@]|9|@]|C|$]]|$1|1Q|3|1R|5|N|7|38|8|@]|9|@]|C|$O|P]]|$1|1S|3|1T|5|6|7|39|8|@]|9|@]|C|$]]|$1|1U|3|1V|5|N|7|3A|8|@]|9|@]|C|$O|P]]|$1|1W|3|-4|5|6|7|3B|8|@]|9|@]|C|$]]]|1X|$1Y|$5|1Z|20|21|C|$22|23]]|24|$5|1Z|20|21|C|$22|25]]]]

The conversion in JAVA is quite simple but need some understanding. As explain in the JLS for <a href="https://docs.oracle.com/javase/specs/jls/se7/html/jls-4.html#jls-4.2.2" rel="nofollow noreferrer">integer operations</a>:

<blockquote>
 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). 
</blockquote>

And an example is always the best way to translate the JLS ;) 

<pre><code>int + long -&gt; long
int(1) + long(2) + int(3) -&gt; long(1+2) + long(3)
</code></pre>

<blockquote>
 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. 
</blockquote>

<pre><code>short + int -&gt; int + int -&gt; int
</code></pre>

A small example using Eclipse to show that even an addition of two <code>short</code>s will not be that easy :

<pre><code>short s = 1;
s = s + s; &lt;- Compiling error

//possible loss of precision
// required: short
// found: int
</code></pre>

This will required a casting with a possible loss of precision.

The same is true for the <a href="https://docs.oracle.com/javase/specs/jls/se7/html/jls-4.html#jls-4.2.4" rel="nofollow noreferrer">floating point operators</a>

<blockquote>
 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). 
</blockquote>

So the promotion is done on the float into double.

And the mix of both integer and floating value result in floating values as said 

<blockquote>
 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. 
</blockquote>

This is true for binary operators but not for "Assignment Operators" like <code>+=</code>

A simple working example is enough to prove this

<pre><code>int i = 1;
i += 1.5f;
</code></pre>

The reason is that there is an implicit cast done here, this will be execute like 

<pre><code>i = (int) i + 1.5f
i = (int) 2.5f
i = 2
</code></pre>

blocks|key|610528|text|这是我干的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|610529|double+g+=+1.0/3.0;
System.out.printf("%25gf",+g);|code-block|syntax|javascript|610530|在进行双重计算时使用.0，否则Java将假定您使用的是整数。如果计算使用任意数量的双精度值，则输出将是双精度值。如果都是整数，则输出将是整数。|610531|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I did this.
<pre><code>double g = 1.0/3.0;
System.out.printf(&quot;%gf&quot;, g);
</code></pre>
Use .0 while doing double calculations or else Java will assume you are using Integers. If a Calculation uses any amount of double values, then the output will be a double value. If the are all Integers, then the output will be an Integer.

blocks|key|4280164|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4280165|结果为0。为什么会这样，我该如何解决这个问题？|blockquote|4280166|4280167|4280168|TL;DR|offset|length|style|BOLD|4280169|您可以通过执行以下操作来解决此问题：|4280170|double+g+=+1.0/3.0;+|code-block|syntax|javascript|4280171|或|4280172|double+g+=+1.0/3;+|4280173|4280174|double+g+=+1/3.0;+|4280175|4280176|double+g+=+(double)+1+/+3;|4280177|当您使用变量时，最后一个选项是必需的，例如int+a+=+1,+b+=+3;+double+g+=+(double)+a+/+b;。|CODE|4280178|A更完整的答案|4280179|4280180|加倍g=1/+3；|4280181|4280182|4280183|这会导致0，因为|4280184|首先，被除数的<+divisor;|4280185|both变量是int类型的，因此导致int+(5.6.2.+JLS)，它自然不能表示浮点值，如0.333333...|unordered-list-item|4280186|
|4280187|"Integer除法舍入为0。“15.17.2+JLS|4280188|4280189|为什么使用double+g+=+1.0/3.0;和double+g+=+((double)+1)+/+3;？|4280190|从Chapter+5.+Conversions+and+Promotions可以读到：|4280191|4280192|+One+conversion+context是数字运算符的操作数，例如%2B或*。这类操作数的转换过程称为数值提升。提升的特殊之处在于，在二元运算符的情况下，为一个操作数选择的转换可能部分取决于另一个操作数表达式的类型。|4280193|4280194|4280195|和5.6.2.+Binary+Numeric+Promotion|4280196|4280197|当运算符对一对操作数应用二进制数值提升时，每个操作数必须表示一个可转换为数值类型的值，请按顺序应用以下规则：|4280198|4280199|如果任何操作数属于引用类型，则对其进行拆箱转换(§5.1.8)。|4280200|应用扩展基元转换(§5.1.2)来转换以下规则指定的任一或两个操作数：|4280201|如果其中一个操作数的类型为double，则另一个操作数将转换为double。|4280202|否则，如果其中一个操作数的类型为float，则另一个操作数将转换为float。|4280203|否则，如果其中一个操作数的类型为long，则另一个操作数将转换为long类型。|4280204|否则，这两个操作数都将转换为int.类型|4280205|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/javase/specs/jls/se7/html/jls-5.html|1|https://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.17.2|2^0|0|0|0|0|0|5|0|0|0|0|0|0|0|0|0|L|18|0|0|7|0|0|0|0|0|4|1|0|0|7|3|I|3|1B|A|N|A|0|0|0|G|B|1|0|0|5|J|P|S|0|1|11|2|0|0|0|0|0|1|V|0|0|0|0|0|0|0|12|0|0|0|0^^$0|@$1|2|3|-4|4|5|6|2Q|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|2R|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|2S|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|2T|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|2U|7|@$H|2V|I|2W|J|K]]|8|@]|9|$]]|$1|L|3|M|4|5|6|2X|7|@]|8|@]|9|$]]|$1|N|3|O|4|P|6|2Y|7|@]|8|@]|9|$Q|R]]|$1|S|3|T|4|5|6|2Z|7|@]|8|@]|9|$]]|$1|U|3|V|4|P|6|30|7|@]|8|@]|9|$Q|R]]|$1|W|3|T|4|5|6|31|7|@]|8|@]|9|$]]|$1|X|3|Y|4|P|6|32|7|@]|8|@]|9|$Q|R]]|$1|Z|3|T|4|5|6|33|7|@]|8|@]|9|$]]|$1|10|3|11|4|P|6|34|7|@]|8|@]|9|$Q|R]]|$1|12|3|13|4|5|6|35|7|@$H|36|I|37|J|14]]|8|@]|9|$]]|$1|15|3|16|4|5|6|38|7|@$H|39|I|3A|J|K]]|8|@]|9|$]]|$1|17|3|-4|4|5|6|3B|7|@]|8|@]|9|$]]|$1|18|3|19|4|C|6|3C|7|@]|8|@]|9|$]]|$1|1A|3|-4|4|5|6|3D|7|@]|8|@]|9|$]]|$1|1B|3|-4|4|5|6|3E|7|@]|8|@]|9|$]]|$1|1C|3|1D|4|5|6|3F|7|@$H|3G|I|3H|J|14]]|8|@]|9|$]]|$1|1E|3|1F|4|5|6|3I|7|@]|8|@]|9|$]]|$1|1G|3|1H|4|1I|6|3J|7|@$H|3K|I|3L|J|14]|$H|3M|I|3N|J|14]|$H|3O|I|3P|J|14]]|8|@$H|3Q|I|3R|1|3S]]|9|$]]|$1|1J|3|1K|4|5|6|3T|7|@]|8|@]|9|$]]|$1|1L|3|1M|4|1I|6|3U|7|@]|8|@$H|3V|I|3W|1|3X]]|9|$]]|$1|1N|3|-4|4|5|6|3Y|7|@]|8|@]|9|$]]|$1|1O|3|1P|4|5|6|3Z|7|@$H|40|I|41|J|14]|$H|42|I|43|J|14]]|8|@]|9|$]]|$1|1Q|3|1R|4|5|6|44|7|@]|8|@$H|45|I|46|1|47]]|9|$]]|$1|1S|3|-4|4|5|6|48|7|@]|8|@]|9|$]]|$1|1T|3|1U|4|C|6|49|7|@]|8|@]|9|$]]|$1|1V|3|-4|4|5|6|4A|7|@]|8|@]|9|$]]|$1|1W|3|-4|4|5|6|4B|7|@]|8|@]|9|$]]|$1|1X|3|1Y|4|5|6|4C|7|@$H|4D|I|4E|J|14]]|8|@]|9|$]]|$1|1Z|3|-4|4|5|6|4F|7|@]|8|@]|9|$]]|$1|20|3|21|4|C|6|4G|7|@]|8|@]|9|$]]|$1|22|3|-4|4|5|6|4H|7|@]|8|@]|9|$]]|$1|23|3|24|4|5|6|4I|7|@]|8|@]|9|$]]|$1|25|3|26|4|5|6|4J|7|@]|8|@]|9|$]]|$1|27|3|28|4|5|6|4K|7|@$H|4L|I|4M|J|K]]|8|@]|9|$]]|$1|29|3|2A|4|5|6|4N|7|@]|8|@]|9|$]]|$1|2B|3|2C|4|5|6|4O|7|@]|8|@]|9|$]]|$1|2D|3|2E|4|5|6|4P|7|@]|8|@]|9|$]]|$1|2F|3|-4|4|5|6|4Q|7|@]|8|@]|9|$]]]|2G|$2H|$4|2I|2J|2K|9|$2L|2M]]|2N|$4|2I|2J|2K|9|$2L|2O]]|2P|$4|2I|2J|2K|9|$2L|2M]]]]

<blockquote>
The result is 0. Why is this, and how do I solve this problem?
</blockquote>
TL;DR
You can solve it by doing:
<pre><code>double g = 1.0/3.0; 
</code></pre>
or
<pre><code>double g = 1.0/3; 
</code></pre>
or
<pre><code>double g = 1/3.0; 
</code></pre>
or
<pre><code>double g = (double) 1 / 3;
</code></pre>
The last of these options is required when you are using variables e.g. <code>int a = 1, b = 3; double g = (double) a / b;</code>.
A more completed answer
<blockquote>
double g = 1 / 3;
</blockquote>
This result in <code>0</code> because
<ul>
<li>first the dividend &lt; divisor;</li>
<li>both variables are of type <code>int</code> therefore resulting in <code>int</code> (<a href="https://docs.oracle.com/javase/specs/jls/se7/html/jls-5.html" rel="nofollow noreferrer">5.6.2. JLS</a>) which naturally cannot represent the a floating point value such as <code>0.333333..</code>.</li>
<li>&quot;Integer division rounds toward 0.&quot; <a href="https://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.17.2" rel="nofollow noreferrer">15.17.2 JLS</a></li>
</ul>
Why <code>double g = 1.0/3.0;</code> and <code>double g = ((double) 1) / 3;</code> work?
From <a href="https://docs.oracle.com/javase/specs/jls/se7/html/jls-5.html" rel="nofollow noreferrer">Chapter 5. Conversions and Promotions</a> one can read:
<blockquote>
One conversion context is the operand of a numeric operator such as +
or *. The conversion process for such operands is called numeric
promotion. Promotion is special in that, in the case of binary
operators, the conversion chosen for one operand may depend in part on
the type of the other operand expression.
</blockquote>
and <code>5.6.2. Binary Numeric Promotion</code>
<blockquote>
When an operator applies binary numeric promotion to a pair of
operands, each of which must denote a value that is convertible to a
numeric type, the following rules apply, in order:
If any operand is of a reference type, it is subjected to unboxing
conversion (§5.1.8).
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.
</blockquote>

blocks|key|4279989|text|(1/3)表示整数除法，这就是为什么你不能从这个除法中得到小数值的原因。要解决此问题，请使用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4279990|public+static+void+main(String[]+args)+{
++++++++double+g+=+1.0+/+3;
++++++++System.out.printf("%25.2f",+g);
++++}|code-block|syntax|javascript|4279991|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

(1/3) means Integer division, thats why you can not get decimal value from this division. To solve this problem use:

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

blocks|key|610465|text|public+static+void+main(String[]+args)+{
++++double+g+=+1+/+3;
++++System.out.printf("%25.2f",+g);
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|610466|因为1和3都是整数，所以结果不是四舍五入，而是被截断了。所以你忽略分数，只取整数。|unstyled|610467|要避免这种情况，请将数字1或3中的至少一个作为小数形式1.0和/或3.0。|610468|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

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

Since both 1 and 3 are ints the result not rounded but it's truncated. So you ignore fractions and take only wholes.

To avoid this have at least one of your numbers 1 or 3 as a decimal form 1.0 and/or 3.0.

blocks|key|1655135|text|试试这个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1655136|public+static+void+main(String[]+args)+{
++++double+a+=+1.0;
++++double+b+=+3.0;
++++double+g+=+a+/+b;
++++System.out.printf(""%2B+g);
}|code-block|syntax|javascript|1655137|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Try this out:

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

blocks|key|4279673|text|改为"double+g=1.0/3.0;“。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4279674|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

blocks|key|610291|text|其他许多人没有指出真正的问题：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|610292|仅对整数执行|610293|操作会将操作结果强制转换为整数。|blockquote|610294|610295|610296|这必然意味着可以显示为整数的浮点结果将被截断(去掉小数部分)。|610297|你问什么是类型转换(类型转换/类型转换)？|610298|它在语言的实现上有所不同，但维基百科有一个相当全面的观点，它也谈到了强迫，这是回答你的问题的关键信息。|610299|http://en.wikipedia.org/wiki/Type_conversion|offset|length|610300|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|0|0|0|0|0|0|18|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|10|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|11|8|@]|9|@]|A|$]]|$1|G|3|-4|5|6|7|12|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|13|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|14|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|15|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|16|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|17|8|@]|9|@$Q|18|R|19|1|1A]]|A|$]]|$1|S|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|P]]]]

Many others have failed to point out the real issue:

<blockquote>
 An operation on only integers casts the result of the operation to an integer.
</blockquote>

This necessarily means that floating point results, that could be displayed as an integer, will be truncated (lop off the decimal part).

What is casting (typecasting / type conversion) you ask?

It varies on the implementation of the language, but Wikipedia has a fairly comprehensive view, and it does talk about coercion as well, which is a pivotal piece of information in answering your question.

<a href="http://en.wikipedia.org/wiki/Type_conversion" rel="nofollow">http://en.wikipedia.org/wiki/Type_conversion</a>

I was writing this code:

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

The result is 0. Why is this, and how do I solve this problem?

Int division: Why is the result of 1/3 == 0?

33 天实现自己的 AI 进化论？发文瓜分机械键盘、耳机等万元奖池！点击参加活动：<a href="https://cloud.tencent.com/developer/article/2503022" target="_blank">https://cloud.tencent.com/developer/article/2503022</a> 
 <img src="https://qcloudimg.tencent-cloud.cn/raw/01543e0407db10898a7ee9f420794432.jpg"/>

技术创作特训营有奖征文

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云AI代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

文章&问答评论现已支持表情

我写了这段代码：public static void main(String[] args) {    double g = 1 / 3;    System.out.printf("%.2f", g);}结果是0。为什么会这样，我该如何解决这个问题？

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

回答 17

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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

回答 17

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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