BigDecimal 의 용법 상세 해석(두 개의 소수,반올림,디지털 포맷,과학 계수 법 전환 숫자,숫자 속 의 쉼표 처리 유지)

11384 단어 Java면접시험
원본 링크:https://www.cnblogs.com/jpfss/p/8072379.html
프로필
    자바 가 자바.math 패키지 에서 제공 하 는 API 류 BigDecimal 은 16 비트 가 넘 는 유효 비트 의 수 를 정확하게 연산 하 는 데 사 용 됩 니 다.2 정밀도 부동 소수점 형 변수 double 은 16 비트 의 유효 수 를 처리 할 수 있다.실제 응용 에 서 는 더 크 거나 더 작은 수 를 연산 하고 처리 해 야 한다.float 와 double 은 과학적 인 계산 이나 공정 계산 에 만 사용 할 수 있 으 며,상업 계산 에 서 는 자바.math.BigDecimal 을 사용 해 야 합 니 다.BigDecimal 이 만 든 것 은 대상 입 니 다.우 리 는 전통 적 인+,-,*,/등 산술 연산 자 를 사용 하여 대상 에 대해 직접 수학 연산 을 할 수 없고 해당 하 는 방법 을 사용 해 야 합 니 다.방법 중의 매개 변수 도 반드시 BigDecimal 의 대상 이 어야 한다.구조 기 는 클래스 의 특수 한 방법 으로 대상,특히 매개 변 수 를 가 진 대상 을 만 드 는 데 사용 된다. 
2.구조 기 설명
BigDecimal(int)       매개 변수 가 지정 한 정수 치 를 가 진 대상 을 만 듭 니 다.BigDecimal(double)은 매개 변수 가 지정 한 쌍 정밀도 값 을 가 진 대상 을 만 듭 니 다.BigDecimal(long)    매개 변수 가 지정 한 긴 정수 치 를 가 진 대상 을 만 듭 니 다.BigDecimal(String)은 문자열 로 표 시 된 값 을 매개 변수 로 지정 한 대상 을 만 듭 니 다. 
방법 설명
add(BigDecimal)        BigDecimal 대상 의 값 을 더 한 다음 이 대상 으로 돌아 갑 니 다.subtract(BigDecimal)BigDecimal 대상 의 값 을 감소 시 킨 다음 이 대상 으로 돌아 갑 니 다.multiply(BigDecimal)  BigDecimal 대상 의 값 을 곱 한 다음 이 대상 으로 돌아 갑 니 다.divide(BigDecimal)     BigDecimal 대상 의 값 을 나 눈 다음 이 대상 으로 돌아 갑 니 다.toString()                BigDecimal 대상 의 수 치 를 문자열 로 변환 합 니 다.doubleValue()          BigDecimal 대상 의 값 을 이중 정밀도 로 되 돌려 줍 니 다.floatValue()             BigDecimal 대상 의 값 을 단일 정밀도 로 되 돌려 줍 니 다.longValue()             BigDecimal 대상 의 값 을 긴 정수 로 되 돌려 줍 니 다.intValue()               BigDecimal 대상 의 값 을 정수 로 되 돌려 줍 니 다.
상용 방법
4.1 두 자리 소수 유지
/** 
 *        
 */  
@org.junit.Test  
public void formatTest() {  
    double num=13.154215;  
  
    //     
    DecimalFormat df1 = new DecimalFormat("0.00");  
    String str = df1.format(num);  
    System.out.println(str);  //13.15  
  
    //     
    // #.00        #.0000      
    DecimalFormat df2 =new DecimalFormat("#.00");  
    String str2 =df2.format(num);  
    System.out.println(str2);  //13.15  
  
    //     
    //%.2f %.               2               f        
    String result = String.format("%.2f", num);  
    System.out.println(result);  //13.15  
} 

 String.formate 사용법 설명:
@Test  
public void test1() { //4.1541483776749997E9  
	double a = 4887233385.5;  
	double b = 0.85;  
	  
	System.out.println("result1-->"+a*b);  // result1-->4.1541483776749997E9  
	  
	BigDecimal a1 = new BigDecimal(a);  
	BigDecimal b1 = new BigDecimal(b);  
	  
	System.out.println("result2-->"+a1.multiply(b1));//result2-->4154148377.674999891481619       
	  
	BigDecimal aBigDecimal = new BigDecimal(String.valueOf(a));  
	BigDecimal bBigDecimal = new BigDecimal(String.valueOf(b));  
	  
	//           
//      BigDecimal aBigDecimal = new BigDecimal(Double.toString(a));  
//      BigDecimal bBigDecimal = new BigDecimal(Double.toString(b));  
  
	System.out.println("result3-->"+aBigDecimal.multiply(bBigDecimal)); //result3-->4154148377.675  

}

4.2 반올림
/** 
 *      
 */  
@Test  
public void test2() {  
    double num = 111231.5585;  
    BigDecimal b = new BigDecimal(num);  
    //  2     
    double result = b.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();  
    System.out.println(result);  //111231.56  
} 

