Java & JavaScript 数字处理

java.lang.Math

java.lang.Math提供了一系列静态方法用于科学计算；其方法的参数和返回值类型一般为double型。

abs()
    返回绝对值
ceil()
    返回一个大于等于操作数的最近整数值
    Math.ceil(8.3); //9.0
    Math.ceil(9.0); //9.0
floor()
    返回一个小于等于操作数的最近整数值
    Math.floor(8.7); //8.0
    Math.floor(9.0); //9.0
max()
    返回两个操作数的最大一个
    Math.max(1,2);
min()
    返回两个操作数的最小一个
    Math.min(1,2);
random()
    返回大于等于0.0小于1.0的随机double型
round()
    返回最接近操作数的整数(四舍五入)
toRadians()
    转换为弧度
    Math.toRadians(90.0); //1.57079...
sin()
    返回给定角度的正弦,操作数是double型
    Math.sin(Math.toRadians(90.0)); //求90度角的正弦值,返回1.0
cos()
    返回给定角度的余弦,操作数是double型
    Math.cos(Math.toRadians(0.0)); //求0度角的余弦值,返回1.0
tan()
    返回给定角度的正切,操作数是double型
    Math.tan(Math.toRadians(45.0)); //求45度角的正切值,返回1.0
sqrt()
    返回给定值的平方根,,操作数是double型
    Math.sqrt(4.0); //2.0
    Math.sqrt(-4.0); //Nan
toDegrees()
    返回给定弧度的角度值
    Math.toDegrees(Math.PI*0.5); //90.0

 

java.math.BigDecimal

一般的Float类和Double类可以用来做科学计算或工程计算，但在商业计算中，要求数字精度比较高，故用到java.math.BigDecimal类。BigDecimal类支持任何精度的定点数。

BigDecimal构造方法

// 将double表示形式转换为BigDecimal *不建议使用
public BigDecimal(double val) 

// 将int表示形式转换成BigDecimal
public BigDecimal(int val)　　

// 将String表示形式转换成BigDecimal
public BigDecimal(String val)　　

 

当double必须用作BigDecimal的源时，请使用Double.toString(double)转成String，然后使用String构造方法，或使用BigDecimal的静态方法valueOf：BigDecimal bDouble1 = BigDecimal.valueOf(2.3);

BigDecimal加减乘除运算

//加法
public BigDecimal add(BigDecimal value);
System.out.println("a + b =" + a.add(b));
//减法 
public BigDecimal subtract(BigDecimal value);
System.out.println("a - b =" + a.subtract(b));
//乘法
public BigDecimal multiply(BigDecimal value);
System.out.println("a * b =" + a.multiply(b));
//除法
public BigDecimal divide(BigDecimal value);
System.out.println("a / b =" + a.divide(b));

 

divide方法有可以传三个参数：

public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode) 

 

第一参数表示除数， 第二个参数表示小数点后保留位数，
第三个参数表示舍入模式，只有在作除法运算或四舍五入时才用到舍入模式，有下面这几种：

ROUND_CEILING	向正无穷方向舍入
ROUND_DOWN	向零方向舍入
ROUND_FLOOR	向负无穷方向舍入
ROUND_HALF_DOWN	向（距离）最近的一边舍入，除非两边（的距离）是相等,如果是这样，向下舍入, 例如1.55 保留一位小数结果为1.5
ROUND_HALF_EVEN	向（距离）最近的一边舍入，除非两边（的距离）是相等,如果是这样， 如果保留位数是奇数，使用ROUND_HALF_UP，如果是偶数，使用ROUND_HALF_DOWN
ROUND_HALF_UP	向（距离）最近的一边舍入，除非两边（的距离）是相等,如果是这样，向上舍入, 1.55保留一位小数结果为1.6
ROUND_UNNECESSARY	计算结果是精确的，不需要舍入模式
ROUND_UP	向远离0的方向舍入

DecimalFormat 数字格式化

double pi = 3.1415927; //圆周率
// 取一位整数
System.out.println(new DecimalFormat("0").format(pi)); //3
// 取一位整数和两位小数
System.out.println(new DecimalFormat("0.00").format(pi)); //3.14
// 取两位整数和三位小数，整数不足部分以0填补。
System.out.println(new DecimalFormat("00.000").format(pi)); // 03.142
// 取所有整数部分
System.out.println(new DecimalFormat("#").format(pi)); //3
// 以百分比方式计数，并取两位小数
System.out.println(new DecimalFormat("#.##%").format(pi)); //314.16%

 

 四舍五入

需要对BigDecimal进行截断和四舍五入可用setScale方法，例：

BigDecimal a = new BigDecimal("4.5635");
a = a.setScale(3, RoundingMode.HALF_UP);    //保留3位小数，且四舍五入
System.out.println(a);

 

注意：

尽量使用参数类型为String的构造函数。

