자바 에서 BigDecimal 류 의 정확 한 사 칙 연산 도구 류 Arith

더 읽 기
효과   자바 라 는 책 에서 도 이 원칙 을 언급 했다.float 와 double 은 과학적 계산 이나 공정 계산 에 만 사용 할 수 있 고 상업 계산 에서 우 리 는 자바.math.BigDecimal 을 사용 해 야 한다.
BigDecimal 을 사용 하고 String 으로 만들어 야 합 니 다.   하지만 상상 해 보 세 요.만약 에 우리 가 덧셈 연산 을 하려 면 두 개의 부동 점 수 를 String 으로 바 꾼 다음 에 BigDecimal 을 만 들 수 있 습 니 다.그 중 하 나 는 add 방법 을 호출 하여 다른 하 나 를 매개 변수 로 한 다음 에 연산 결과(BigDecimal)를 부동 소수점 으로 바 꿔 야 합 니 다.너 는 이렇게 번 거 로 운 과정 을 참 을 수 있 니?다음은 도구 류 Arith 를 제공 하여 조작 을 간소화 합 니 다.이것 은 가감 승제 와 반올림 을 포함 하여 다음 과 같은 정적 방법 을 제공 합 니 다.   public   static   double   add(double   v1,double   v2)   public   static   double   sub(double   v1,double   v2)   public   static   double   mul(double   v1,double   v2)   public   static   double   div(double   v1,double   v2)   public   static   double   div(double   v1,double   v2,int   scale)   public   static   double   round(double   v,int   scale)  

import java.math.BigDecimal;    
  
/**  
 *   BigDecimal       ，             
 * @author ameyume  
 *  
 */  
public class Arith {    
  
    /**   
    *   Java                   ，           
    *        ，           。   
    */    
    //            
    private static final int DEF_DIV_SCALE = 10;    
           
    //            
    private Arith(){    
    }    
  
    /**   
     *          。   
     * @param v1       
     * @param v2      
     * @return          
     */    
    public static double add(double v1,double v2){    
        BigDecimal b1 = new BigDecimal(Double.toString(v1));    
        BigDecimal b2 = new BigDecimal(Double.toString(v2));    
        return b1.add(b2).doubleValue();    
    }    
       
    /**   
     *          。   
     * @param v1       
     * @param v2      
     * @return          
     */    
    public static double sub(double v1,double v2){    
        BigDecimal b1 = new BigDecimal(Double.toString(v1));    
        BigDecimal b2 = new BigDecimal(Double.toString(v2));    
        return b1.subtract(b2).doubleValue();    
    }    
       
    /**   
     *          。   
     * @param v1       
     * @param v2      
     * @return          
     */    
    public static double mul(double v1,double v2){    
        BigDecimal b1 = new BigDecimal(Double.toString(v1));    
        BigDecimal b2 = new BigDecimal(Double.toString(v2));    
        return b1.multiply(b2).doubleValue();    
    }    
  
    /**   
     *   （  ）       ，          ，      
     *      10 ，         。   
     * @param v1       
     * @param v2      
     * @return          
     */    
    public static double div(double v1,double v2){    
        return div(v1,v2,DEF_DIV_SCALE);    
    }    
  
    /**   
     *   （  ）       。          ， scale      
     *    ，         。   
     * @param v1       
     * @param v2      
     * @param scale                 。   
     * @return          
     */    
    public static double div(double v1,double v2,int scale){    
        if(scale<0){    
            throw new IllegalArgumentException(    
                "The scale must be a positive integer or zero");    
        }    
        BigDecimal b1 = new BigDecimal(Double.toString(v1));    
        BigDecimal b2 = new BigDecimal(Double.toString(v2));    
        return b1.divide(b2,scale,BigDecimal.ROUND_HALF_UP).doubleValue();    
    }    
  
    /**   
     *               。   
     * @param v             
     * @param scale            
     * @return            
     */    
    public static double round(double v,int scale){    
        if(scale<0){    
            throw new IllegalArgumentException(    
                "The scale must be a positive integer or zero");    
        }    
        BigDecimal b = new BigDecimal(Double.toString(v));    
        BigDecimal one = new BigDecimal("1");    
        return b.divide(one,scale,BigDecimal.ROUND_HALF_UP).doubleValue();    
    }    
       
   /**   
    *          (Float)   
    * @param v            
    * @return          
    */    
    public static float convertsToFloat(double v){    
        BigDecimal b = new BigDecimal(v);    
        return b.floatValue();    
    }    
       
    /**   
    *          (Int)          
    * @param v            
    * @return          
    */    
    public static int convertsToInt(double v){    
        BigDecimal b = new BigDecimal(v);    
        return b.intValue();    
    }    
  
    /**   
    *          (Long)   
    * @param v            
    * @return          
    */    
    public static long convertsToLong(double v){    
        BigDecimal b = new BigDecimal(v);    
        return b.longValue();    
    }    
  
    /**   
    *               
    * @param v1              
    * @param v2              
    * @return               
    */    
    public static double returnMax(double v1,double v2){    
        BigDecimal b1 = new BigDecimal(v1);    
        BigDecimal b2 = new BigDecimal(v2);    
        return b1.max(b2).doubleValue();    
    }    
  
    /**   
    *               
    * @param v1              
    * @param v2              
    * @return               
    */    
    public static double returnMin(double v1,double v2){    
        BigDecimal b1 = new BigDecimal(v1);    
        BigDecimal b2 = new BigDecimal(v2);    
        return b1.min(b2).doubleValue();    
    }    
  
    /**   
    *            
    * @param v1              
    * @param v2              
    * @return           0，               1，    -1   
    */    
        public static int compareTo(double v1,double v2){    
        BigDecimal b1 = new BigDecimal(v1);    
        BigDecimal b2 = new BigDecimal(v2);    
        return b1.compareTo(b2);    
    }   
  
}