【Java常用工具类】数学计算

其他工具类

【Java常用工具类】字符串

【Java常用工具类】日期类

【Java常用工具类】easyexcel基本使用演示

【Java常用工具类】集合操作常用方法

前言

数学计算比较适合流式编程风格，主要封装了double数值的加减乘除，解决精度问题，使用起来更加方便。

方法解释

1、简单的多数相加

Assert.assertEquals(10, new MathUtils(1).add(2).add(3).add(4).get(), 0.0);

2、两个数计算可直接调用静态方法

Assert.assertEquals(3, MathUtils.add(1d, 2d), 0.0);

3、计算结果取绝对值

Assert.assertEquals(1d, new MathUtils(1).add(-2).abs().get(), 0.0);

4、复杂计算 (1+2)*(3+4)

Assert.assertEquals(21, new MathUtils(1).add(2).mul(new MathUtils(3).add(4).get()).get(), 0.0);

5、复杂计算 2*3+1

Assert.assertEquals(7, new MathUtils(2).mul(3).add(1).get(), 0.0);

6、向上取整，保留两位小数

Assert.assertEquals(2.01, MathUtils.add(1.001, 1.002, 2, BigDecimal.ROUND_UP), 0.0);

7、向下取整，保留两位小数（默认配置）

Assert.assertEquals(2.0, MathUtils.add(1.001, 1.002, 2, BigDecimal.ROUND_DOWN), 0.0);

8、四舍五入，若舍弃部分 大于等于5 就进位，保留四位小数

Assert.assertEquals(2.0001, MathUtils.add(1.00004, 1.00001, 4, BigDecimal.ROUND_HALF_UP), 0.0);

9、四舍五入，若舍弃部分 大于5 就进位，保留两位小数

Assert.assertEquals(2.0, MathUtils.add(1.004, 1.001, 2, BigDecimal.ROUND_HALF_DOWN), 0.0);

10、double与BigDecimal互转

    @Test
    public void doubleToBigDecimal() {
        BigDecimal bigDecimal = MathUtils.doubleToBigDecimal(1);
        Assert.assertEquals(1d, bigDecimal.doubleValue(), 0.0);
    }
    
    @Test
    public void bigDecimalToDouble() {
        BigDecimal bigDecimal = new BigDecimal("2.1");
        double d = MathUtils.bigDecimalToDouble(bigDecimal);
        Assert.assertEquals(2.1, d, 0.0);
    }

11、double与string互转

    @Test
    public void doubleToString() {
        String str = MathUtils.doubleToString(2.1);
        Assert.assertEquals("2.1", str);
    }

    @Test
    public void stringToDouble() {
        double d = MathUtils.stringToDouble("2.1");
        Assert.assertEquals(2.1, d, 0.0);
    }

12、BigDecimal与string互转

    @Test
    public void bigDecimalToString() {
        BigDecimal bigDecimal = new BigDecimal("2.1");
        String str = MathUtils.bigDecimalToString(bigDecimal);
        Assert.assertEquals("2.1", str);
    }

    @Test
    public void stringToBigDecimal() {
        String str = "2.1";
        BigDecimal bigDecimal = MathUtils.stringToBigDecimal(str);
        Assert.assertEquals(2.1d, bigDecimal.doubleValue(), 0.0);
    }

方法代码

import java.math.BigDecimal;

public class MathUtils {

    private double val;

    private static final int DEFAULT_SCALE = 2;

    private static final int DEFAULT_ROUNDING_MODE = BigDecimal.ROUND_DOWN;

    public MathUtils(double val) {
        this.val = val;
    }

    /**
     * 直接使用 Math.abs(val)
     *
     * @return the absolute value of the argument.
     */
    public MathUtils abs() {
        val = Math.abs(val);
        return this;
    }

    /**
     * 两数之和
     *
     * @param a            an argument.
     * @param b            another argument.
     * @param scale        scale of the {@code BigDecimal} value to be returned.
     * @param roundingMode The rounding mode to apply.
     * @return double
     */
    public static double add(double a, double b, int scale, int roundingMode) {
        BigDecimal b1 = new BigDecimal(Double.toString(a));
        BigDecimal b2 = new BigDecimal(Double.toString(b));
        return b1.add(b2).setScale(scale, roundingMode).doubleValue();
    }

    /**
     * 两数之和，默认向下取整
     *
     * @param a     an argument.
     * @param b     another argument.
     * @param scale scale of the {@code BigDecimal} value to be returned.
     * @return double
     */
    public static double add(double a, double b, int scale) {
        BigDecimal b1 = new BigDecimal(Double.toString(a));
        BigDecimal b2 = new BigDecimal(Double.toString(b));
        return b1.add(b2).setScale(scale, DEFAULT_ROUNDING_MODE).doubleValue();
    }