BigDecimal.setScale()방법 은 소수점 setScale(1)을 포맷 하 는 데 사용 되 며,기본적으로 반올림 방식 을 사용 합 니 다.  setScale(1,BigDecimal.ROUND_DOWN)남 은 작은 숫자 를 직접 삭제 합 니 다.예 를 들 어 2.35 는 2.3 이 됩 니 다.  setScale(1,BigDecimal.ROUND_UP)위치 처리,2.35 에서 2.4 로 변경  setScale(1,BigDecimal.ROUND_HALF_UP)반올림,2.35 2.4
setScaler(1,BigDecimal.ROUND_HALF_DOWN)반올림,2.35 는 2.3 이 되 고,5 라면 내리 버린다.
setScaler(1,BigDecimal.ROUND_CEILING)무한대 의 반올림 에 가깝다
setScaler(1,BigDecimal.ROUND_FLOOR)마이너스 무한대 반올림,숫자>0 과 ROUND 에 가깝다.UP 역할 과 마찬가지 로 숫자<0 과 ROUNDDOWN 역할 이 똑 같 아 요.
setScaler(1,BigDecimal.ROUND_HALF_EVEN)가장 가 까 운 숫자 로 반올림 하고,인접 한 두 숫자 와 거리 가 같 으 면 인접 한 짝수 로 반올림 한다.
 
설명:
1.scale 은 소수점 뒤의 자릿수 를 가리킨다.예 를 들 어 123.456 이면 score 는 3.
score()가 바로 BigDecimal 류 중의 방법 이 군요.예 를 들 어:BigDecimal b=new BigDecimal("123.456");
b.scale(),돌아 오 는 것 은 3.
2:rounding Mode 는 소수 보존 모드 입 니 다.그것들 은 모두 BigDecimal 의 상수 필드 로 여러 가지 가 있다.예 를 들 면:BigDecimal.ROUNDHALF_UP 는 반올림 을 의미한다.3:pubilc BigDecimal division(BigDecimal divisor,int scale,int rounding Mode)은 내 가 BigDecimal 대상 을 divisor 로 나 눈 후의 결 과 를 사용 하고 이 결 과 를 scale 의 작은 숫자 로 유지 하 라 고 요구 한 다 는 뜻 이다.rounding Mode 는 보존 모드 가 무엇 인지,반올림 인지,다른 것 인지 스스로 선택 할 수 있다!
4:일반 add,subtract,multiply 방법 에 대한 작은 숫자 는 다음 과 같이 포맷 합 니 다.
BigDecimal mData = new BigDecimal("9.655").setScale(2, BigDecimal.ROUND_HALF_UP);         System.out.println("mData=" + mData);
-결과:-mData=9.66
4.3 포맷
    NumberFormat 류 의 format()방법 은 BigDecimal 대상 을 매개 변수 로 사용 할 수 있 기 때문에 BigDecimal 을 이용 하여 16 비트 이상 의 유효 숫자 를 가 진 화폐 값,백분 치,일반 수 치 를 포맷 제어 할 수 있 습 니 다.
/** 
 *     
 */  
@Test  
public void test3() {  
    NumberFormat currency = NumberFormat.getCurrencyInstance(); //           
    NumberFormat percent = NumberFormat.getPercentInstance();  //            
    percent.setMaximumFractionDigits(3); //        3   
  
    BigDecimal loanAmount = new BigDecimal("150.48"); //      
    BigDecimal interestRate = new BigDecimal("0.008"); //    
    BigDecimal interest = loanAmount.multiply(interestRate); //    
  
    System.out.println("    :\t" + currency.format(loanAmount)); //    : ¥150.48  
    System.out.println("  :\t" + percent.format(interestRate));  //  : 0.8%  
    System.out.println("  :\t" + currency.format(interest)); //  : ¥1.20  
}
@Test  
public void test3() {  
    DecimalFormat df = new DecimalFormat();  
    double data = 1234.56789; //          
  
    //1、           (         )  
    String style = "0.0";  
    df.applyPattern(style);  
    System.out.println("1-->" + df.format(data));  //1234.6  
  
    //2、               
    style = "00000.000 kg";  
    df.applyPattern(style);  
    System.out.println("2-->" + df.format(data));  //01234.568 kg  
  
  
    //3、     "#"          ,     ,     ,    。  
    style = "##000.000 kg";  
    df.applyPattern(style);  
    System.out.println("3-->" + df.format(data));  //1234.568 kg  
  
    //4、     "-"       ,        
    style = "-000.000";  
    df.applyPattern(style);  
    System.out.println("4-->" + df.format(data)); //-1234.568  
  
  
    //5、     ","        ,       
    style = "-0,000.0#";  
    df.applyPattern(style);  
    System.out.println("5-->" + df.format(data));  //5-->-1,234.57  
  
  
    //6、    "E"       ,"E"            ,  
    // "E"               
    style = "0.00E000";  
    df.applyPattern(style);  
    System.out.println("6-->" + df.format(data));  //6-->1.23E003  
  
  
    //7、     "%"    100       ,     。  
    style = "0.00%";  
    df.applyPattern(style);  
    System.out.println("7-->" + df.format(data));  //7-->123456.79%  
  
  
    //8、     "\u2030"    1000       ,     。  
    style = "0.00\u2030";  
    //              
    DecimalFormat df1 = new DecimalFormat(style);  
    //df.applyPattern(style);  
    System.out.println("8-->" + df1.format(data));  //8-->1234567.89‰  
} 

