blocks|key|1634391|text|根据相同的Javadoc：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1634392|如果参数是NaN、无穷大、正零或负零，则结果与参数相同。使用int不能做到这一点。|offset|length|style|CODE|1634393|最大的double值也大于最大的int，因此它必须是一个long。|1634394|entityMap^0|0|5|3|U|3|0|3|6|G|3|S|4|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]|$D|P|E|Q|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|R|8|@$D|S|E|T|F|G]|$D|U|E|V|F|G]|$D|W|E|X|F|G]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|K|$]]

According to the same Javadoc:

If the argument is <code>NaN</code> or an infinity or positive zero or negative zero, then the result is the same as the argument. Can't do that with an <code>int</code>.

The largest <code>double</code> value is also larger than the largest <code>int</code>, so it would have to be a <code>long</code>.

blocks|key|1634492|text|这是为了精确度。双精度数据类型具有53位尾数。在其他方面，这意味着double可以表示最多2%5E53的所有整数，而不会造成精度损失。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1634493|如果你把这么大的数字存储在一个整数中，你会得到一个溢出。整数只有32位。|1634494|在这里，将整数作为双精度值返回是正确的做法，因为它提供的用法范围比整数大得多。|1634495|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

It's for precision. The double data-type has a 53 bit mantissa. Among other things that means that a double can represent all whole up to 2^53 without precision loss. 

If you store such a large number in an integer you will get an overflow. Integers only have 32 bits. 

Returning the integer as a double is the right thing to do here because it offers a much wider usefull number-range than a integer could.

blocks|key|1634551|text|以便error和其他非整数值可以通过一系列计算正确地级联。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1634552|例如，如果您没有向Math.floor提供数字(NaN)，它就会传递它。|1634553|如果它返回integer，它就不能传递这些状态或错误，并且您可能会从早期的计算中得到看起来不错但经过进一步处理后是错误的结果。|1634554|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

So that error and other non integer values can correctly cascade through a series of calculations.

For instance, if you feed Not a Number (NaN) into Math.floor, it'll pass it along.

If it returned integer it couldn't pass these status or errors along, and you could get bad results from an earlier calculation that look good but are wrong after further processing.

blocks|key|1419805|text|如果你给它一个比最大整型或长整型更大的双精度值，你希望它返回什么？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1419806|(诚然，如果它大于最大长度，精度无论如何都会很低-它可能不是最接近的理论整数-但即便如此……)|1419807|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

What would you want it to return if you gave it a double bigger than the largest int or long?

(Admittedly if it's bigger than the largest long the precision will be low anyway - it may not be the nearest theoretical integer - but even so...)

blocks|key|1634683|text|就像Java中有整数和浮点除法一样，有整数和浮点的方法来做floor：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1634684|double+f+=+Math.floor(x);|code-block|syntax|javascript|1634685|或|1634686|int+k+=+(int)+x;+|1634687|但在使用具有有限精度算术的floor时，您总是需要小心:您对x的计算可能会得到类似1.99999999的结果，这两种形式都会得到1，而不是2。有许多算法需要绕过这一限制，以避免对某些输入值产生错误的结果。|1634688|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|$]]

Just as there is an integer and a floating point division in Java, there are integer and floating point ways to do floor:

<pre><code>double f = Math.floor(x);
</code></pre>

or 

<pre><code>int k = (int) x; 
</code></pre>

but you always need to be careful with using floor with finite precision arithmetic: your calculation of x may yield something like 1.99999999 which will be floored to 1, not 2 by both forms. There are many algorithms out there that need to work around this limitation to avoid producing wrong results for some input values.

blocks|key|1419937|text|其他人已经告诉了你为什么，我将告诉你如何在你想要这样做的情况下正确地进行舍入。如果您只打算使用正数，则可以使用以下语句：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1419938|int+a=(int)+1.5;|code-block|syntax|javascript|1419939|但是，(int)总是舍入为0。因此，如果你想做一个负数：|1419940|int+a=(int)+-1.5;+//Equal+to+-1|1419941|在我的例子中，我不想这样做。我使用以下代码进行舍入，它似乎很好地处理了所有边缘情况：|1419942|private+static+long+floor(double+a)
{
++++return+(int)+Math.floor(a);
}|1419943|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Others have told you the why, I'm going to tell you how to round correctly given you want to do this. If you are only going to use positive numbers, then you can use this statement:

<pre><code>int a=(int) 1.5;
</code></pre>

However, the (int) always rounds towards 0. Thus, if you want to do a negative number:

<pre><code>int a=(int) -1.5; //Equal to -1
</code></pre>

In my case, I didn't want to do this. I used the following code to do the rounding, and it seems to handle all of the edge cases well:

<pre><code>private static long floor(double a)
{
 return (int) Math.floor(a);
}
</code></pre>

Official Javadoc <a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Math.html#floor(double)" rel="noreferrer">says</a> that <code>Math.floor()</code> returns a <code>double</code> that is "equal to a mathematical integer", but then why shouldn't it return an <code>int</code>?

Why does Math.floor return a double?

Java

官方的Javadoc 说Math.floor()返回一个“等于一个数学整数”的double，但是为什么它不应该返回一个int呢

问为什么Math.floor会返回一个双精度值？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么Math.floor会返回一个双精度值？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么Math.floor会返回一个双精度值？
EN