Java浮点数除法，整数除得小数，指定小数位数

雨点打透心脏的1/2处 2022-05-16 00:11 547阅读 0赞

在Java中如果除运算符“/”，在不加任何限制的情况下，两个整数相除，得到的是整数，小数点后的被舍弃。但是有些场景下我们需要拿到除得的小数，还要指定位数的小数。这时候有以下处理方法：

1.使用DecimalFormat来限定得到的小数位数

int pcm = 98;
                int fcm = 11;
    
                DecimalFormat df = new DecimalFormat("0.00");
                
                double tmpVal = Double.parseDouble(df.format((double) pcm/(pcm+fcm))); 
                //get value 0.89

注意，它默认返回的是String，如果需要double/float要做一下转换。

2.直接使用Decimal运算

@Test
    	public void testDecimalOper(){
    		int pcm = 94;
    		int fcm = 11;
    
    		BigDecimal pcmbd = new BigDecimal(pcm);
    		BigDecimal fcmbd = new BigDecimal(fcm);
    
    		BigDecimal rate = new BigDecimal(0.00);
    		rate = pcmbd.divide(pcmbd.add(fcmbd), 2, RoundingMode.HALF_UP);
    		System.out.println(rate);//0.90
    	}

> float/double在工程运算中使用的比较多，在商业计算中使用Decimal类型的比较多。（*注：*
> 
> *在《Effective Java》这本书中也提到这个原则，float和double只能用来做科学计算或者是工程计算，在商业计算中我们要用 java.math.BigDecimal，另外，我们如果需要精确计算，要用String来够造BigDecimal。在《Effective Java》一书中的例子是用String来够造BigDecimal的。（注意：divide方法中推荐使用枚举RoundingMode.HALF\_UP*）

）

两种方式都可以。推荐使用第二种方式来处理精度和round mode的设置。

附BigDecimal rouding mode:

/**
     * Rounding mode to round away from zero.  Always increments the
     * digit prior to a nonzero discarded fraction.  Note that this rounding
     * mode never decreases the magnitude of the calculated value.
     */
    public final static int ROUND_UP =           0;
    
    /**
     * Rounding mode to round towards zero.  Never increments the digit
     * prior to a discarded fraction (i.e., truncates).  Note that this
     * rounding mode never increases the magnitude of the calculated value.
     */
    public final static int ROUND_DOWN =         1;
    
    /**
     * Rounding mode to round towards positive infinity.  If the
     * {@code BigDecimal} is positive, behaves as for
     * {@code ROUND_UP}; if negative, behaves as for
     * {@code ROUND_DOWN}.  Note that this rounding mode never
     * decreases the calculated value.
     */
    public final static int ROUND_CEILING =      2;
    
    /**
     * Rounding mode to round towards negative infinity.  If the
     * {@code BigDecimal} is positive, behave as for
     * {@code ROUND_DOWN}; if negative, behave as for
     * {@code ROUND_UP}.  Note that this rounding mode never
     * increases the calculated value.
     */
    public final static int ROUND_FLOOR =        3;
    
    /**
     * Rounding mode to round towards {@literal "nearest neighbor"}
     * unless both neighbors are equidistant, in which case round up.
     * Behaves as for {@code ROUND_UP} if the discarded fraction is
     * ≥ 0.5; otherwise, behaves as for {@code ROUND_DOWN}.  Note
     * that this is the rounding mode that most of us were taught in
     * grade school.
     */
    public final static int ROUND_HALF_UP =      4;
    
    /**
     * Rounding mode to round towards {@literal "nearest neighbor"}
     * unless both neighbors are equidistant, in which case round
     * down.  Behaves as for {@code ROUND_UP} if the discarded
     * fraction is {@literal >} 0.5; otherwise, behaves as for
     * {@code ROUND_DOWN}.
     */
    public final static int ROUND_HALF_DOWN =    5;
    
    /**
     * Rounding mode to round towards the {@literal "nearest neighbor"}
     * unless both neighbors are equidistant, in which case, round
     * towards the even neighbor.  Behaves as for
     * {@code ROUND_HALF_UP} if the digit to the left of the
     * discarded fraction is odd; behaves as for
     * {@code ROUND_HALF_DOWN} if it's even.  Note that this is the
     * rounding mode that minimizes cumulative error when applied
     * repeatedly over a sequence of calculations.
     */
    public final static int ROUND_HALF_EVEN =    6;
    
    /**
     * Rounding mode to assert that the requested operation has an exact
     * result, hence no rounding is necessary.  If this rounding mode is
     * specified on an operation that yields an inexact result, an
     * {@code ArithmeticException} is thrown.
     */
    public final static int ROUND_UNNECESSARY =  7;