자바 사용 BigDecimal 클래스 처리 고밀도 계산

18898 단어 【JAVA】Android 개발 및 기술 탐색
자바 가 자바.math 패키지 에서 제공 하 는 API 류 BigDecimal 은 16 비트 가 넘 는 유효 비트 의 수 를 정확하게 연산 하 는 데 사 용 됩 니 다.2 정밀도 부동 소수점 형 변수 double 은 16 비트 의 유효 수 를 처리 할 수 있 으 나 실제 응용 에 서 는 더 크 거나 더 작은 수 를 연산 하고 처리 해 야 할 수 있 습 니 다.일반적으로 정밀 도 를 정확하게 계산 할 필요 가 없 는 숫자 에 대해 서 는 Float 와 Double 처 리 를 직접 사용 할 수 있 지만 Double.valueOf(String)와 Float.valueOf(String)는 정밀 도 를 잃 게 됩 니 다.그래서 개발 중 에 만약 에 우리 가 정확하게 계산 한 결과 가 필요 하 다 면 반드시 BigDecimal 류 를 사용 하여 조작 해 야 합 니 다!
(1)BigDecimal 류 가 자주 사용 하 는 몇 가지 구조 방법
  • BigDecimal(int):int 표시 형식 을 BigDecimal 대상 으로 전환한다
  • BigDecimal(String):문자열 표시 형식 을 BigDecimal 대상 으로 변환 합 니 다
  • BigDecimal(double):double 표시 형식 을 BigDecimal 대상 으로 전환한다
    • (2)BigDecimal 류 의 상용 방법
  • add(BigDecimal):BigDecimal 대상 의 값 을 더 하면 BigDecimal 대상 으로 돌아 갑 니 다
  • subtract(BigDecimal):BigDecimal 대상 의 값 이 감소 하여 BigDecimal 대상 으로 되 돌아 갑 니 다
  • multiply(BigDecimal):BigDecimal 대상 의 값 을 곱 하여 BigDecimal 대상 에 게 되 돌려 줍 니 다
  • divide(BigDecimal):BigDecimal 대상 의 값 을 나 누 어 BigDecimal 대상 으로 되 돌려 줍 니 다
    • toString():BigDecimal 대상 의 값 을 문자열 로 변환 합 니 다
  • doubleValue():BigDecimal 대상 의 값 을 쌍 정밀도 로 변환 합 니 다
  • floatValue():BigDecimal 대상 의 값 을 단일 정밀도 로 변환 합 니 다
  • longValue():BigDecimal 대상 의 값 을 성장 정수 로 변환 합 니 다
  • intValue():BigDecimal 대상 의 값 을 정수 로 변환 합 니 다
    • 다음은 자주 사용 되 는 수학 연산 류 를 정확하게 처리 하 는 데 사용 된다.
    package com.per.test;

import java.math.BigDecimal;

/**
 *               
 * Created by lijuan on 2016/8/27.
 */
public class ArithmeticUtils {
    //        
    private static final int DEF_DIV_SCALE = 10;

    /**
     *          
     *
     * @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 BigDecimal add(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.add(b2);
    }

    /**
     *          
     *
     * @param v1       
     * @param v2      
     * @param scale   scale    
     * @return       
     */
    public static String add(String v1, String v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.add(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    }

    /**
     *          
     *
     * @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 BigDecimal sub(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.subtract(b2);
    }

    /**
     *          
     *
     * @param v1       
     * @param v2      
     * @param scale   scale    
     * @return       
     */
    public static String sub(String v1, String v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.subtract(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    }

    /**
     *          
     *
     * @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();
    }

    /**
     *          
     *
     * @param v1    
     * @param v2   
     * @return       
     */
    public static BigDecimal mul(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.multiply(b2);
    }


    /**
     *          
     *
     * @param v1       
     * @param v2      
     * @param scale   scale    
     * @return       
     */
    public static double mul(double v1, double v2, int scale) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return round(b1.multiply(b2).doubleValue(), scale);
    }

    /**
     *          
     *
     * @param v1       
     * @param v2      
     * @param scale   scale    
     * @return       
     */
    public static String mul(String v1, String v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.multiply(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    }

    /**
     *   （  ）       ，          ，   
     *      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();
    }

    /**
     *   （  ）       。          ， scale   
     *    ，         
     *
     * @param v1       
     * @param v2      
     * @param scale               
     * @return       
     */
    public static String div(String v1, String v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException("The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v1);
        return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).toString();
    }

    /**
     *               
     *
     * @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));
        return b.setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    /**
     *               
     *
     * @param v              
     * @param scale         
     * @return         
     */
    public static String round(String v, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b = new BigDecimal(v);
        return b.setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    }


    /**
     *    
     *
     * @param v1       
     * @param v2      
     * @param scale         
     * @return   
     */
    public static String remainder(String v1, String v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.remainder(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    }

    /**
     *      BigDecimal
     *
     * @param v1       
     * @param v2      
     * @param scale         
     * @return   
     */
    public static BigDecimal remainder(BigDecimal v1, BigDecimal v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        return v1.remainder(v2).setScale(scale, BigDecimal.ROUND_HALF_UP);
    }

    /**
     *     
     *
     * @param v1     
     * @param v2    
     * @return   v1   v2     true   false
     */
    public static boolean compare(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        int bj = b1.compareTo(b2);
        boolean res;
        if (bj > 0)
            res = true;
        else
            res = false;
        return res;
    }
}

    자,이 글 은 이렇게 되 었 습 니 다.잘못된 부분 이 있 으 면 지 도 를 바 랍 니 다.감사합니다^ ^
    참고 문헌:자바 처리 고밀도 계산
    2016 년 11 월 문제 기록 과 총화
    hadop fs-count 의 결과 적 의미

    좋은 웹페이지 즐겨찾기

    개발자 우수 사이트 수집

    개발자가 알아야 할 필수 사이트 100선 추천 우리는 당신을 위해 100개의 자주 사용하는 개발자 학습 사이트를 정리했습니다
    best100-homepage