java.math.BigDecimal 加减乘除 +add -subtract ×multiply ÷divide

• .add( 加
• .subtract( 减
• .multiply( 乘
• .divide( 除

加 .add(

不指定精度

BigDecimal bigDecimal = new BigDecimal("2.718281828").add(new BigDecimal("3.14159265359"));        System.out.println(bigDecimal);

指定精度

BigDecimal bigDecimal = new BigDecimal("2.718281828").add(new BigDecimal("3.14159265359"), new MathContext(7));        System.out.println(bigDecimal);

减 .subtract(

不指定精度

new BigDecimal("2.718281828").subtract(new BigDecimal("3.14159265359"));

指定精度

new BigDecimal("2.718281828").subtract(new BigDecimal("3.14159265359"), new MathContext(7));

乘 .multiply(

不指定精度

new BigDecimal("2.718281828").multiply(new BigDecimal("3.14159265359"));

指定精度

new BigDecimal("2.718281828").multiply(new BigDecimal("3.14159265359"), new MathContext(7));

除 .divide(

不指定精度 除法最好预先指定精度,不然如果除不尽(小数位无限)时,会抛异常, 默认precision精度是0,表示无限精度

BigDecimal bigDecimal;
System.out.println("如果除不尽(小数位无限),又不指定精度偏移,就会抛异常,默认精度0表示无限");
//		bigDecimal = new BigDecimal("2.718281828").divide(new BigDecimal("3.14159265359"));        System.out.println(bigDecimal);   // 会抛异常,除不尽(小数位无限),又不指定精度偏移,就会抛异常,默认精度0表示无限
bigDecimal = new BigDecimal("2.718281828").divide(new BigDecimal("2"));        System.out.println(bigDecimal);   // 可以除尽就不抛异常

指定精度

BigDecimal bigDecimal;
System.out.println("divide除法有两种方式可以指定精度");
bigDecimal = new BigDecimal("2.718281828").divide(new BigDecimal("3.14159265359"), new MathContext(6));        System.out.println(bigDecimal);
bigDecimal = new BigDecimal("2.718281828").divide(new BigDecimal("3.14159265359"), 6, RoundingMode.HALF_UP);        System.out.println(bigDecimal);
bigDecimal = new BigDecimal("2.718281828").divide(new BigDecimal("-3.14159265359"), new MathContext(6));        System.out.println(bigDecimal);
bigDecimal = new BigDecimal("-2.718281828").divide(new BigDecimal("3.14159265359"), 6, RoundingMode.HALF_UP);        System.out.println(bigDecimal);

例1

import java.math.*;

public class TryBigDecimal2312312059 {

	public static void main(String[] args) {
        
		defPrecision默认精度();
		
		setPrecision指定精度();
		
		setPrecision指定精度_结果负数();
        
		divide除法保留66位有效数字();
		
		add加法_有精度和没精度();
        
		subtract减法_有精度和没精度();
		
		multiply乘法_有精度和没精度();
		
		divide除法_有精度和没精度();

	}
	
	public static void defPrecision默认精度() {
		System.out.println("defPrecision默认精度 👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇");
		BigDecimal bigDecimal;
		bigDecimal = new BigDecimal("2.718281828").add(new BigDecimal(1));        System.out.println(bigDecimal);
		bigDecimal = new BigDecimal("2.718281828").subtract(new BigDecimal(1));        System.out.println(bigDecimal);
		bigDecimal = new BigDecimal("2.718281828").multiply(new BigDecimal("3.14159265359"));        System.out.println(bigDecimal);
//		bigDecimal = new BigDecimal("2.718281828").divide(new BigDecimal("3.14159265359"));        System.out.println(bigDecimal);   // 会抛异常,除不尽(小数位无限),又不指定精度偏移,就会抛异常,默认精度0表示无限
		bigDecimal = new BigDecimal("2.718281828").divide(new BigDecimal("2"));        System.out.println(bigDecimal);   // 可以除尽就不抛异常
		System.out.println("👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑");
	}
	public static void setPrecision指定精度() {
		System.out.println("setPrecision指定精度 👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇");
		BigDecimal bigDecimal;
		bigDecimal = new BigDecimal(1).add(new BigDecimal("3.14159265359"), new MathContext(7));        System.out.println(bigDecimal);
        bigDecimal = new BigDecimal("2.718281828").add(new BigDecimal(1), new MathContext(7));        System.out.println(bigDecimal);
        bigDecimal = new BigDecimal("2.718281828").subtract(new BigDecimal(1), new MathContext(7));        System.out.println(bigDecimal);
        bigDecimal = new BigDecimal("2.718281828").multiply(new BigDecimal("3.14159265359"), new MathContext(7));        System.out.println(bigDecimal);
        bigDecimal = new BigDecimal("2.718281828").divide(new BigDecimal("3.14159265359"), new MathContext(6));        System.out.println(bigDecimal);
        bigDecimal = new BigDecimal("2.718281828").divide(new BigDecimal("3.14159265359"), 6, RoundingMode.HALF_UP);        System.out.println(bigDecimal);
		System.out.println("👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑");
	}
	public static void setPrecision指定精度_结果负数() {
		System.out.println("setPrecision指定精度_结果负数 👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇");
		BigDecimal bigDecimal;
		bigDecimal = new BigDecimal(1).add(new BigDecimal("-3.14159265359"), new MathContext(7));        System.out.println(bigDecimal);
        bigDecimal = new BigDecimal("-2.718281828").add(new BigDecimal(1), new MathContext(7));        System.out.println(bigDecimal);
        bigDecimal = new BigDecimal("-2.718281828").subtract(new BigDecimal(1), new MathContext(7));        System.out.println(bigDecimal);
        bigDecimal = new BigDecimal("-2.718281828").multiply(new BigDecimal("3.14159265359"), new MathContext(7));        System.out.println(bigDecimal);
        bigDecimal = new BigDecimal("2.718281828").divide(new BigDecimal("-3.14159265359"), new MathContext(6));        System.out.println(bigDecimal);
        bigDecimal = new BigDecimal("-2.718281828").divide(new BigDecimal("3.14159265359"), 6, RoundingMode.HALF_UP);        System.out.println(bigDecimal);
		System.out.println("👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑");
	}
	public static void divide除法保留66位有效数字() {
		System.out.println("divide除法保留66位有效数字 👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇");
		BigDecimal bigDecimal;
		bigDecimal = new BigDecimal(2).divide(new BigDecimal(3), 66, RoundingMode.HALF_UP);        System.out.println(bigDecimal);
        bigDecimal = new BigDecimal(2).divide(new BigDecimal(3), new MathContext(66));        System.out.println(bigDecimal);
        bigDecimal = new BigDecimal(1).divide(new BigDecimal(3), 66, RoundingMode.HALF_UP);        System.out.println(bigDecimal);
        bigDecimal = new BigDecimal(1).divide(new BigDecimal(3), new MathContext(66));        System.out.println(bigDecimal);
        bigDecimal = new BigDecimal(1).divide(new BigDecimal(6), 66, RoundingMode.HALF_UP);        System.out.println(bigDecimal);
        bigDecimal = new BigDecimal(1).divide(new BigDecimal(6), new MathContext(66));        System.out.println(bigDecimal);
        bigDecimal = new BigDecimal(-2).divide(new BigDecimal(3), 66, RoundingMode.HALF_UP);        System.out.println(bigDecimal);
        bigDecimal = new BigDecimal(-2).divide(new BigDecimal(3), new MathContext(66));        System.out.println(bigDecimal);
        bigDecimal = new BigDecimal(-1).divide(new BigDecimal(3), 66, RoundingMode.HALF_UP);        System.out.println(bigDecimal);
        bigDecimal = new BigDecimal(-1).divide(new BigDecimal(3), new MathContext(66));        System.out.println(bigDecimal);
        bigDecimal = new BigDecimal(-1).divide(new BigDecimal(6), 66, RoundingMode.HALF_UP);        System.out.println(bigDecimal);
        bigDecimal = new BigDecimal(-1).divide(new BigDecimal(6), new MathContext(66));        System.out.println(bigDecimal);
		System.out.println("👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑");
	}
	public static void add加法_有精度和没精度() {
		System.out.println("add加法_有精度和没精度 👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇");
		BigDecimal bigDecimal;
		bigDecimal = new BigDecimal("2.718281828").add(new BigDecimal("3.14159265359"));        System.out.println(bigDecimal);
		bigDecimal = new BigDecimal("2.718281828").add(new BigDecimal("3.14159265359"), new MathContext(7));        System.out.println(bigDecimal);
		System.out.println("👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑");
	}
	public static void subtract减法_有精度和没精度() {
		System.out.println("subtract减法_有精度和没精度 👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇");
		BigDecimal bigDecimal;
		bigDecimal = new BigDecimal("2.718281828").subtract(new BigDecimal("3.14159265359"));        System.out.println(bigDecimal);
		bigDecimal = new BigDecimal("2.718281828").subtract(new BigDecimal("3.14159265359"), new MathContext(7));        System.out.println(bigDecimal);
		bigDecimal = new BigDecimal("-2.718281828").subtract(new BigDecimal("3.14159265359"));        System.out.println(bigDecimal);
		bigDecimal = new BigDecimal("-2.718281828").subtract(new BigDecimal("3.14159265359"), new MathContext(7));        System.out.println(bigDecimal);
		bigDecimal = new BigDecimal("-2.718281828").subtract(new BigDecimal("-3.14159265359"));        System.out.println(bigDecimal);
		bigDecimal = new BigDecimal("-2.718281828").subtract(new BigDecimal("-3.14159265359"), new MathContext(7));        System.out.println(bigDecimal);
		System.out.println("👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑");
	}
	public static void multiply乘法_有精度和没精度() {
		System.out.println("multiply乘法_有精度和没精度 👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇");
		BigDecimal bigDecimal;
		bigDecimal = new BigDecimal("2.718281828").multiply(new BigDecimal("3.14159265359"));        System.out.println(bigDecimal);
		bigDecimal = new BigDecimal("2.718281828").multiply(new BigDecimal("3.14159265359"), new MathContext(7));        System.out.println(bigDecimal);
		System.out.println("👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑");
	}
	public static void divide除法_有精度和没精度() {
		System.out.println("divide除法_有精度和没精度 👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇");
		BigDecimal bigDecimal;
		System.out.println("如果除不尽(小数位无限),又不指定精度偏移,就会抛异常,默认精度0表示无限");
//		bigDecimal = new BigDecimal("2.718281828").divide(new BigDecimal("3.14159265359"));        System.out.println(bigDecimal);   // 会抛异常,除不尽(小数位无限),又不指定精度偏移,就会抛异常,默认精度0表示无限
		bigDecimal = new BigDecimal("2.718281828").divide(new BigDecimal("2"));        System.out.println(bigDecimal);   // 可以除尽就不抛异常
		System.out.println("divide除法有两种方式可以指定精度");
		bigDecimal = new BigDecimal("2.718281828").divide(new BigDecimal("3.14159265359"), new MathContext(6));        System.out.println(bigDecimal);
        bigDecimal = new BigDecimal("2.718281828").divide(new BigDecimal("3.14159265359"), 6, RoundingMode.HALF_UP);        System.out.println(bigDecimal);
        bigDecimal = new BigDecimal("2.718281828").divide(new BigDecimal("-3.14159265359"), new MathContext(6));        System.out.println(bigDecimal);
        bigDecimal = new BigDecimal("-2.718281828").divide(new BigDecimal("3.14159265359"), 6, RoundingMode.HALF_UP);        System.out.println(bigDecimal);
		System.out.println("👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑👆↑");
	}
	
	

}

速度测试

100精度除法,每秒可执行50万次

import java.math.*;

public class Test_BigDecimal_divideSpeed_231231 {
	
	public static void main(String[] arguments)throws Exception{
		
		m1();m2();m1();m2();m1();m2();
		m1();m2();m1();m2();m1();m2();
		m1();m2();m1();m2();m1();m2();
		
	}
	
	static int max = 50_0000;
	
	static void m1() {
		long beginning = System.currentTimeMillis();
		
		String result = null;
		
		for(int n=0; n<max; n++) {
			result = new BigDecimal("2.718281828").divide(new BigDecimal("3.14159265359"), new MathContext(100)).toString();
		}
		
		long cost = System.currentTimeMillis()-beginning;
		
		System.out.println("耗时"+cost+"毫秒, 执行了"+max+"次, 结果为:"+result);
	}
	static void m2() {
		long beginning = System.currentTimeMillis();
		
		String result = null;
		
		for(int n=0; n<max; n++) {
			result = new BigDecimal("2.718281828").divide(new BigDecimal("3.14159265359"), 100, RoundingMode.HALF_UP).toString();
		}
		
		long cost = System.currentTimeMillis()-beginning;
		
		System.out.println("耗时"+cost+"毫秒, 执行了"+max+"次, 结果为:"+result);
	}

}

AMD4800H 100精度除法,每秒可执行50万次

耗时1184毫秒, 执行了500000次, 结果为:0.8652559792860895044311167073466036472378724550479317827465393707041947845058590659816975167438419857
耗时924毫秒, 执行了500000次, 结果为:0.8652559792860895044311167073466036472378724550479317827465393707041947845058590659816975167438419857
耗时917毫秒, 执行了500000次, 结果为:0.8652559792860895044311167073466036472378724550479317827465393707041947845058590659816975167438419857
耗时914毫秒, 执行了500000次, 结果为:0.8652559792860895044311167073466036472378724550479317827465393707041947845058590659816975167438419857
耗时906毫秒, 执行了500000次, 结果为:0.8652559792860895044311167073466036472378724550479317827465393707041947845058590659816975167438419857
耗时924毫秒, 执行了500000次, 结果为:0.8652559792860895044311167073466036472378724550479317827465393707041947845058590659816975167438419857
耗时919毫秒, 执行了500000次, 结果为:0.8652559792860895044311167073466036472378724550479317827465393707041947845058590659816975167438419857
耗时918毫秒, 执行了500000次, 结果为:0.8652559792860895044311167073466036472378724550479317827465393707041947845058590659816975167438419857
耗时900毫秒, 执行了500000次, 结果为:0.8652559792860895044311167073466036472378724550479317827465393707041947845058590659816975167438419857
耗时929毫秒, 执行了500000次, 结果为:0.8652559792860895044311167073466036472378724550479317827465393707041947845058590659816975167438419857
耗时921毫秒, 执行了500000次, 结果为:0.8652559792860895044311167073466036472378724550479317827465393707041947845058590659816975167438419857
耗时901毫秒, 执行了500000次, 结果为:0.8652559792860895044311167073466036472378724550479317827465393707041947845058590659816975167438419857
耗时933毫秒, 执行了500000次, 结果为:0.8652559792860895044311167073466036472378724550479317827465393707041947845058590659816975167438419857
耗时931毫秒, 执行了500000次, 结果为:0.8652559792860895044311167073466036472378724550479317827465393707041947845058590659816975167438419857
耗时922毫秒, 执行了500000次, 结果为:0.8652559792860895044311167073466036472378724550479317827465393707041947845058590659816975167438419857
耗时918毫秒, 执行了500000次, 结果为:0.8652559792860895044311167073466036472378724550479317827465393707041947845058590659816975167438419857
耗时906毫秒, 执行了500000次, 结果为:0.8652559792860895044311167073466036472378724550479317827465393707041947845058590659816975167438419857
耗时899毫秒, 执行了500000次, 结果为:0.8652559792860895044311167073466036472378724550479317827465393707041947845058590659816975167438419857

工具类包装

工具类包装1

import java.math.*;

/**
 * 用于高精确处理常用的数学运算
 */
public class BdUtil {
    //默认除法运算精度
    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;
    }
}