4.4 BigDecimal 비교
BigDecimal 은 compare To(BigDecimal)를 사용 하여 비교 한 것 으로 구체 적 인 비교 상황 은 다음 과 같다. 
/** 
 *       equals       。 
 * 
 *   BigDecimal       double float ,     ,          ,               。 
 */  
@Test  
public void test4() {  
    BigDecimal a = new BigDecimal("1");  
    BigDecimal b = new BigDecimal("2");  
    BigDecimal c = new BigDecimal("1");  
    int result1 = a.compareTo(b);  
    int result2 = a.compareTo(c);  
    int result3 = b.compareTo(a);  
  
    System.out.println(result1);  //-1  
    System.out.println(result2);  //0  
    System.out.println(result3);  //1  
} 

4.5 과학 계수 법
    일부 항목 은 Excel 에서 데 이 터 를 가 져 오 는 것 과 관련 이 있 을 수 있 지만 Excel 에서 셀 형식 이 수치 이지 만 내용 데이터 가 너무 길 면(예 를 들 어 은행 계좌)가 져 올 때 기본 값 으로 과학 계수 법 으로 읽 히 고 다음 코드 로 쉽게 해결 할 수 있 습 니 다.
@Test  
public void test5() {  
    BigDecimal bd = new BigDecimal("3.40256010353E11");  
    String result = bd.toPlainString();  
    System.out.println(result);  //340256010353  
} 

4.6 자바 에서 가격 의 숫자 중간 에 쉼표 처리 
@Test  
public void test1() {  
    java.util.StringTokenizer st = new StringTokenizer( "123,456,789", ",");  
    StringBuffer sb = new StringBuffer();  
    while(st.hasMoreTokens())   {  
        sb.append(st.nextToken());  
    }  
    System.out.println(sb);  //123456789  
}  
  
@Test  
public void test2() {  
    String str = "123,456,789";  
    str = str.replace(",", "");  
    System.out.println(str);  //123456789  
} 

4.7.정확 한 계산
double value1=1.00;  
String value2 = "1.00";  
BigDecimal b1 = new BigDecimal(Double.valueOf(value1));  
BigDecimal b1 = new BigDecimal(String.valueOf(value2));  
  
 public BigDecimal add(BigDecimal value);                        //    
 public BigDecimal subtract(BigDecimal value);                   //     
 public BigDecimal multiply(BigDecimal value);                   //    
 public BigDecimal divide(BigDecimal value);                     //    

다음은 도구 류 입 니 다.이 도구 류 는 더하기,빼 기,곱 하기,연산 을 제공 합 니 다.
public class Arith {  
    /** 
     *          add   
     * @param value1     
     * @param value2    
     * @return        
     */  
    public static double add(double value1,double value2){  
        BigDecimal b1 = new BigDecimal(Double.valueOf(value1));  
        BigDecimal b2 = new BigDecimal(Double.valueOf(value2));  
        return b1.add(b2).doubleValue();  
    }  
      
    /** 
     *          sub   
     * @param value1     
     * @param value2    
     * @return        
     */  
    public static double sub(double value1,double value2){  
        BigDecimal b1 = new BigDecimal(Double.valueOf(value1));  
        BigDecimal b2 = new BigDecimal(Double.valueOf(value2));  
        return b1.subtract(b2).doubleValue();  
    }  
      
    /** 
     *          mul   
     * @param value1     
     * @param value2    
     * @return        
     */  
    public static double mul(double value1,double value2){  
        BigDecimal b1 = new BigDecimal(Double.valueOf(value1));  
        BigDecimal b2 = new BigDecimal(Double.valueOf(value2));  
        return b1.multiply(b2).doubleValue();  
    }  
      
    /** 
     *            div 
     * @param value1     
     * @param value2    
     * @param scale      
     * @return        
     * @throws IllegalAccessException 
     */  
    public static double div(double value1,double value2,int scale) throws IllegalAccessException{  
        //        0,        
        if(scale<0){           
            throw new IllegalAccessException("       0");  
        }  
        BigDecimal b1 = new BigDecimal(Double.valueOf(value1));  
        BigDecimal b2 = new BigDecimal(Double.valueOf(value2));  
        return b1.divide(b2, scale).doubleValue();      
    }  
}

좋은 웹페이지 즐겨찾기