    /**
     * 两数之和
     *
     * @param a an argument.
     * @param b another argument.
     * @return double
     */
    public static double add(double a, double b) {
        BigDecimal b1 = new BigDecimal(Double.toString(a));
        BigDecimal b2 = new BigDecimal(Double.toString(b));
        return b1.add(b2).setScale(DEFAULT_SCALE, DEFAULT_ROUNDING_MODE).doubleValue();
    }

    /**
     * 两数之和
     *
     * @param scale        scale of the {@code BigDecimal} value to be returned.
     * @param roundingMode The rounding mode to apply.
     * @return MathUtil
     */
    public MathUtils add(double value, int scale, int roundingMode) {
        BigDecimal b1 = new BigDecimal(Double.toString(val));
        BigDecimal b2 = new BigDecimal(Double.toString(value));
        val = b1.add(b2).setScale(scale, roundingMode).doubleValue();
        return this;
    }

    /**
     * 两数之和，默认向下取整
     *
     * @param scale scale of the {@code BigDecimal} value to be returned.
     * @return MathUtil
     */
    public MathUtils add(double value, int scale) {
        return add(value, scale, DEFAULT_ROUNDING_MODE);
    }

    /**
     * 两数之和，默认向下取整两位小数。
     *
     * @return MathUtil
     */
    public MathUtils add(double value) {
        return add(value, DEFAULT_SCALE);
    }

    /**
     * 两数之差
     *
     * @param a            an argument.
     * @param b            another argument.
     * @param scale        scale of the {@code BigDecimal} value to be returned.
     * @param roundingMode The rounding mode to apply.
     * @return double
     */
    public static double subtract(double a, double b, int scale, int roundingMode) {
        BigDecimal b1 = new BigDecimal(Double.toString(a));
        BigDecimal b2 = new BigDecimal(Double.toString(b));
        return b1.subtract(b2).setScale(scale, roundingMode).doubleValue();
    }

    /**
     * 两数之差，默认向下取整
     *
     * @param a     an argument.
     * @param b     another argument.
     * @param scale scale of the {@code BigDecimal} value to be returned.
     * @return double
     */
    public static double subtract(double a, double b, int scale) {
        BigDecimal b1 = new BigDecimal(Double.toString(a));
        BigDecimal b2 = new BigDecimal(Double.toString(b));
        return b1.subtract(b2).setScale(scale, DEFAULT_ROUNDING_MODE).doubleValue();
    }

    /**
     * 两数之差，默认向下取整两位小数。
     *
     * @param a an argument.
     * @param b another argument.
     * @return double
     */
    public static double subtract(double a, double b) {
        BigDecimal b1 = new BigDecimal(Double.toString(a));
        BigDecimal b2 = new BigDecimal(Double.toString(b));
        return b1.subtract(b2).setScale(DEFAULT_SCALE, DEFAULT_ROUNDING_MODE).doubleValue();
    }

    /**
     * 两数之差
     *
     * @param scale        scale of the {@code BigDecimal} value to be returned.
     * @param roundingMode The rounding mode to apply.
     * @return MathUtil
     */
    public MathUtils subtract(double value, int scale, int roundingMode) {
        BigDecimal b1 = new BigDecimal(Double.toString(val));
        BigDecimal b2 = new BigDecimal(Double.toString(value));
        val = b1.subtract(b2).setScale(scale, roundingMode).doubleValue();
        return this;
    }

    /**
     * 两数之差，默认向下取整
     *
     * @param scale scale of the {@code BigDecimal} value to be returned.
     * @return MathUtil
     */
    public MathUtils subtract(double value, int scale) {
        return subtract(value, scale, DEFAULT_ROUNDING_MODE);
    }

    /**
     * 两数之差，默认向下取整两位小数。
     *
     * @return MathUtil
     */
    public MathUtils subtract(double value) {
        return subtract(value, DEFAULT_SCALE);
    }

    /**
     * 两数相乘
     *
     * @param a            an argument.
     * @param b            another argument.
     * @param scale        scale of the {@code BigDecimal} value to be returned.
     * @param roundingMode The rounding mode to apply.
     * @return double
     */
    public static double mul(double a, double b, int scale, int roundingMode) {
        BigDecimal b1 = new BigDecimal(Double.toString(a));
        BigDecimal b2 = new BigDecimal(Double.toString(b));
        return b1.multiply(b2).setScale(scale, roundingMode).doubleValue();
    }

    /**
     * 两数相乘，默认向下取整
     *
     * @param a     an argument.
     * @param b     another argument.
     * @param scale scale of the {@code BigDecimal} value to be returned.
     * @return double
     */
    public static double mul(double a, double b, int scale) {
        BigDecimal b1 = new BigDecimal(Double.toString(a));
        BigDecimal b2 = new BigDecimal(Double.toString(b));
        return b1.multiply(b2).setScale(scale, DEFAULT_ROUNDING_MODE).doubleValue();
    }

    /**
     * 两数相乘，默认向下取整两位小数。
     *
     * @param a an argument.
     * @param b another argument.
     * @return double
     */
    public static double mul(double a, double b) {
        BigDecimal b1 = new BigDecimal(Double.toString(a));
        BigDecimal b2 = new BigDecimal(Double.toString(b));
        return b1.multiply(b2).setScale(DEFAULT_SCALE, DEFAULT_ROUNDING_MODE).doubleValue();
    }