BigDecimal都是不可变的（immutable）的，在进行每一步运算时，都会产生一个新的对象，所以在做加减乘除运算时千万要保存操作后的值。

 

JavaScript 数字处理

加法函数，用来得到精确的加法结果

function accAdd(arg1, arg2) {
    var r1, r2, m, c;
    try {
        r1 = arg1.toString().split(".")[1].length;
    } catch (e) {
        r1 = 0;
    }
    try {
        r2 = arg2.toString().split(".")[1].length;
    } catch (e) {
        r2 = 0;
    }
    c = Math.abs(r1 - r2);
    m = Math.pow(10, Math.max(r1, r2));
    if (c > 0) {
        var cm = Math.pow(10, c);
        if (r1 > r2) {
            arg1 = Number(arg1.toString().replace(".", ""));
            arg2 = Number(arg2.toString().replace(".", "")) * cm;
        } else {
            arg1 = Number(arg1.toString().replace(".", "")) * cm;
            arg2 = Number(arg2.toString().replace(".", ""));
        }
    } else {
        arg1 = Number(arg1.toString().replace(".", ""));
        arg2 = Number(arg2.toString().replace(".", ""));
    }
    return (arg1 + arg2) / m;
}

 

减法函数，用来得到精确的减法结果

function accSub (arg1, arg2) {
    var r1, r2, m, n
    if (arg1.toString().split('.').length > 1) {
        r1 = arg1.toString().split('.')[1].length
    } else {
        r1 = 0
    }
    if (arg2.toString().split('.') > 1) {
        r2 = arg2.toString().split('.')[1].length
    } else {
        r2 = 0
    }
    m = Math.pow(10, Math.max(r1, r2))
    n = (r1 >= r2) ? r1 : r2
    return ((arg1 * m - arg2 * m) / m).toFixed(n)
}

 

乘法函数，用来得到精确的乘法结果

function accMul(arg1, arg2) {
    var m = 0,
    s1 = arg1.toString(),
    s2 = arg2.toString();
    try {
        m += s1.split(".")[1].length;
    } catch (e) {}
    try {
        m += s2.split(".")[1].length;
    } catch (e) {}
    return Number(s1.replace(".", "")) * Number(s2.replace(".", "")) / Math.pow(10, m);
}

 

除法函数，用来得到精确的除法结果

function accDiv(arg1, arg2) {
    var t1 = 0,t2 = 0,r1, r2;
    try {
        t1 = arg1.toString().split(".")[1].length;
    } catch (e) {}
    try {
        t2 = arg2.toString().split(".")[1].length;
    } catch (e) {}
    with(Math) {
        r1 = Number(arg1.toString().replace(".", ""));
        r2 = Number(arg2.toString().replace(".", ""));
        return (r1 / r2) * pow(10, t2 - t1);
    }
}

 

保留小数位数，返回字符串（str 数值 precision位数）

myRoundStr: function (srcStr, nAfterDot) {
    let resultStr, nTen
    srcStr = '' + srcStr + ''
    const strLen = srcStr.length
    const dotPos = srcStr.indexOf('.', 0)
    if (dotPos == -1) {
        resultStr = srcStr + '.'
        for (let i = 0; i < nAfterDot; i++) {
            resultStr = resultStr + '0'
        }
        return resultStr
    } else {
    if ((strLen - dotPos - 1) >= nAfterDot) {
        nTen = 1
        for (let j = 0; j < nAfterDot; j++) {
            nTen = nTen * 10
        }
        resultStr = Math.round(parseFloat(srcStr) * nTen) / nTen
        return resultStr
    } else {
        resultStr = srcStr
        for (let i = 0; i < (nAfterDot - strLen + dotPos + 1); i++) {
            resultStr = resultStr + '0'
        }
        return resultStr
        }
    }
}

 

分转元（srcStr金额  nAfterDot保留几位小数）

branchFenToYuan: function (srcStr, nAfterDot) {
    if (srcStr == null || isNaN(srcStr )) {
        return '0.00'
    }
    let resultStr, nTen
    srcStr = srcStr / 100
    srcStr = '' + srcStr + ''
    const strLen = srcStr.length
    const dotPos = srcStr.indexOf('.', 0)
    if (dotPos == -1) {
        resultStr = srcStr + '.'
        for (let i = 0; i < nAfterDot; i++) {
            resultStr = resultStr + '0'
        }
        return resultStr
    } else {
        if ((strLen - dotPos - 1) >= nAfterDot) {
            nTen = 1
            for (let j = 0; j < nAfterDot; j++) {
                nTen = nTen * 10
        }
        resultStr = Math.round(parseFloat(srcStr) * nTen) / nTen
        return resultStr
    } else {
        resultStr = srcStr
        for (let i = 0; i < (nAfterDot - strLen + dotPos + 1); i++) {
            resultStr = resultStr + '0'
        }
        return resultStr
        }
    }
}

 

元转分