精华内容
下载资源
问答
  • 一.java种取整数的方式 1.直接使用强制转换 public static void roundOne(){ System.out.println("正数:(int)10.12 = " + (int)10.12); System.out.println("负数:(int)-10.12 = " + (int)-10.12); S


        今天编码时,需要对数据进行保留两位小数处理,结果卡壳了,百度了一下解决掉后,结果返回到前端的值不是预想值,特此整理,以备后续遗忘。

    一.java中取整数的方式

    1.直接使用强制转换

    public static void roundOne(){
            System.out.println("正数:(int)10.12 = " + (int)10.12);   
            System.out.println("负数:(int)-10.12 = " + (int)-10.12);  
            System.out.println("---------------------------------");
            System.out.println("正数:(int)1011111111111111111111.12 = " + (int)1011111111111111111111.12);   
            System.out.println("负数:(int)-1011111111111111111111.12 = " + (int)-1011111111111111111111.12);  
        }


        直接用强制转换的方式将浮点型数据转换为整型时,直接去掉小数点后部分的精度,取整数部分;直接强制取整有精度风险,一方面是小数位损失,另一方面当浮点型数字超过整型数字最大值时,会发生溢出。实际工程中,如果这两种因素都不会对工程产生影响,可以使用,否则不建议使用。


    2.java中提供的取整的函数

      java中提供了三种取整的函数:
      (1).Math.ceil(double num);
      (2).Math.floor(double num);
      (3).Math.round(double num);

       public static void roundTwo(){
            System.out.println("正数:Math.ceil(10.12) = " + Math.ceil(10.12));
            System.out.println("负数:Math.ceil(-10.12) = " + Math.ceil(-10.12));
            System.out.println("正数:Math.ceil(101111111111111111111.12) = " + Math.ceil(101111111111111111111.12));
            System.out.println("负数:Math.ceil(-101111111111111111111.12) = " + Math.ceil(-101111111111111111111.12));
            System.out.println("---------------------------------");
            System.out.println("正数:Math.floor(10.12) = " + Math.floor(10.12));
            System.out.println("负数:Math.floor(-10.12) = " + Math.floor(-10.12));
            System.out.println("正数:Math.floor(101111111111111111111.12) = " + Math.floor(101111111111111111111.12));
            System.out.println("负数:Math.floor(-101111111111111111111.12) = " + Math.floor(-101111111111111111111.12));
        }



        Math.ceil(double num);函数是取浮点数的天花板数,即不小于num的最小整数;Math.floor(double num)函数是取地板数,即不大于num的最大整数。这两个函数的返回值均是double型(java中当其值大于9999999.0时,默认用科学记数法表示),如果超过没有特殊情况,或者说规则很明确,就一种规则。


    public static void roundThree(){
            System.out.println("小数点后第一位=5");   
            System.out.println("正数:Math.round(10.5) = " + Math.round(10.5));   
            System.out.println("负数:Math.round(-10.5) = " + Math.round(-10.5));   
            System.out.println();   
      
            System.out.println("小数点后第一位<5");   
            System.out.println("正数:Math.round(10.46) = " + Math.round(10.46));   
            System.out.println("负数:Math.round(-10.46) = " + Math.round(-10.46));   
            System.out.println();   
      
            System.out.println("小数点后第一位>5");   
            System.out.println("正数:Math.round(10.68) = " + Math.round(10.68));   
            System.out.println("负数:Math.round(-10.68) = " + Math.round(-10.68));
        }


     

     Math.round(double num)函数是取整函数,该函数只关注小数点后第一位小数值,具体规则如下:
    (1).参数的小数点后第一位<5,运算结果为参数整数部分。
    (2).参数的小数点后第一位>5,运算结果为参数整数部分绝对值+1,符号(即正负)不变。
    (3).参数的小数点后第一位=5,正数运算结果为整数部分+1,负数运算结果为整数部分。
    总结:大于五全部加,等于五正数加,小于五全不加。


    二.Java中四舍五入的方法

    1.使用BigDecimal对象的方式

    public static void roundFour(){
            double f = 10.2345;
            BigDecimal b0 = new BigDecimal(f);
            BigDecimal b1 = new BigDecimal(f);
            BigDecimal b2 = new BigDecimal(f);
            BigDecimal b3 = new BigDecimal(f);
            BigDecimal b4 = new BigDecimal(f);
            BigDecimal b5 = new BigDecimal(f);
            BigDecimal b6 = new BigDecimal(f);
            BigDecimal b7 = new BigDecimal("10.2345");
            
            double f0 = b0.setScale(3, BigDecimal.ROUND_UP).doubleValue();
            double f1 = b1.setScale(3, BigDecimal.ROUND_DOWN).doubleValue();
            double f2 = b2.setScale(3, BigDecimal.ROUND_CEILING).doubleValue();
            double f3 = b3.setScale(3, BigDecimal.ROUND_FLOOR).doubleValue();
            double f4 = b4.setScale(3, BigDecimal.ROUND_HALF_UP).doubleValue();
            double f5 = b5.setScale(3, BigDecimal.ROUND_HALF_DOWN).doubleValue();
            double f6 = b6.setScale(3, BigDecimal.ROUND_HALF_EVEN).doubleValue();
            double f7 = b7.setScale(4, BigDecimal.ROUND_UNNECESSARY).doubleValue();
            
            System.out.println(f + "使用  远离零方向舍入(ROUND_UP)方式四舍五入结果为:" + f0);
            System.out.println(f + "使用  趋向零方向舍入(ROUND_DOWN)方式四舍五入结果为:" + f1);
            System.out.println(f + "使用  向正无穷方向舍入(ROUND_CEILING)方式四舍五入结果为:" + f2);
            System.out.println(f + "使用  向负无穷方向舍入(ROUND_FLOOR)方式四舍五入结果为:" + f3);
            System.out.println(f + "使用  最近数字舍入(5进)(ROUND_HALF_UP)方式四舍五入结果为:" + f4);
            System.out.println(f + "使用  最近数字舍入(5舍)(ROUND_HALF_DOWN)方式四舍五入结果为:" + f5);
            System.out.println(f + "使用  银行家舍入法(ROUND_HALF_EVEN)方式四舍五入结果为:" + f6);
            System.out.println(f + "使用  不需要舍入模式(ROUND_UNNECESSARY)方式结果为:" + f7);
        }


       

    BigDecimal中有8中四舍五入设置方式:

    (1).ROUND_UP:远离零方向舍入。向绝对值最大的方向舍入,只要舍弃位非0即进位。

    (2).ROUND_DOWN:趋向零方向舍入。向绝对值最小的方向输入,所有的位都要舍弃,不存在进位情况。

    (3).ROUND_CEILING:向正无穷方向舍入。向正最大方向靠拢。若是正数,舍入行为类似于ROUND_UP,若为负数,舍入行为类似于ROUND_DOWN。Math.round()方法就是使用的此模式。

    (4).ROUND_FLOOR:向负无穷方向舍入。向负无穷方向靠拢。若是正数,舍入行为类似于ROUND_DOWN;若为负数,舍入行为类似于ROUND_UP。

    (5).ROUND_HALF_UP:最近数字舍入(5进)。这是我们最经典的四舍五入。

    (6).ROUND_HALF_DOWN:最近数字舍入(5舍)。在这里5是要舍弃的。

    (7).ROUND_HALF_EVEN:银行家舍入法。

    (8).ROUND_UNNECESSARY:计算结果是精确的,不需要舍入模式。

        a.ROUND_HALF_DOWN解释

        第(6)中四舍五入方式ROUND_HALF_DOWN解释的是遇到5要舍弃,但10.2345保留3位小数后结果是10.235,并没有直接舍去精确位的5,还是进了1,为什么呢?

    public static void roundFive(){
            //通过double类型作为参数实例化BigDecimal对象
            double f = 10.2345;
            BigDecimal b5 = new BigDecimal(f);
            System.out.println("b5:" + b5);
            double f5 = b5.setScale(3, BigDecimal.ROUND_HALF_DOWN).doubleValue();
            System.out.println("ROUND_HALF_DOWN方式处理后:" + f5);
            System.out.println("----------------------------");
            //通过字符串类型作为参数实例化BigDecimal对象
            BigDecimal b5_1 = new BigDecimal("10.2345");
            System.out.println("b5_1:" + b5_1);
            double f5_1 = b5_1.setScale(3, BigDecimal.ROUND_HALF_DOWN).doubleValue();
            System.out.println("ROUND_HALF_DOWN方式处理后:" + f5_1);
            System.out.println("----------------------------");
            //遇到的5后面有小数位0,对数据大小无影响,直接舍弃5
            BigDecimal b5_2 = new BigDecimal("10.23450");
            System.out.println("b5_2:" + b5_2);
            double f5_2 = b5_2.setScale(3, BigDecimal.ROUND_HALF_DOWN).doubleValue();
            System.out.println("ROUND_HALF_DOWN方式处理后:" + f5_2);
            System.out.println("----------------------------");
            
          //遇到的5后面有非0小数位,对数据大小有影响,会进1
            BigDecimal b5_3 = new BigDecimal("10.234501");
            System.out.println("b5_3:" + b5_3);
            double f5_3 = b5_3.setScale(3, BigDecimal.ROUND_HALF_DOWN).doubleValue();
            System.out.println("ROUND_HALF_DOWN方式处理后:" + f5_3);
            System.out.println("----------------------------");
        }


        通过例子可以看出,10.2345通过ROUND_HALF_DOWN方式保留三位小数后结果为10.235原因是,使用的double类型初始化产生的BigDecimal对象的,实际上实例化后的数值并不是10.2345,而是10.234500000000000596855898038484156131744384765625,根据样例可知,当5后面还有其他小数时,依然会向前进1位。也就是说当使用ROUND_HALF_DOWN方式时,并不是所有的5都直接舍去,需要看5后面是否有其他非0位,如果没有,直接舍去,如果有,需要进1。


        b.银行家算法

        四舍五入其实在金融方面运用的非常多,尤其是银行的利息。我们都知道银行的盈利渠道主要是利息差,它从储户手里收集资金,然后放贷出去,期间产生的利息差就是银行所获得的利润。如果我们采用平常四舍五入的规则话,这里采用每10笔存款利息计算作为模型,如下:

    四舍:0.000、0.001、0.002、0.003、0.004。这些舍的都是银行赚的钱。
    五入:0.005、0.006、0.007、0.008、0.009。这些入的都是银行亏的钱,

    分别为:0.005、0.004、.003、0.002、0.001。

        所以对于银行来说它的盈利应该是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元,千万别小看这个数字,这对于银行来说就是一笔非常大的损失。面对这个问题就产生了如下的银行家涉入法了。该算法是由美国银行家提出了,主要用于修正采用上面四舍五入规则而产生的误差。如下:

    (1).舍去位的数值小于5时,直接舍去。
    (2).舍去位的数值大于5时,进位后舍去。
    (3).当舍去位的数值等于5时,若5后面还有其他非0数值,则进位后舍去,若5后面是0时,则根据5前一位数的奇偶性来判断,奇数进位,偶数舍去。

    对于上面的规则我们举例说明
    11.556 = 11.56          ------六入
    11.554 = 11.55          -----四舍
    11.5551 = 11.56         -----五后有数进位
    11.545 = 11.54          -----五后无数,若前位为偶数应舍去
    11.555 = 11.56          -----五后无数,若前位为奇数应进位


        c.ROUND_UNNECESSARY解释

       ROUND_UNNECESSARY方式表示计算结果是精确的,如果不是精确的,将会抛出java.lang.ArithmeticException异常。

    public static void roundSix(){
            BigDecimal b7 = new BigDecimal("10.23455");
            double f7 = b7.setScale(4, BigDecimal.ROUND_UNNECESSARY).doubleValue();
            System.out.println("ROUND_UNNECESSARY方式处理后:" + f7);
        }


    如果将BigDecimal b7 = new BigDecimal("10.23455")中的数字改为10.2345或10.234500000;即可正常运行。也就是说,使用ROUND_UNNECESSARY方式时,浮点数保留N位小数时,不能影响数字的精度,只要有舍弃掉数字导致精度受影响,都会抛出异常。

    注:这些枚举值有时候会用RoundingMode类中的枚举值,其实效果是一样的,RoundingMode只是将BigDecimal中的枚举又封装了一层,简化了一下枚举名,无实质性差别。RoundingMode枚举类中的枚举示例:UP(BigDecimal.ROUND_UP),


    2.使用DecimalFormat对象的方式

    public static void roundSeven(){
            DecimalFormat df = new DecimalFormat("#.000");
            //df.setRoundingMode(RoundingMode.DOWN);
            System.out.println(df.format(new BigDecimal(10.2345)));//10.235
        }

    注:DecimalFormat默认采用了RoundingMode.HALF_EVEN这种类型,可以通过setRoundingMode方法进行设置四舍五入方式,而且format之后的结果是一个字符串类型String


    3.使用String.format方式

    public static void roundEight(){
            double d = 10.2345;
            String result = String.format("%.3f", d);
            System.out.println("result:" + result);
        }

    输出为10.235。String.format可以格式化很多类型的数据,包括整数、浮点数、字符串、日期等,具体对浮点数的格式化规则后续详细介绍,此处只需知道浮点数的四舍五入有这种方式。


    4.使用Math.round方式

    public static void roundNine(){
            double d1 = Math.round(5.2644555*100)*0.01d;
            System.out.println("d1:" + d1);
            
            double d2 = Math.round(5.2654555*100)*0.01d;
            System.out.println("d2:" + d2);
        }


    Math.round()方式不建议使用,因为会有风险,如样例所示。


    5.使用NumberFormat方式

    public static void roundTen(){
            double d = 10.2345;
            NumberFormat nf=NumberFormat.getNumberInstance() ;
            nf.setMaximumFractionDigits(2);
            String s= nf.format(d) ;
            System.out.println("s1:" + s);
            
            nf.setMaximumFractionDigits(3);
            s= nf.format(d) ;
            System.out.println("s2:" + s);
        }




    本文参考了以下博客:

    http://blog.csdn.net/snn1410/article/details/36423873

    http://www.cnblogs.com/chenssy/p/3366632.html

    http://blog.csdn.net/jobjava/article/details/6764623







    展开全文
  • Java向上/向下/四舍五入取整

    万次阅读 2018-08-28 16:46:50
    1、四舍五入:Math.round(result); 记忆方式:单词round,是“附近”的意思 2、向上取整 :Math.ceil(result) 记忆方式:单词ceil,是“天花板”的意思 3、向下取整 :Math.floor(result); 记忆方式:单词...

    本文中,使用到的Java 类 :java.lang.Math。

    目标:对数值进行取整操作。

    方式

    1、四舍五入:Math.round(result);

    记忆方式:单词round,是“附近”的意思

    2、向上取整 :Math.ceil(result)

    记忆方式:单词ceil,是“天花板”的意思

    3、向下取整 :Math.floor(result);

    记忆方式:单词floor,是“地板”的意思

    package com.test;
    
    /**
     * Created by Liuxd on 2018-08-28.
     */
    public class TestInteger {
    
        public static void main(String[] args) {
            double d1 = 17;
            double d2 = 3;
    
            double result = d1 / d2;
    
            /**
             * 四舍五入
             */
            int roundNum = (int) Math.round(result);
            /**
             * 向上取整
             */
            int ceilNum = (int) Math.ceil(result);
            /**
             * 向下取整
             */
            int floorNum = (int) Math.floor(result);
    
            System.out.println("除法商值:" + result);
            System.out.println("四舍五入:" + roundNum);
            System.out.println("向上取整:" + ceilNum);
            System.out.println("向下取整:" + floorNum);
        }
    }
    

    输出结果:

    除法商值:5.666666666666667
    四舍五入:6
    向上取整:6
    向下取整:5

     

    展开全文
  • 在处理一些数据时,我们希望能用“四舍五入实现,但是C#采用的是“四舍六入五成双”的方法,如下面的例子,就是用“四舍六入五成双”得到的结果: double d1 = Math.Round(1.25, 1);//1.2double d2 = Math....

    在处理一些数据时,我们希望能用“四舍五入”法实现,但是C#采用的是“四舍六入五成双”的方法,如下面的例子,就是用“四舍六入五成双”得到的结果:

    double d1 = Math.Round(1.25, 1);//1.2
    double d2 = Math.Round(1.24, 1);//1.2
    double d3 = Math.Round(1.26, 1);//1.3
    double d4 = Math.Round(1.35, 1);//1.4

    为了用C#来实现“四舍五入”,我写了下面的函数:

    代码
         /// <summary>
    /// 实现数据的四舍五入法
       /// </summary>
    /// <param name="v">要进行处理的数据</param>
    /// <param name="x">保留的小数位数</param>
    /// <returns>四舍五入后的结果</returns>
    private double Round(double v, int x)
    {
    bool isNegative = false;
    //如果是负数
    if (v < 0)
    {
    isNegative = true;
    v = -v;
    }

    int IValue = 1;
    for (int i = 1; i <= x; i++)
    {
    IValue = IValue * 10;
    }
    double Int = Math.Round(v * IValue + 0.5, 0);
    v = Int / IValue;

    if (isNegative)
    {
    v = -v;
    }

    return v;
    }

    经过简单的测试,上面的函数能实现对数据的四舍五入法。

    Math.Round ()在四舍五入时有个问题:   
    Math.Round(2.5,0) = 2;   
    Math.Round(3.5,0) = 4;
    2.5应该等于3才对!
    在ASP中也存在这个问题,不过ASP中还有个FormatNumber可以用,但目前还不知道怎么使用?
    解释:
    Math.Round()准确的说,这个函数不是四舍五入,而是四舍六入五凑偶,就是说小于4或大于6的该舍该入是没有争议的,而5处在正中间,如果四舍五入则会造成数据的整体偏差,所以采取的原则是:如果舍入位为5,则舍入后最后一位为偶数,这是国际惯例。
    现在做的项目都要5入,解决方法:
    目前做法是: 
    如:(3.45*10+0.5)取整,再除以10
    C# 中没有四舍五入函数,事实上我知道的程序语言都没有四舍五入函数,因为四舍五入算法不科学,国际通行的是 Banker 舍入法 Banker 's rounding(银行家舍入)算法,即四舍六入五取偶。事实上这也是 IEEE 规定的舍入标准。因此所有符合 IEEE 标准的语言都应该是采用这一算法的 
    Math.Round 方法默认的也是 Banker 舍入法 在 .NET 2.0 中 Math.Round 方法有几个重载方法 
    Math.Round(Decimal, MidpointRounding) 
    Math.Round(Double, MidpointRounding) 
    Math.Round(Decimal, Int32, MidpointRounding) 
    Math.Round(Double, Int32, MidpointRounding) 
    将小数值舍入到指定精度。MidpointRounding 参数,指定当一个值正好处于另两个数中间时如何舍入这个值 
    该参数是个 MidpointRounding 枚举 
    此枚举有两个成员:
    AwayFromZero 当一个数字是其他两个数字的中间值时,会将其舍入为两个值中绝对值较大的值。 
    ToEven 当一个数字是其他两个数字的中间值时,会将其舍入为最接近的偶数。 
    所以,要实现四舍五入函数,对于正数,可以加一个 MidpointRounding.AwayFromZero 参数指定当一个数字是其他两个数字的中间值时其舍入为两个值中绝对值较大的值,例: 
    Math.Round(3.45, 2, MidpointRounding.AwayFromZero) 
    不过对于负数上面的方法就又不对了 
    因此需要自己写个函数来处理 
    double ChinaRound(double value, int decimals) 

      if (value < 0) 
      { 
        return Math.Round(value + 5 / Math.Pow(10, decimals + 1), decimals, MidpointRounding.AwayFromZero); 
      } 
      else 
      { 
        return Math.Round(value, decimals, MidpointRounding.AwayFromZero); 
      } 

    有些时候不一定要用四舍五入的,可能需要上取整或下取整:
    Math.Ceiling()和Math.Floor 
    Math.Ceiling(3.1)=4;    
    Math.Floor(3.9)=3;
    取天板值与地板值,与"四舍五入"无关。其实Floor的结果与(int)相同,因此也可以这样写Math.Floor((double)2/3+0.5)
    floor 和 ceil是math unit 里的函数,使用前要先 Uses Math。
    trunc 和 round 是system unit 里的函数,缺省就可以用。
    floor 直接往小的取,比如 floor(-123.55)=-124,floor(123.55)=123
    trunc 直接切下整数,比如 trunc(-123.55)=-123, floor(123.55)=123
    ceil 直接往大的取,比如 ceil(-123.55)=-123, ceil(123.55)=124
    round 计算四舍五入,比如 round(-123.55)=-124,round(123.55)=124
    C#取整函数向上取整实例
    int a = 5; 

    int b = 2;   

    lbl.Text = Convert.ToString(Math.Ceiling((double)a / (double)b)); 

    展开全文
  • 向上取整用:Math.ceil(double a) 向下取整用:Math.floor(double a) int a = 7; int b = 5; BigDecimal aBig = new BigDecimal(a); BigDecimal bBig = new BigDecimal(b); //向上取整 int num1 = (int)...
    向上取整用:Math.ceil(double a)
    
    向下取整用:Math.floor(double a)
            int a = 7;
            int b = 5;
            BigDecimal aBig = new BigDecimal(a);
            BigDecimal bBig = new BigDecimal(b);
            //向上取整
            int num1 = (int)Math.ceil(aBig.divide(bBig).doubleValue());
            //向下取整
            int num2 = (int)Math.floor(aBig.divide(bBig).doubleValue());
            System.out.println("正常值:"+aBig.divide(bBig));
            System.out.println("向上取整:"+num1);
            System.out.println("向下取整:"+num2);

     

    参考:java 除法向上,向下取整 - 秋香姑娘请你不要紧张 - 博客园

    展开全文
  • 阿里巴巴Java岗面试题分享 1.HashMap 的内部结构?内部原理?和 HashTable 的区别,假如发⽣了 hash 碰撞,如何设计能让遍历效率⾼? 2.讲一讲讲讲 ConcurrentHashMap吧。 3.讲一下JVM虚拟机内存结构,以及它们的作...
  • 如果要四舍五入,就要首先转换成Double型,然后利用Math.Round四舍五入。 具体代码如下 Double avg = Math.Round((Double)a / b, 2); 如果想向上取整 Double avg = Math.Cell((Double)a / b, 2); 如果想向下取整 ...
  • * 数据计算结果处理(四舍五入,保留一位小数) * @param member 分子 * @param denominator 分母 * @return */ public static String dateProcessing(int member,int denominator){ floa...
  • 这里讲解一下java里面除法的应用,除法的结果怎样才是小数,怎样自定义的精确到哪一位,怎样解方程 1.除数不能为0,我们都知道java里面...3.正数的,四舍五入,到哪一位怎样自定义商精确到哪一步 使用String xxx = Str.
  • public static void main(String[] args) { int i=15; int a =6; //15除以6等于2.5 System.out.println(((float) i/a)); String result = String.format("%.0f",((float) i/a)); System.out.println...
  • double d = (double) weiguidesc.length() / 18;//文本长度除以每行字符长度 ...//除数取整,也就是行数 float ab = 15f/4f; int ac = (int)ab; Log.i("lgq","......ac==="...
  • 向上取整:Math.ceil(double a) ...四舍五入取整:Math.round(double a) 例: Math.ceil(24.1)–> 25 Math.floor(24.8)–> 24 Math.round(24.1)–> 24 Math.round(24.8)–> 25
  • 商=被数.devide(除数,保留小数位数,精确方法) 120/100 ,150/100 ,180/100 值均为2 public static int divide(String v1, String v2){ BigDecimal b1 = new BigDecimal(v1); BigDecimal b2 = new ...
  • 问题:2个int(m,s)整数除法如何向上取整?答案: (m + s - 1) / m 分析 如图将m按照s的长度划分为8份草绿色加上黄色的部分。m总是可以表示成 m=n*s + d; 0 ≤ d < s; d = (m%s)。 在java里面,m / s...
  • 四舍五入:round()——当末尾的前一位为奇数,向远离0取整;为偶数,去尾取整;或言之:奇数进位,偶数去尾 向0取整:int() float除法:/ java: 整数除法是向0取整:形如int e = -5/3; // -1 reference: ...
  • 今天看视频教程,取一个数的十位数字,公式...在java內,除法运算/的功能是有区别的: 1、如果相除的两个数都是整数,那么结果也是整数,这叫做取整除法。比如,3/2,结果是1。 2、如果其中有一个是浮点数,那么就是...
  • 安卓 java 除法取整

    千次阅读 2019-11-13 15:54:35
    我的项目需求是动态计算recyclerview的高度,每行个item,所以需要根据item的数量动态设置item高度,这就涉及到除法的问题,比如有2个item,4个item,6个item,8个item等,也就是需要得出实际的行数,比如2个只有一行...
  • java 四舍五入保留小数点后两位

    千次阅读 2020-10-10 09:55:53
    方式一: double f = 3.1516; BigDecimal b = new BigDecimal(f); double f1 = b.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue(); 输出结果f1为 3.15; 源码解读:  public BigDecimal setScale(int ...
  • import java.math.BigDecimal; /** * 数字工具类 ... * 两数相除,结果取四舍五入 * * @param v1 * @param v2 除数不能为0 * @param scale 保留几位小数 * @return */ public static dou
  • 除法运算中,当发生除不尽的情况时,可由scale参数指定精度,之后的数字四舍五入 BigDecimal b1 = new BigDecimal(Double.toString(v1)); BigDecimal b2 = new BigDecimal(Double.toString(v2)); return ...
  • java 四舍五入 精确 保留2位小数点、任意位小数点     int i=4; int j=14; float result =(float)i/j; java.text.DecimalFormat format = (java.text.DecimalFormat)java.text.DecimalFormat....
  • 除法之后向上取整和向下取整 1、向上取整 两数相除(a/b)向上取整:(a+b-1)/b,理解为a如果能将b整除则不+1,若不能整除,则+1。 例:9/2=4 向上取整:(9+2-1)/2=5; 也可以使用c++中的ceil()函数:ceil(9/2)=5 2....
  • 在实际项目中可能会遇到这种情况,当获取某记录的总条数之后,需要进行分页查询,这时就需要对总条数进行除法操作,判断一共有多少页数据,比如有110条数据,每页显示20条,一共需要6页显示,这时就需要以下操作,来...
  •  System.out.println("四舍五入取整:(2.1)=" + new BigDecimal("2.1").setScale(0, BigDecimal.ROUND_HALF_UP));   System.out.println("四舍五入取整:(2.5)=" + new BigDecimal("2.5").setScale(0, ...
  • 这就导致了: (正数是 下取整 小了)(负数是 上取整大了) 即,结果会向 0 靠拢 所以,C/Java语言的 整数除法,是使用的是: Truncate除法 即k = (a - r) / b 让(k 是 Truncate除法)成立的 前提条件,取决于: ...
  • 自己想到的方式,分享一下 int i = 1/10; int z =1%10; if(z>0) { i =i+1; }
  • 编程中的除法 编程中的除法分为三种: 向上取整:即在所有计算的结果中,取最接近+∞的那个值为最终的商。如10 ÷ (-3) = -3……1而不是10 ÷ (-3) = -4……-2。 向下取整:同理,在所有计算的结果中,取最...
  • Java除法运算(保留小数)

    万次阅读 多人点赞 2018-04-17 14:29:03
    编程的人都知道,java中的“/”、“%”运算,其中前者为取整,后者取余数。那么有没有快捷的运算方法取正常的运算结果呢?查了资料,发现很简单。代码如下: /** * TODO 除法运算,保留小数 * @author 袁忠明 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,715
精华内容 3,086
关键字:

java除法四舍五入取整

java 订阅