• Android中MathMath.floor()、Math.round()及Math.ceil()等方法的使用
2021-05-26 13:36:58

1、Math.floor()

先看定义：

/**

* Returns the double conversion of the most positive (closest to positive

* infinity) integer value less than or equal to the argument.

*

* Special cases:

*

*

{@code floor(+0.0) = +0.0}

*

{@code floor(-0.0) = -0.0}

*

{@code floor(+infinity) = +infinity}

*

{@code floor(-infinity) = -infinity}

*

{@code floor(NaN) = NaN}

*

*/

public static native double floor(double d);

由定义可知：Math.floor()表示向下取整。,即小于或等于double型参数的整数位的数字。

比如：Math.floor(18.7)的结果是18.0，Math.floor(-18.3)的结果-19.0，下面再列出几组：

Math.floor(-1.1): -2.0

Math.floor(-1.5): -2.0

Math.floor(-1.6): -2.0

Math.floor(0.1): 0.0

Math.floor(0.5): 0.0

Math.floor(0.6): 0.0

Math.floor(1.1): 1.0

Math.floor(1.5): 1.0

Math.floor(1.6): 1.0

2、Math.round()

接下来看Math.round()的定义：

/**

* Returns the result of rounding the argument to an integer. The result is

* equivalent to {@code (int) Math.floor(f+0.5)}.

*

* Special cases:

*

*

{@code round(+0.0) = +0.0}

*

{@code round(-0.0) = +0.0}

*

{@code round((anything > Integer.MAX_VALUE) = Integer.MAX_VALUE}

*

{@code round((anything < Integer.MIN_VALUE) = Integer.MIN_VALUE}

*

{@code round(+infinity) = Integer.MAX_VALUE}

*

{@code round(-infinity) = Integer.MIN_VALUE}

*

{@code round(NaN) = +0.0}

*

*

* @param f

* the value to be rounded.

* @return the closest integer to the argument.

*/

public static int round(float f) {

// check for NaN

if (f != f) {

return 0;

}

return (int) floor(f + 0.5f);

}

由定义可以很清楚的知道：Math.round()方法表示的是“四舍五入”的计算。

算法为Math.floor(f+0.5)，即将原来的数字加上0.5后再向下取整

Math.round(18.5)的结果为19，Math.round(-18.5)的结果为-18。下面再列出几组：

Math.round(-1.1): -1

Math.round(-1.5): -1

Math.round(-1.6): -2

Math.round(0.1): 0

Math.round(0.5): 1

Math.round(0.6): 1

Math.round(1.1): 1

Math.round(1.5): 2

Math.round(1.6): 2

3、Math.ceil()

Math.ceil的定义为：

/**

* Returns the double conversion of the most negative (closest to negative

* infinity) integer value greater than or equal to the argument.

*

* Special cases:

*

*

{@code ceil(+0.0) = +0.0}

*

{@code ceil(-0.0) = -0.0}

*

{@code ceil((anything in range (-1,0)) = -0.0}

*

{@code ceil(+infinity) = +infinity}

*

{@code ceil(-infinity) = -infinity}

*

{@code ceil(NaN) = NaN}

*

*/

public static native double ceil(double d);

由定义也可知：Math.ceil()方法就表示向上取整。即大于或等于double型参数的整数位的数字。

比如：Math.ceil(18.3)的结果是19.0，Math.ceil(-18.7)的结果-18.0。再看看一组：

Math.ceil(-1.1): -1.0

Math.ceil(-1.5): -1.0

Math.ceil(-1.6): -1.0

Math.ceil(0.1): 1.0

Math.ceil(0.5): 1.0

Math.ceil(0.6): 1.0

Math.ceil(1.1): 2.0

Math.ceil(1.5): 2.0

Math.ceil(1.6): 2.0

4、Math.rint()

Math.rint()的定义：

/**

* Returns the double conversion of the result of rounding the argument to

* an integer. Tie breaks are rounded towards even.

*

* Special cases:

*

*

{@code rint(+0.0) = +0.0}

*

{@code rint(-0.0) = -0.0}

*

{@code rint(+infinity) = +infinity}

*

{@code rint(-infinity) = -infinity}

*

{@code rint(NaN) = NaN}

*

*

*@param d

* the value to be rounded.

*@return the closest integer to the argument (as a double).

*/

