java Round双精度数据类型最多3位

Question

我试图计算一个代表利率的字段的值，我必须将该值四舍五入到3位

下面是我正在使用的代码：

double bigAmt1 = Double.parseDouble(amount);
            bigAmt = (intsign*bigAmt1)/div;
            
        bigAmt=Math.round(bigAmt*1000d)/1000d;

amount = 4048500
intsign = 1
div = 6

它返回=4.048 我需要它返回=4.049

如果我将amount的值改为4048600，那么它返回4.049，所以我认为它是对除法后最后一位大于5的值进行四舍五入，但如果最后一位等于或大于5，那么它应该四舍五入到下一位

下面是我的测试课--

package test;

import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;
import java.text.DecimalFormat;

public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println(divideAndConvertToString1("4048100","6","1"));
        //System.out.println("---> 3 places  "+Math.round(3.5));
        //Math.round(3.7)
        /*double value = 12.3457652133;
        value =Double.parseDouble(new DecimalFormat("##.####").format(value));
        System.out.println("---> 3 places  "+value);*/
    }
    
    public static String divideAndConvertToString(String amount, String decml, String sign) {

        double bigAmt = 0.00;
        
        int div = 0;
        
        double d =0;
        
        if (!isStringEmpty(decml)) {
          d = Double.parseDouble(decml);
        }
        
        double d1 = Math.pow(10, d);
        div = (int)d1;              
        
        int intsign = Integer.parseInt(sign);
        
        if (amount != null && !"".equalsIgnoreCase(amount)) {
            //BigDecimal bigAmt1 = new BigDecimal(amount);
            
            double bigAmt1 = Double.parseDouble(amount);
            bigAmt = (intsign*bigAmt1)/div;         
            bigAmt=Math.ceil(bigAmt*1000d)/1000d;
            
            //bigAmt = new BigDecimal((intsign*bigAmt1.doubleValue())/div);
            
            return  String.valueOf(bigAmt);
                        
        }
        else {
            bigAmt = bigAmt;
        }
        System.out.println("inside divideAndConvertToString");
        return String.valueOf(bigAmt);
        
    }
    
    
     public static String divideAndConvertToString1(String amount, String decml, String sign) {

         BigDecimal bigAmt = null;
            
            int div = 0;
            
            double d =0;
            
            if (!Util.isStringEmpty(decml)) {
              d = Double.parseDouble(decml);
            }
            
            double d1 = Math.pow(10, d);
            div = (int)d1;              
            
            int intsign = Integer.parseInt(sign);
            
            if (amount != null && !"".equalsIgnoreCase(amount)) {
                BigDecimal bigAmt1 = new BigDecimal(amount);

                bigAmt = new BigDecimal((intsign*bigAmt1.doubleValue())/div);
            }
            else {
                bigAmt = new BigDecimal("0");
            }
            System.out.println("inside divideAndConvertToString1");

            return String.valueOf(bigAmt.setScale(3, RoundingMode.CEILING));
            
            //System.out.println(b.setScale(0, RoundingMode.CEILING)); 
            
        }
     
     public static boolean isStringEmpty(String input) {
            if (input == null || input.trim().length() == 0 || "".equalsIgnoreCase(input)) {
                return true;
            }
            return false;
        }

}

Answer 1

Math.round应该可以工作，但我通常这样做：

bigAmt=Math.floor((bigAmt*1000d)+0.5d)/1000d;

但你的问题在别处：

bigAmt1 = Double.parseDouble(amount);
bigAmt = (intsign*bigAmt1)/div;
bigAmt=Math.round(bigAmt*1000d)/1000d;

因此，利用你的价值观：

amount = 4048500
intsign = 1
div = 6

bigAmt1 = 4048500;
bigAmt = (1*4048500)/6 = 674750;
bigAmt=   round(674750*1000)/1000 = round(674750000)/1000 = 674750;

然而，在您的示例中，您写道：it returns = 4.048 I need it return = 4.049那么您有相同的div值吗？ 如果div为1000000，则：

bigAmt1 = 4048500;
bigAmt = (1*4048500)/1000000 = 4.048500;
bigAmt=   round(4.048500*1000)/1000 = round(4048.500)/1000 = 4.049;

但是有一个大问题，因为浮点可能会将4.048500数字四舍五入为类似4.048499999999的值。直接使用整数舍入更安全：

1000* ((amount+500)/1000)
1000* ((4048500+500)/1000)
1000* ((4049000    )/1000)
1000* (4049)
       4049000

所以，将舍入值的一半相加，除以舍入值，然后乘以舍入值。所有这些都是在整数上完成的

Answer 2

你为什么不使用Math.ceil()，而不是Math.round()，我想这就是它的用途