精华内容
下载资源
问答
  • BigDecimal 四舍五入

    千次阅读 2018-08-01 14:18:01
    public static void round_...四舍五入(保留位后一位是5进位) = " + new BigDecimal("2.35").setScale(1, BigDecimal.ROUND_HALF_UP)); 常用 System.out.println("四舍五入(保留位后一位是5舍...
        public static void round_half_up() {
            System.out.println("四舍五入(保留位后一位是5进位) = " + new BigDecimal("2.35").setScale(1, BigDecimal.ROUND_HALF_UP)); 常用
            System.out.println("四舍五入(保留位后一位是5舍弃) = " + new BigDecimal("2.35").setScale(1, BigDecimal.ROUND_HALF_DOWN));
            System.out.println("四舍五入(保留位是奇数) = " + new BigDecimal("4.55").setScale(1, BigDecimal.ROUND_HALF_EVEN)); 向最接近数字方向舍入的舍入模式,如果与两个相邻数字的距离相等,则向相邻的偶数舍入。
            System.out.println("四舍五入(保留位是偶数) = " + new BigDecimal("4.45").setScale(1, BigDecimal.ROUND_HALF_EVEN)); 向最接近数字方向舍入的舍入模式,如果与两个相邻数字的距离相等,则向相邻的偶数舍入。
            System.out.println("            进位    = " + new BigDecimal("2.31").setScale(1, BigDecimal.ROUND_UP));
        }

    打印结果:

    四舍五入(保留位后一位是5进位) = 2.4
    四舍五入(保留位后一位是5舍弃) = 2.3
    四舍五入(保留位是奇数) = 4.6
    四舍五入(保留位是偶数) = 4.4
                进位    = 2.4

    说明:

        ROUND_CEILING 
        Rounding mode to round towards positive infinity. 
         向正无穷方向舍入
    
        ROUND_DOWN 
        Rounding mode to round towards zero. 
         向零方向舍入
    
        ROUND_FLOOR 
        Rounding mode to round towards negative infinity. 
         向负无穷方向舍入
    
        ROUND_HALF_DOWN 
        Rounding mode to round towards "nearest neighbor" unless both neighbors are equidistant, in which case round down. 
         向(距离)最近的一边舍入,除非两边(的距离)是相等,如果是这样,向下舍入, 例如1.55 保留一位小数结果为1.5
    
        ROUND_HALF_EVEN 
        Rounding mode to round towards the "nearest neighbor" unless both neighbors are equidistant, in which case, round towards the even neighbor. 
         向(距离)最近的一边舍入,除非两边(的距离)是相等,如果是这样,如果保留位上的数字是奇数,使用ROUND_HALF_UP ,如果是偶数,使用ROUND_HALF_DOWN
    
    
        ROUND_HALF_UP 
        Rounding mode to round towards "nearest neighbor" unless both neighbors are equidistant, in which case round up. 
         向(距离)最近的一边舍入,除非两边(的距离)是相等,如果是这样,向上舍入, 1.55保留一位小数结果为1.6
    
    
        ROUND_UNNECESSARY 
        Rounding mode to assert that the requested operation has an exact result, hence no rounding is necessary. 
         计算结果是精确的,不需要舍入模式
    
    
        ROUND_UP 
        Rounding mode to round away from zero. 
          向远离0的方向舍入
    
    展开全文
  • 1.问题:数字格式:四舍五入的用法;2.源代码:public class TestDemo4 { public static void main(String[] args) { NumberFormat nf = NumberFormat.getPercentInstance();/*设置为百分比*/ nf....

    1.问题:

    数字格式:四舍五入的用法;

    2.源代码:

    public class TestDemo4 {
        public static void main(String[] args) {
            NumberFormat nf = NumberFormat.getPercentInstance();/*设置为百分比*/
            nf.setMinimumFractionDigits(2);//设置该百分比数字,保留2位小数;
            nf.setRoundingMode(RoundingMode.HALF_UP); //设置满5向上进位,即四舍五入;
    
            /*实验*/
            Double a=0.1956565445;
            String b=nf.format(a);
            System.out.println(b);
        }
    }
    

    3.截图:

    这里写图片描述

    4.总结:

    ①设置百分比:
    NumberFormat nf=NumberFormat.getPercentInstance();
    ②设置百分比保留的位数:
    nf.setMinimumFractionDigits(2);
    ③进位规则:
    nf.setRoundingMode(RoundingMode.HALF_UP);
    满5向上进位;还有其它方法,例如满5向下进位;

    展开全文
  • 建议25: 不要让四舍五入亏了一方 本建议还是来重温一个小学数学问题:四舍五入四舍五入是一种近似精确的计算方法,在Java 5之前,我们一般是通过使用Math.round来获得指定精度的整数或小数的,这种方法使用...

    建议25: 不要让四舍五入亏了一方

    本建议还是来重温一个小学数学问题:四舍五入。四舍五入是一种近似精确的计算方法,在Java 5之前,我们一般是通过使用Math.round来获得指定精度的整数或小数的,这种方法使用非常广泛,代码如下:

    public class Client {  
          public static void main(String[] args) {  
               System.out.println("10.5近似值:" + Math.round(10.5));  
               System.out.println("-10.5近似值:"+ Math.round(-10.5));  
          }  
     } 

    运行结果:

    10.5近似值:11
    -10.5近似值:-10

    这是四舍五入的经典案例,也是初级面试官很乐意选择的考题,绝对值相同的两个数字,近似值为什么就不同了呢?这是由Math.round采用的舍入规则所决定的(采用的是正无穷方向舍入规则,后面会讲解)。我们知道四舍五入是有误差的:其误差值是舍入位的一半。我们以舍入运用最频繁的银行利息计算为例来阐述该问题。

    我们知道银行的盈利渠道主要是利息差,从储户手里收拢资金,然后放贷出去,其间的利息差额便是所获得的利润。对一个银行来说,对付给储户的利息的计算非常频繁,人民银行规定每个季度末月的20日为银行结息日,一年有4次的结息日。

    场景介绍完毕,我们回过头来看四舍五入,小于5的数字被舍去,大于等于5的数字进位后舍去,由于所有位上的数字都是自然计算出来的,按照概率计算可知,被舍入的数字均匀分布在0到9之间,下面以10笔存款利息计算作为模型,以银行家的身份来思考这个算法:

    四舍。舍弃的数值:0.000、0.001、0.002、0.003、0.004,因为是舍弃的,对银行家来说,就不用付款给储户了,那每舍弃一个数字就会赚取相应的金额:0.000、0.001、0.002、0.003、0.004。

    五入。进位的数值:0.005、0.006、0.007、0.008、0.009,因为是进位,对银行家来说,每进一位就会多付款给储户,也就是亏损了,那亏损部分就是其对应的10进制补数:0.005、0.004、0.003、0.002、0.001。

    因为舍弃和进位的数字是在0到9之间均匀分布的,所以对于银行家来说,每10笔存款的利息因采用四舍五入而获得的盈利是:

    0.000 + 0.001 + 0.002 + 0.003 + 0.004 - 0.005 - 0.004 - 0.003 - 0.002 - 0.001 = -0.005 

    也就是说,每10笔的利息计算中就损失0.005元,即每笔利息计算损失0.0005元,这对一家有5千万储户的银行来说(对国内的银行来说,5千万是个很小的数字),每年仅仅因为四舍五入的误差而损失的金额是:

    public class Client {  
         public static void main(String[] args) {  
              //银行账户数量,5千万  
              int accountNum =5000*10000;  
              //按照人行的规定,每个季度末月的20日为银行结息日  
              double cost = 0.0005 * accountNum * 4 ;  
              System.out.println("银行每年损失的金额:" + cost);  
         }  
    }

    输出的结果是:“银行每年损失的金额:100000.0”。即,每年因为一个算法误差就损失了10万元,事实上以上的假设条件都是非常保守的,实际情况可能损失得更多。那各位可能要说了,银行还要放贷呀,放出去这笔计算误差不就抵消掉了吗?不会抵销,银行的贷款数量是非常有限的,其数量级根本没有办法和存款相比。

    这个算法误差是由美国银行家发现的(那可是私人银行,钱是自己的,白白损失了可不行),并且对此提出了一个修正算法,叫做银行家舍入(Banker's Round)的近似算法,其规则如下:

    舍去位的数值小于5时,直接舍去;

    舍去位的数值大于等于6时,进位后舍去;

    当舍去位的数值等于5时,分两种情况:5后面还有其他数字(非0),则进位后舍去;若5后面是0(即5是最后一个数字),则根据5前一位数的奇偶性来判断是否需要进位,奇数进位,偶数舍去。

    以上规则汇总成一句话:四舍六入五考虑,五后非零就进一,五后为零看奇偶,五前为偶应舍去,五前为奇要进一。我们举例说明,取2位精度:

    round(10.5551) = 10.56  
    round(10.555)  = 10.56  
    round(10.545)  = 10.54 

    要在Java 5以上的版本中使用银行家的舍入法则非常简单,直接使用RoundingMode类提供的Round模式即可,示例代码如下:

    public class Client {  
         public static void main(String[] args) {  
              //存款  
              BigDecimal d = new BigDecimal(888888);  
              //月利率,乘3计算季利率  
              BigDecimal r = new BigDecimal(0.001875*3);  
              //计算利息  
              BigDecimal i = d.multiply(r).setScale(2,RoundingMode.HALF_EVEN);  
              System.out.println("季利息是:"+i);  
         }  
    }


    在上面的例子中,我们使用了BigDecimal类,并且采用setScale方法设置了精度,同时传递了一个RoundingMode.HALF_EVEN参数表示使用银行家舍入法则进行近似计算,BigDecimal和RoundingMode是一个绝配,想要采用什么舍入模式使用RoundingMode设置即可。目前Java支持以下七种舍入方式:
    
    ROUND_UP: 远离零方向舍入。
    
    向远离0的方向舍入,也就是说,向绝对值最大的方向舍入,只要舍弃位非0即进位。
    
    ROUND_DOWN:趋向零方向舍入。
    
    向0方向靠拢,也就是说,向绝对值最小的方向输入,注意:所有的位都舍弃,不存在进位情况。
    
    ROUND_CEILING:向正无穷方向舍入。
    
    向正最大方向靠拢,如果是正数,舍入行为类似于ROUND_UP;如果为负数,则舍入行为类似于ROUND_DOWN。注意:Math.round方法使用的即为此模式。
    
    ROUND_FLOOR:向负无穷方向舍入。
    
    向负无穷方向靠拢,如果是正数,则舍入行为类似于 ROUND_DOWN;如果是负数,则舍入行为类似于 ROUND_UP。
    
    HALF_UP: 最近数字舍入(5进)。
    
    这就是我们最最经典的四舍五入模式。
    
    HALF_DOWN:最近数字舍入(5舍)。
    
    在四舍五入中,5是进位的,而在HALF_DOWN中却是舍弃不进位。
    
    HALF_EVEN :银行家算法。
    
    在普通的项目中舍入模式不会有太多影响,可以直接使用Math.round方法,但在大量与货币数字交互的项目中,一定要选择好近似的计算模式,尽量减少因算法不同而造成的损失。
    
    注意 根据不同的场景,慎重选择不同的舍入模式,以提高项目的精准度,减少算法损失。


    RoundingMode介绍

    RoundingMode是一个枚举类,有一下几个常量:UP,DOWN,CEILING,FLOOR,HALF_UP,HALF_DOWN,HALF_EVEN,UNNECESSARY

     


     

    UP
    public static final RoundingMode UP
    远离零方向舍入的舍入模式。始终对非零舍弃部分前面的数字加 1。注意,此舍入模式始终不会减少计算值的绝对值。

    示例:

    输入数字 使用 UP 舍入模式
    将输入数字舍入为一位数
    5.5 6
    2.5 3
    1.6 2
    1.1 2
    1.0 1
    -1.0 -1
    -1.1 -2
    -1.6 -2
    -2.5 -3
    -5.5 -6

     


     

    DOWN
    public static final RoundingMode DOWN
    向零方向舍入的舍入模式。从不对舍弃部分前面的数字加 1(即截尾)。注意,此舍入模式始终不会增加计算值的绝对值。

    示例:

    输入数字 使用 DOWN 舍入模式
    将输入数字舍入为一位数
    5.5 5
    2.5 2
    1.6 1
    1.1 1
    1.0 1
    -1.0 -1
    -1.1 -1
    -1.6 -1
    -2.5 -2
    -5.5 -5

     


     

    CEILING
    public static final RoundingMode CEILING
    向正无限大方向舍入的舍入模式。如果结果为正,则舍入行为类似于 RoundingMode.UP;如果结果为负,则舍入行为类似于 RoundingMode.DOWN。注意,此舍入模式始终不会减少计算值。

    示例:

    输入数字 使用 CEILING 舍入模式
    将输入数字舍入为一位数
    5.5 6
    2.5 3
    1.6 2
    1.1 2
    1.0 1
    -1.0 -1
    -1.1 -1
    -1.6 -1
    -2.5 -2
    -5.5 -5

     


     

    FLOOR
    public static final RoundingMode FLOOR
    向负无限大方向舍入的舍入模式。如果结果为正,则舍入行为类似于 RoundingMode.DOWN;如果结果为负,则舍入行为类似于RoundingMode.UP。注意,此舍入模式始终不会增加计算值。

    示例:

    输入数字 使用 FLOOR 舍入模式
    将输入数字舍入为一位数
    5.5 5
    2.5 2
    1.6 1
    1.1 1
    1.0 1
    -1.0 -1
    -1.1 -2
    -1.6 -2
    -2.5 -3
    -5.5 -6

     


     

    HALF_UP
    public static final RoundingMode HALF_UP
    向最接近数字方向舍入的舍入模式,如果与两个相邻数字的距离相等,则向上舍入。如果被舍弃部分 >= 0.5,则舍入行为同 RoundingMode.UP;否则舍入行为同RoundingMode.DOWN。注意,此舍入模式就是通常学校里讲的四舍五入。

    示例:

    输入数字 使用 HALF_UP 舍入模式
    将输入数字舍入为一位数
    5.5 6
    2.5 3
    1.6 2
    1.1 1
    1.0 1
    -1.0 -1
    -1.1 -1
    -1.6 -2
    -2.5 -3
    -5.5 -6

     


     

    HALF_DOWN
    public static final RoundingMode HALF_DOWN
    向最接近数字方向舍入的舍入模式,如果与两个相邻数字的距离相等,则向下舍入。如果被舍弃部分 > 0.5,则舍入行为同 RoundingMode.UP;否则舍入行为同RoundingMode.DOWN

    示例:

    输入数字 使用 HALF_DOWN 舍入模式
    将输入数字舍入为一位数
    5.5 5
    2.5 2
    1.6 2
    1.1 1
    1.0 1
    -1.0 -1
    -1.1 -1
    -1.6 -2
    -2.5 -2
    -5.5 -5

     


     

    HALF_EVEN
    public static final RoundingMode HALF_EVEN
    向最接近数字方向舍入的舍入模式,如果与两个相邻数字的距离相等,则向相邻的偶数舍入。如果舍弃部分左边的数字为奇数,则舍入行为同 RoundingMode.HALF_UP;如果为偶数,则舍入行为同RoundingMode.HALF_DOWN。注意,在重复进行一系列计算时,此舍入模式可以在统计上将累加错误减到最小。此舍入模式也称为“银行家舍入法”,主要在美国使用。此舍入模式类似于 Java 中对floatdouble 算法使用的舍入策略。

    示例:

    输入数字 使用 HALF_EVEN 舍入模式
    将输入数字舍入为一位数
    5.5 6
    2.5 2
    1.6 2
    1.1 1
    1.0 1
    -1.0 -1
    -1.1 -1
    -1.6 -2
    -2.5 -2
    -5.5 -6

     


     

    UNNECESSARY
    public static final RoundingMode UNNECESSARY
    用于断言请求的操作具有精确结果的舍入模式,因此不需要舍入。如果对生成精确结果的操作指定此舍入模式,则抛出 ArithmeticException

    示例:

    输入数字 使用 UNNECESSARY 舍入模式
    将输入数字舍入为一位数
    5.5 抛出 ArithmeticException
    2.5 抛出 ArithmeticException
    1.6 抛出 ArithmeticException
    1.1 抛出 ArithmeticException
    1.0 1
    -1.0 -1
    -1.1 抛出 ArithmeticException
    -1.6 抛出 ArithmeticException
    -2.5 抛出 ArithmeticException
    -5.5 抛出 ArithmeticException

    注意使用RoundingMode.HALF_UP实现四舍五入的bug问题:

    	public static void main(String[] args) {
    		//传说中的经典四舍五入
    		System.out.println(new BigDecimal(1.1315).setScale(3, RoundingMode.HALF_UP).doubleValue());//1.131
    		System.out.println(new BigDecimal(1.13151).setScale(3, RoundingMode.HALF_UP).doubleValue());//1.132
    		System.out.println(new BigDecimal(1.1325).setScale(3, RoundingMode.HALF_UP).doubleValue());//1.133
    	}

    为什么传说中的经典四舍五入与我们预期的结果1.132不符呢?难道是java语言的bug?

    		System.out.println(new BigDecimal(1.1315));//1.13149999999999995026200849679298698902130126953125
    		System.out.println(new BigDecimal(1.13151));//1.131510000000000015774048733874224126338958740234375
    		System.out.println(new BigDecimal(1.1325));//1.1325000000000000621724893790087662637233734130859375
    		System.out.println(new BigDecimal(1.1335));//1.1334999999999999520383653361932374536991119384765625
    		System.out.println(new BigDecimal(1.1345));//1.13450000000000006394884621840901672840118408203125
    通过测试,我们发现数字1.1315转为BigDecimal的实际值是1.1314999999999999502620,那么四舍五入保留3位小数的值为1.131就是正确的返回结果了。

    BigDecimal的构造函数 public BigDecimal(double val) 会损失了double 参数的精度,从而导致经典四舍五入的结果与预期不符。



    展开全文
  • C++中的四舍五入

    万次阅读 2017-05-23 10:38:02
    C++中的四舍五入

    在C++的输出流中使用控制符,可以实现对输出格式的控制,包括对输出小数的精度的控制:

    double a=123.456789012345; //对a赋初值
    cout<<setiosflags(ios∷fixed)<<setprecision(8)<<a; //输出: 123.45678901 

    设置小数的精度后,程序会对数据进行自动的四舍五入。
    但是在普通的整形计算表达式中,程序不会自动进行四舍五入,例如:

    int main(){
        int a = 0.69;
        cout<<"a = "<<a<<endl;
        return 0;
    }

    输出结果为:
    这里写图片描述

    在math.h或cmath头文件中有四舍五入有关的函数:
    这里写图片描述
    round函数就可以完成四舍五入的工作。

    下面自己编写一个将double四舍五入为整形int的函数:

    #include <iostream>
    #include <cmath>
    using namespace std;
    
    int r(double a){
        int b;
        if(a > 0){
            b = (a*2+1)/2;
        }else{
            b = (a*2-1)/2;  
        }
        return b;
    }
    
    int main(){ 
        double a = -0.69;
        a = r(a);   
        cout<<"a = "<<a<<endl;  
        cout<<"round(a) = "<<round(a)<<endl;    
        return 0;
    }

    输出为:
    这里写图片描述

    展开全文
  • Hive四舍五入等用法

    千次阅读 2018-10-23 16:02:57
    返回类型 函数名 ... 四舍五入 hive> select round(3.4); 3.0 hive> select round(3.6); 4.0 double round(double a,int b) 指定精度四舍五入 hive> se...
  • DB2数据库之四舍五入

    万次阅读 2016-11-21 13:59:34
    DB2数据库需要用到两个函数实现四舍五入,分别是:CAST、round round函数本身就是实现四舍五入,为什么还要CAST函数? 案例讲解: 首先创建一张测试表用于模拟四舍五入的情景。项目中对于金额字段一般将类型定义为...
  • 四舍五入设置 (1)、浮点数精确计算 项目中一直存在一个问题,就是每次报表统计的物资金额和实际的金额要差那么几分钱,和实际金额不一致,让客户觉得总是不那么舒服,原因是因为我们使用java的浮点类型...
  • ABAP 关于四舍五入算法

    千次阅读 2015-01-20 21:58:41
    ABAP 关于四舍五入算法
  • Number.toFixed(n) -- 保留n位小数点,多出的四舍五入 var num=123456.789; var num1=num.toFixed(2) // 123456.79 如果不要四舍五入,并且一定要去2位小数,即使是“12.1”这种要变成“12.10”可以保留3位小数...
  • sql server小数四舍五入,保留

    千次阅读 2016-11-15 16:13:49
    round()函数,是四舍五入用,第一个参数是我们要被操作的数据,第二个参数是设置我们四舍五入之后小数点后显示几位。 numeric函数的2个参数,第一个表示数据长度,第二个参数表示小数点后位数。 cast as numeric(5...
  • java 小数转换成百分数 四舍五入

    千次阅读 2018-12-18 15:14:30
    下面列举 小数转百分数...1,不四舍五入 直接转成字符串截取  System.out.println(String.valueOf(c * 100).substring(0, 5) + "%"); 2,四舍五入 2.1 NumberFormat nt = NumberFormat.getPercentIn...
  • python一些简单,但是很强大的函数:import numpy as np #变量的值的互换,如a,b两个向量的值互换,不能用a = b, b=a完成,需要中间变量 #但是python里面用tuple也很容易的实现 ...#四舍五入 round(3.45...
  • C#使用Math.Round()四舍五入

    千次阅读 2018-01-10 18:13:49
    C#使用Math.Round()四舍五入 1.使用重载函数Math.Round(值,精确位数) ( 四舍六入五取偶) 如果不指定第三个参数,则等效为第三参数指定MidpointRounding.ToEven,即向最近的偶数四舍五入。 这个时候不是我们...
  • Access的四舍五入取整

    千次阅读 2013-01-01 00:51:26
    -- 四舍五入取整 SELECT Round(639.4639,0)结果:639 SELECT Round(639.5639,0)结果:640 -- 四舍五入取小数位SELECT Round(639.4639,2)结果:639.46 SELECT Round(639.5639,2)结果:639.56...
  • 本文所有讨论都是基于python3...就会引出python四舍五入问题。 一、python四舍五入问题 好多博客在说round做舍入的时候,要看舍入的前一位是奇数还是偶数,奇数进位,偶数舍去,其实是不准确的。例如: >>&...
  • java四舍五入和精度控制

    千次阅读 2013-07-05 13:25:16
    Java中Double的高精度问题及... 四舍五入 我们的第一个反应是做四舍五入。Math类中的round方法不能设置保留几位小数,我们只能 象这样(保留两位): public double round(double value){  return Math.rou
  • MySQL 浮点数字段“四舍五入”问题

    千次阅读 2019-07-01 14:47:09
    MySQL 浮点数字段,使用ROUND函数进行 “四舍五入” 计算时,查询结果错误的原因及解决方案
  • SQL数字类型转换和四舍五入

    千次阅读 2016-03-14 23:12:02
    cast和convert用于数据类型转换,round用于四舍五入取近似字,numeric用于精确设置数字精度(长度)和小数位数。 T-SQL: CAST and CONVERT Explicitly converts an expression of one data type to another. CAST and ...
  • // 案例:四舍五入保留小数点后1位 double d1 = 123.456; double d2 = 654.321; double v1 = (double) Math.round(d1 * 10) / 10; double v2 = (double) Math.round(d2 * 10) / 10; System.out...
  • java对数字进行四舍五入

    千次阅读 2014-06-25 22:54:08
    1. 利用数学函数 /** * 利用数学函数四舍五入,最简便的方法 */ public static Float mathConvert(Float num){ return (float) Math.round(num * 100 )/ 100; }
  • python 数字的四舍五入的问题

    万次阅读 2016-10-19 19:30:15
    python3 以及python2.7 使用 round或者format进行浮点数的四舍五入问题由于 python3 包括python2.7 以后的round策略使用的是decimal.ROUND_HALF_EVEN 即Round to nearest with ties going to nearest even integer....
  • 在很多场景的计算中,最终得到的数值例如123.45678,要截取2位小数得到123.45,而不是默认的四舍五入方法得到123.46,如何实现呢? 文章目录 一.小数点后取2位(四舍五入)的方法 方法一:round()...
  • java实现数字的(四舍五入)算法

    千次阅读 2017-06-13 11:07:32
    java中要实现四舍五入的算法,其实自己写也很简单,不过java原生也自带了这个类,那就是Math类。 java.lang.Math 类包含的方法进行基本的数字操作,如基本的指数,对数,平方根和三角函数等. 不废话了,直接上代码...
  • Delphi的四舍五入函数

    千次阅读 2015-05-15 10:25:48
    一、四舍五入法  四舍五入是一种应用非常广泛的近似计算方法,其有算术舍入法和银行家舍入法两种。  所谓算术舍入法,就是我们通常意义上的四舍五入法。其规则是:当舍去位的数值大于等于5时,在舍去该位的同时...
  • 1.round() 函数是四舍五入用,第一个参数是我们要被操作的数据,第二个参数是设置我们四舍五入之后小数点后显示几位。 2.numeric 函数的2个参数,第一个表示数据长度,第二个参数表示小数点后位数。 例如: ...
  • DecimalFormat用法,四舍五入

    千次阅读 2018-07-26 19:12:27
    DecimalFormat DFORMAT = new DecimalFormat("0.00"); System.out.println(DFORMAT.format(0.123)); System.out.println(DFORMAT.format(11.123)); System.out.println(DFORMAT.fo...
  • java double类型保留小数和四舍五入

    千次阅读 2017-02-15 21:12:49
    方法一:通过四舍五入方式保留特定后几位 import java.util.*; public class Main { public static void main(String args[]) { double t=1.123456; System.out.println((double)Math.round(t*100000)/...
  • 小数在我们的日常使用中经常使用到,有时候需要取整,有时候需要四舍五入,在不同的软件中还是不一样的,以下列出2种: 1.EXECL: 直接使用ROUND函数就可以,例如ROUND(3.1415926,3)=3.142 /ROUND(3.1415926,0)=3 ...
  • 关于BigDecimal数据的四舍五入

    千次阅读 2015-11-13 16:51:36
    BigDecimal类的主要功能是进行小数的大数计算,而且最重要的是可以精确到指定的四舍五入位数。 如果要进行四舍五入的操作,则必须依靠以下的方法: public BigDecimal divide(BigDecimal divisor,int scale,...
  • 关于BigDecimal的四舍五入和截断

    千次阅读 2015-05-05 11:16:51
    关于四舍五入: ROUND_HALF_UP: 遇到.5的情况时往上近似,例: 1.5 ->;2 ROUND_HALF_DOWN : 遇到.5的情况时往下近似,例: 1.5 ->;1 BigDecimal a = new BigDecimal(1.5); System.out.println("down="+a.setScale(0,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 55,959
精华内容 22,383
关键字:

如何设置四舍五入