public static native double rint(double d);

Math.ring()返回double值最接近参数的值，并等于某个整数。如果两个double值跟整数都同样接近，结果是整数值是偶数。特殊情况:

如果参数值已经等于某个整数，那么结果跟参数一样。

如果参数为NaN或无穷大，正零或负零，那么结果和参数一样。

比如例子：

Math.rint(-1.1): -1.0

Math.rint(-1.5): -2.0

Math.rint(-1.6): -2.0

Math.rint(0.1): 0.0

Math.rint(0.5): 0.0

Math.rint(0.6): 1.0

Math.rint(1.1): 1.0

Math.rint(1.5): 2.0

Math.rint(1.6): 2.0

更多相关内容
• Math.floor() method rounds a number DOWNWARDS to the nearest integer, and returns the result. (小于等于 x，且与 x 最接近的整数。)其实返回值就是该数的整数位：Math.floor(0.666) –> 0Math.floor(39.2783...
• 主要介绍了Java Math.round()，Math.ceil()，Math.floor()的区别详解，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
• Math.floor( x ) ; 下面是参数的详细信息： x : 一个数字 返回值: 返回比最大的整数小于或等于一个数x 例子： <html> <head> <title>JavaScript Math floor() Method</title> </head&...
• 首先还是看看[removed] The Definitive Guide, 4th Edition中对三个函数的定义。 Math.ceil(): round a number up ...Math.floor(): round a number down Arguments: Any numeric value or expressi
• Math是一个对象，不是一个构造函数，所以不能new Math 一、返回0到1之间的随机数值，但不包含1，包含零。顾头不顾尾。一般零出现的概率极小，可以忽略不计。 <div class="bg" @click="cssChange"> </div&...

、、、、、、、、、、、仅对以前所学做复习记录使用、、、、、、、、、

Math是一个对象，不是一个构造函数，所以不能new Math

#### 一、返回0到1之间的随机数值，但不包含1，包含零。顾头不顾尾。一般零出现的概率极小，可以忽略不计。

<div class="bg" @click="cssChange"> </div>

cssChange(){
console.log(Math.random());
}

#### 二、Math.floor()是向下取整数（向越小的值方向取值），即将小数点后面的数字全部省去；如果是个整数就取它本身的值：

// 向越小的值方向取值
Math.floor(1.222)       // 1
Math.floor(1.9999999)  // 1
Math.floor(1)          // 1
Math.floor(-1)        // -1
Math.floor(-1.222)    // -2

## Math.round(Math.random()*(y-x)+x);

例如获取0-10

<div class="bg" @click="cssChange"> </div>

cssChange(){
console.log(Math.round(Math.random()*(10-0)+0));

}

### 四、用Math.floor()取x到y的值，包含xy，公式：

#### Math.floor(y+1-Math.random()*(y+1-x))

例如：取5-7

methods:{
cssChange(){
console.log(Math.floor(8-Math.random()*(8-5)));
}
}

展开全文
• Math.round() 就是数学中的四舍五入，举例： System.out.println("Math.round(1.2)="+Math.round(1.2)); System.out.println("Math.round(1.5)="+Math.round(1.5)); System.out.println("Math.round(1.7)="+Math....

Math.round()
就是数学中的四舍五入，举例：

System.out.println("Math.round(1.2)="+Math.round(1.2));
System.out.println("Math.round(1.5)="+Math.round(1.5));
System.out.println("Math.round(1.7)="+Math.round(1.7));
System.out.println("Math.round(-1.2)="+Math.round(-1.2));
System.out.println("Math.round(-1.5)="+Math.round(-1.5));
System.out.println("Math.round(-1.7)="+Math.round(-1.7));

结果输出为：

Math.round(1.2)=1
Math.round(1.5)=2
Math.round(1.7)=2
Math.round(-1.2)=-1
Math.round(-1.5)=-1
Math.round(-1.7)=-2

Math.ceil()
ceil英文是天花板的意思，就是对上取整，举例：

System.out.println("Math.ceil(1.2)="+Math.ceil(1.2));
System.out.println("Math.ceil(1.5)="+Math.ceil(1.5));
System.out.println("Math.ceil(1.7)="+Math.ceil(1.7));
System.out.println("Math.ceil(-1.2)="+Math.ceil(-1.2));
System.out.println("Math.ceil(-1.5)="+Math.ceil(-1.5));
System.out.println("Math.ceil(-1.7)="+Math.ceil(-1.7));

结果输出为：

Math.ceil(1.2)=2.0
Math.ceil(1.5)=2.0
Math.ceil(1.7)=2.0
Math.ceil(-1.2)=-1.0
Math.ceil(-1.5)=-1.0
Math.ceil(-1.7)=-1.0

Math.floor()
floor就是地板的意思，就是对下取整，举例：

System.out.println("Math.floor(1.2)="+Math.floor(1.2));
System.out.println("Math.floor(1.5)="+Math.floor(1.5));
System.out.println("Math.floor(1.7)="+Math.floor(1.7));
System.out.println("Math.floor(-1.2)="+Math.floor(-1.2));
System.out.println("Math.floor(-1.5)="+Math.floor(-1.5));
System.out.println("Math.floor(-1.7)="+Math.floor(-1.7));

结果输出为：

Math.floor(1.2)=1.0
Math.floor(1.5)=1.0
Math.floor(1.7)=1.0
Math.floor(-1.2)=-2.0
Math.floor(-1.5)=-2.0
Math.floor(-1.7)=-2.0

Math.abs()
在数学中是指取绝对值，举例：

System.out.println("Math.abs(1.2)="+Math.abs(1.2));
System.out.println("Math.abs(1.5)="+Math.abs(1.5));
System.out.println("Math.abs(1.7)="+Math.abs(1.7));
System.out.println("Math.abs(-1.2)="+Math.abs(-1.2));
System.out.println("Math.abs(-1.5)="+Math.abs(-1.5));
System.out.println("Math.abs(-1.7)="+Math.abs(-1.7));

结果输出为：

Math.abs(1.2)=1.2
Math.abs(1.5)=1.5
Math.abs(1.7)=1.7
Math.abs(-1.2)=1.2
Math.abs(-1.5)=1.5
Math.abs(-1.7)=1.7

展开全文
• .NET中的Math.Floor()和Math.Truncate()什么区别？

.NET中的Math.Floor()Math.Truncate()什么区别？

### #1楼

Math.Floor()符合IEEE标准754第4节“向负无穷大” Math.Floor()

Math.Truncate()Math.Truncate()入到最接近零的整数”。

### #2楼

Math.Floor() ：返回小于或等于指定的双精度浮点数的最大整数。

Math.Round() ：将值舍入为最接近的整数或指定的小数位数。

### #3楼

一些例子：

Round(1.5) = 2
Round(2.5) = 2
Round(1.5, MidpointRounding.AwayFromZero) = 2
Round(2.5, MidpointRounding.AwayFromZero) = 3
Round(1.55, 1) = 1.6
Round(1.65, 1) = 1.6
Round(1.55, 1, MidpointRounding.AwayFromZero) = 1.6
Round(1.65, 1, MidpointRounding.AwayFromZero) = 1.7

Truncate(2.10) = 2
Truncate(2.00) = 2
Truncate(1.90) = 1
Truncate(1.80) = 1

### #4楼

它们在功能上等同于正数。 不同之处在于它们如何处理负数。

例如：

Math.Floor(2.5) = 2
Math.Truncate(2.5) = 2

Math.Floor(-2.5) = -3
Math.Truncate(-2.5) = -2

MSDN链接： - Math.Floor方法 - Math.Truncate方法

PS小心Math.Round它可能不是你所期望的。

要获得“标准”舍入结果，请使用：

float myFloat = 4.5;
Console.WriteLine( Math.Round(myFloat) ); // writes 4
Console.WriteLine( Math.Round(myFloat, 0, MidpointRounding.AwayFromZero) ) //writes 5
Console.WriteLine( myFloat.ToString("F0") ); // writes 5

### #5楼

Math.Floor向下Math.CeilingMath.Ceiling向上Math.FloorMath.Ceiling向下Math.Ceiling Math.Truncate为零。 因此， Math.Truncate就像Math.Floor为正数，和类似Math.Ceiling为负数。 这是参考

为了完整性， Math.Round入到最接近的整数。 如果数字正好位于两个整数之间，那么它将朝向偶数。 参考。

另见： Pax Diablo的回答 。 强烈推荐！

### #6楼

math.floor()

返回小于或等于指定数字的最大整数。

math.truncate()

计算数字的整数部分。

Math.Floor(2.56) = 2
Math.Floor(3.22) = 3
Math.Floor(-2.56) = -3
Math.Floor(-3.26) = -4

Math.Truncate(2.56) = 2
Math.Truncate(2.00) = 2
Math.Truncate(1.20) = 1
Math.Truncate(-3.26) = -3
Math.Truncate(-3.96) = -3

另外Math.Round（）

Math.Round(1.6) = 2
Math.Round(-8.56) = -9
Math.Round(8.16) = 8
Math.Round(8.50) = 8
Math.Round(8.51) = 9

### #7楼

左边是Math.floor sliiiide ...
Math.ceil sliiiide向右...
Math.truncate criiiiss crooooss（地板/ ceil始终朝向0）
Math.round cha cha，真正流畅...（转到最近的一侧）

我们去上班吧！ （⌐□□_）

在左边...... Math.floor
把它收回你们现在... --
这次两次跳...... -=2

每个人都拍手✋✋

你有多低？ 你可以低调吗？ 一路到floor

if (this == "wrong")
return "i don't wanna be right";

Math.truncate(x)也与int(x)相同。
通过删除正或负分数，您总是朝0。

### #8楼

Mat.floor()将始终向下舍入，即。，它返回LESSER整数。 而round()将返回NEAREST整数

### #9楼

请按照以下链接获取MSDN描述：

• Math.Floor ，向下Math.Floor负无穷大。
• Math.Ceiling ，向正无穷大四舍五入。
• Math.Truncate ，向上或向下Math.Truncate为零。
• Math.RoundMath.Round入到最接近的整数或指定的小数位数。 您可以指定行为，如果它在两种可能性之间完全等距，例如舍入使得最后一位数是偶数（“ Round(2.5,MidpointRounding.ToEven) ”变为2）或者它更远离零（“ Round(2.5,MidpointRounding.AwayFromZero) “成为3）。

以下图表和表格可能会有所帮助：

-3        -2        -1         0         1         2         3
+--|------+---------+----|----+--|------+----|----+-------|-+
a                     b       c           d            e

a=-2.7  b=-0.5  c=0.3  d=1.5  e=2.8
======  ======  =====  =====  =====
Floor                    -3      -1      0      1      2
Ceiling                  -2       0      1      2      3
Truncate                 -2       0      0      1      2
Round (ToEven)           -3       0      0      2      3
Round (AwayFromZero)     -3      -1      0      2      3

请注意， Round比它看起来更强大，只是因为它可以舍入到特定的小数位数。 所有其他的总是小数点零。 例如：

n = 3.145;
a = System.Math.Round (n, 2, MidpointRounding.ToEven);       // 3.14
b = System.Math.Round (n, 2, MidpointRounding.AwayFromZero); // 3.15

使用其他函数，您必须使用乘法/除法技巧来实现相同的效果：

c = System.Math.Truncate (n * 100) / 100;                    // 3.14
d = System.Math.Ceiling (n * 100) / 100;                     // 3.15

### #10楼

Math.Floor()向负无穷大Math.Floor()

Math.Truncate向上或向下Math.Truncate为零。

例如：

Math.Floor(-3.4)     = -4
Math.Truncate(-3.4)  = -3

Math.Floor(3.4)     = 3
Math.Truncate(3.4)  = 3

展开全文
• Math.floor()：舍去小数，仅取整数部分 Math.ceil(12.1)=12 Math.ceil(12.8)=12 Math.ceil(12.0)=12 123 Math.ceil()：将小数部分一律向整数部分进位 简单来说，当小数部分为非0值时，进为1.0 Math.ceil(12.1...
• Math.floor() 返回小于或等于一个给定数字的最大整数。语法 Math.floor(x) 参数x 一个数字。 返回值 一个表示小于或等于指定数字的最大整数的数字。 由于 floorMath的一个静态方法，你总是应该像这样使用...
• 今天遇到一个问题:如何随机生成50-100之间的保留两位小数的数字。 所以打算总结一下 一、定义 函数 含义 形式 Math.ceil() 向上取整数，即返回大于... Math.floor() 向下取整，即返回小于等于(...
• 1、Math.ceil()ceil表示“天花板”，向上取整；相当于水平数轴，向左取整... //-2.0 ceil天花板 水平数轴向左取整2、Math.floor()floor表示“地板”，向下取整；相当于水平数轴，向右取整Math.floor(2.6); //2.0 ...
• JavaScript Math.floor 方法 Math.floor 方法用于对数值向下取整，即得到小于或等于该数值的最大整数。语法如下： Math.floor(x) 参数说明: 参数 说明 x 必需。必须是一个数值。 提示：该方法与 Math.ceil ...
• 1、Math.round() “四舍五入”，该函数返回的是一个四舍五入后的的整数 double d = 3.1415926; double d2 = 18.58; double d3 = -15.23; double d4 = -16.85; long round1 = Math.round(d); //...
• Java Math.floor() 方法java.lang.Math.floor() 返回最大的(最接近正无穷大)double值，该值小于或等于参数，并等于某个整数。1 语法public static double floor(double a)2 参数x ：参数值3 返回值返回最大的(最接近...
• 问题出现： 在项目中之前完成的一个精灵汇总属性展示的需求，今天测试突然提了个bug： 如 某A号精灵 攻击力为 ：20.50 某B号精灵 攻击力为 ：17.98 ...local num2 = math.floor(num1 * 100)/100 print("num2 = "..num2)
• Math.round(Math.random()*100000)=66666 1.Math.random()：得到0~1之间的随机数 2.Math.round()：四舍五入 例： 小数点后第一位<5 正数：Math.round(10.46)=10 负数：Math.round(-10.46)=-10 小数点后第一位>...
• 1. Math.Ceiling(),只要有小数就加1(小数部分不为0） 例如： Math.Ceiling(0.0) -> 0 Math.Ceiling(0.1) -> 1 Math.Ceiling(0.2) -> 1 Math.Ceiling(0.3) -> 1 Math.Ceiling(0.4) -> 1 Math.Ceiling...
• Math.floor()返回小于或等于一个给定数字的最大整数。 可以理解Math.floor()为向下取整。 与其相对的是Math.ceil()，这个是向上取整。 如下面的代码： Math.floor( 45.95); // 45 Math.floor( 45.05); // 45 ...
• ## math.floor用法

千次阅读 2021-05-23 14:15:58
math.floor：取数字的近似值 代码示例: import math print('-3.88的近似值',math.floor(-3.88)) print('3.88的近似值：',math.floor(3.88)) 输出： -3.88的近似值 -4 3.88的近似值： 3
• Python math.floor() 方法math.floor()方法是数学模块的库方法，用于获取给定数字的下限值，用于获取数字的下限值，它接受数字/数字表达式并返回最大整数(整数)值，不大于数字。注意：如果数字是整数值，则对于浮点...
• Math.floor()、Math.ceil()和Math.round()都是对浮点数取整（floor和ceil返回不带小数的double，round返回long） floor字面意思为地板，返回的是小于或等于该数值的最大的整数 ceil字面意思是天花板，返回的是大于...
• methods:{ changeMood(){ const arr = ['happy','sad','normal'] this.mood = arr[Math.floor(Math.random()*3)] } },
• math.floor()和math.ceil()的使用 math.floor是向下取整数： math.ceil是向上取整数：
• Math.Floor()符合IEEE标准754第4节“向负无穷大”Math.Floor()。 Math.Truncate()“Math.Truncate()入到最接近零的整数”。
• 理解math.floor(math.random() * (max - min + 1)) + min的含义 math.floor：向下取整 math.random：伪随机数在范围从0到小于1，也就是说，从0（包括0）往上，但是不包括1（排除1）。简化 0≤math.random<1 。 ...
• Math.round可以简单地理解为“四舍六入”，例如： Math.round(10.45)=10 Math.round(10.65)=11 Math.round(-10.45)=10 Math.round(-10.65)=11 但是当赋值数小数点后第一位为5时，即x.5时，正数整数位+1，负数...

...