1. class Test
   
2. {
   
3.     public static void main(String[] args)
   
4.     {
   
5.         double value = 4.015;
   
6.         value = Math.round( value * 100 )/100.0;        
   
7.               System.out.println(value);
   
8.     }        
   
9. }

复制代码

运行的结果是 4.01， 我不明白  既然 round 方法是四舍五入，为什么   value*100 放进去会是401.0  呢？

留给大家回答，我看着呢

1. public class MathTest {
   
2. public static void main(String[] args) {
   
3. System.out.println("小数点后第一位=5");
   
4. System.out.println("正数：Math.round(11.5)=" + Math.round(11.5));
   
5. System.out.println("负数：Math.round(-11.5)=" + Math.round(-11.5));
   
6. System.out.println();
   
7. System.out.println("小数点后第一位<5");
   
8. System.out.println("正数：Math.round(11.46)=" + Math.round(11.46));
   
9. System.out.println("负数：Math.round(-11.46)=" + Math.round(-11.46));
   
10. System.out.println();
    
11. System.out.println("小数点后第一位>5");
    
12. System.out.println("正数：Math.round(11.68)=" + Math.round(11.68));
    
13. System.out.println("负数：Math.round(-11.68)=" + Math.round(-11.68));
    
14. }
    
15. }
    

复制代码

运行结果：
1、小数点后第一位=5
2、正数：Math.round(11.5)=12
3、负数：Math.round(-11.5)=-11
4、
5、小数点后第一位<5
6、正数：Math.round(11.46)=11
7、负数：Math.round(-11.46)=-11
8、
9、小数点后第一位>5
10、正数：Math.round(11.68)=12
11、负数：Math.round(-11.68)=-12

根据上面例子的运行结果，我们还可以按照如下方式总结，或许更加容易记忆：
1、参数的小数点后第一位<5，运算结果为参数整数部分。
2、参数的小数点后第一位>5，运算结果为参数整数部分绝对值+1，符号（即正负）不变。
3、参数的小数点后第一位=5，正数运算结果为整数部分+1，负数运算结果为整数部分。
总结：大于五全部加，等于五正数加，小于五全不加。

public static int round(float a)返回最接近参数的 int。通过加上 1/2 将该结果舍入为整数，取结果的基数并将其强制转换为 int 类型。换句话说，结果等于以下表达式的值：
(int)Math.floor(a + 0.5f)
public static long round(double a)返回最接近参数的 long。通过加上 1/2 将该结果舍入为整数，取结果的基数并将其强制转换为 long 类型。换句话说，结果等于以下表达式的值：
(long)Math.floor(a + 0.5d)

你可以试着将value*100打印出来。   这个结果是401.49999999999994      

这个作四舍五入运算结果是401

再/100  得到4.01  正好返回给value 是duble 类型的。

因为你求的是value*100四舍五入的值....
value*100四舍五入的值为401...
不是value四舍五入的值

这里面有个很有意思的事情
就是 value*100 的值是401.49...94
精度丢失
所以结果不是你想象中的那个啥....

这个和那个 底层的 二进制 的浮点型 标准有关

坐等大神详解

一个十进制小数，哪怕是很简单的小数，如0.1,当你用二进制来表示时，它却是个无限环小数。十进制（0.1）=二进制(0.0001100110011....）
计算机是用二进制表示数的，存储的位长有限，只能截掉，所以误差就产生了。
所以你那个value*100就丢失了精度，很有意思吧。所以输出结果就是4.01了~~~

1. 
   
2. public class MathDemo
   
3. {
   
4. 
   
5.         public static void println(Object obj)
   
6.         {
   
7.                 System.out.println(obj);
   
8.         }
   
9. 
   
10.         public static void main(String []agrs)
    
11.         {
    
12.                 /*println(Math.ceil(16.3));//17.0
    
13.                 println(Math.ceil(-16.3));//-16.0
    
14.                 println(Math.floor(16.3));//16.0
    
15.                 println(Math.floor(-16.3));//-17.0*/
    
16.                 //floor地板  向下去整
    
17.                 //ceil天花板        向上取整
    
18.                 println("====================");
    
19.                 println(Math.round(16.3));//16
    
20.                 println(Math.round(-16.3));//-16
    
21.                 println(Math.round(-16.5));//-16
    
22.                 println(Math.round(16.5));//17
    
23. 
    
24.                 // (long)Math.floor(a + 0.5d)
    
25.                 println("====================");
    
26.                 double value = 4.015;
    
27.                 println(value * 100);//401.49999999999994
    
28.                 println(Math.round(value*100));//401
    
29.                 value = Math.round(value*100)/100.0;
    
30.                 println(value);//4.01
    
31.         }
    
32. }

复制代码

稍后云版块会推出学习过程中问题以及对知识点的领悟收集！会有技术分奖励，敬请期待、多多参与，要注意按照进度收集问题，那样你会事半功倍。

学习了.............

我知道怎么回事了，我这样解释不知道对不对：
1.首先程序执行到 double value = 4.015; 打印出来也是4.015
2.执行到这段  value = Math.round( value * 100 )/100.0;  首先程序执行括号内的(value * 100)，由于低精度往高精度走 （100是 int，value是double）返回结果是double，输出结果是401.49999999999994，如果你指定了float，那么输出的结果就是401.5
3.既然结果是double  401.49999999999994 ，那么你把它放到Math.round（）函数，它当然四舍五入成401咯。
我的代码：

1. package com.itcast.itheima;
   
2. 
   
3. public class RoundTest{
   
4.        
   
5.     public static void main(String[] args){
   
6.                 double value = 4.015;
   
7.                 System.out.println(value);
   
8.                 System.out.println(value*100);
   
9.                 System.out.println( Math.round(value * 100));
   
10.                 value = Math.round( value * 100 )/100.0;        
    
11.                 System.out.println(value);
    
12.     }
    
13. }

复制代码