    /**
     * 两数相乘
     *
     * @param scale        scale of the {@code BigDecimal} value to be returned.
     * @param roundingMode The rounding mode to apply.
     * @return MathUtil
     */
    public MathUtils mul(double value, int scale, int roundingMode) {
        BigDecimal b1 = new BigDecimal(Double.toString(val));
        BigDecimal b2 = new BigDecimal(Double.toString(value));
        val = b1.multiply(b2).setScale(scale, roundingMode).doubleValue();
        return this;
    }

    /**
     * 两数相乘，默认向下取整
     *
     * @param scale scale of the {@code BigDecimal} value to be returned.
     * @return MathUtil
     */
    public MathUtils mul(double value, int scale) {
        return mul(value, scale, DEFAULT_ROUNDING_MODE);
    }

    /**
     * 两数相乘，默认向下取整两位小数。
     *
     * @return MathUtil
     */
    public MathUtils mul(double value) {
        return mul(value, DEFAULT_SCALE);
    }

    /**
     * 两数相除
     *
     * @param a            an argument.
     * @param b            another argument.
     * @param scale        scale of the {@code BigDecimal} value to be returned.
     * @param roundingMode The rounding mode to apply.
     * @return double
     */
    public static double divide(double a, double b, int scale, int roundingMode) {
        BigDecimal b1 = new BigDecimal(Double.toString(a));
        BigDecimal b2 = new BigDecimal(Double.toString(b));
        return b1.divide(b2, scale, roundingMode).doubleValue();
    }

    /**
     * 两数相除，默认向下取整
     *
     * @param a     an argument.
     * @param b     another argument.
     * @param scale scale of the {@code BigDecimal} value to be returned.
     * @return double
     */
    public static double divide(double a, double b, int scale) {
        BigDecimal b1 = new BigDecimal(Double.toString(a));
        BigDecimal b2 = new BigDecimal(Double.toString(b));
        return b1.divide(b2, scale, DEFAULT_ROUNDING_MODE).doubleValue();
    }

    /**
     * 两数相除，默认向下取整两位小数。
     *
     * @param a an argument.
     * @param b another argument.
     * @return double
     */
    public static double divide(double a, double b) {
        BigDecimal b1 = new BigDecimal(Double.toString(a));
        BigDecimal b2 = new BigDecimal(Double.toString(b));
        return b1.divide(b2, DEFAULT_SCALE, DEFAULT_ROUNDING_MODE).doubleValue();
    }

    /**
     * 两数相除
     *
     * @param scale        scale of the {@code BigDecimal} value to be returned.
     * @param roundingMode The rounding mode to apply.
     * @return MathUtil
     */
    public MathUtils divide(double value, int scale, int roundingMode) {
        BigDecimal b1 = new BigDecimal(Double.toString(val));
        BigDecimal b2 = new BigDecimal(Double.toString(value));
        val = b1.divide(b2, scale, roundingMode).doubleValue();
        return this;
    }

    /**
     * 两数相除，默认向下取整
     *
     * @param scale scale of the {@code BigDecimal} value to be returned.
     * @return MathUtil
     */
    public MathUtils divide(double value, int scale) {
        return divide(value, scale, DEFAULT_ROUNDING_MODE);
    }

    /**
     * 两数相除，默认向下取整两位小数。
     *
     * @return MathUtil
     */
    public MathUtils divide(double value) {
        return divide(value, DEFAULT_SCALE);
    }

    /**
     * double 转 BigDecimal
     *
     * @param a an argument.
     * @return BigDecimal
     */
    public static BigDecimal doubleToBigDecimal(double a) {
        return new BigDecimal(Double.toString(a));
    }

    /**
     * BigDecimal 转 double
     *
     * @param bigDecimal an argument.
     * @return an argument.
     */
    public static double bigDecimalToDouble(BigDecimal bigDecimal) {
        return bigDecimal.doubleValue();
    }

    /**
     * BigDecimal 转 String
     *
     * @param bigDecimal an argument.
     * @return String
     */
    public static String bigDecimalToString(BigDecimal bigDecimal) {
        return bigDecimal.toString();
    }

    /**
     * String 转 BigDecimal
     *
     * @param s an argument.
     * @return BigDecimal
     */
    public static BigDecimal stringToBigDecimal(String s) {
        return new BigDecimal(s);
    }

    /**
     * double 转 String
     *
     * @param a an argument.
     * @return String
     */
    public static String doubleToString(double a) {
        return new BigDecimal(Double.toString(a)).toString();
    }

    /**
     * String 转 double
     *
     * @param s an argument.
     * @return double
     */
    public static double stringToDouble(String s) {
        return new BigDecimal(s).doubleValue();
    }

    /**
     * 获取val的值
     *
     * @return val
     */
    public double get() {
        return val;
    }
}