[BUG]JSON序列化，BigDecimal值不对。

[zhao-qiwei]

问题描述

JSON序列化，BigDecimal值不对。
new BigDecimal("1.09600000")序列化JSON的值变成了：1.9600000

环境信息

FastJson2版本：2.0.40
JDK版本：1.8
系统：linux与window都可以再现

重现步骤

测试代码如下：

package net.qmgf.ctrm.api.test;

import java.io.Serializable;
import java.math.BigDecimal;

import com.alibaba.fastjson2.JSONObject;

public class TestJson {

    public static class TestCls implements Serializable {
        private static final long serialVersionUID = 1L;
        private BigDecimal goodsWeight;

        public BigDecimal getGoodsWeight() {
            return goodsWeight;
        }

        public void setGoodsWeight(BigDecimal goodsWeight) {
            this.goodsWeight = goodsWeight;
        }
    }

    public static void main(String[] args) {
        TestCls bean = new TestCls();
        bean.setGoodsWeight(new BigDecimal("1.09600000"));
        System.out.println(JSONObject.toJSONString(bean));
    }
}

输出的结果是：{"goodsWeight":1.9600000}

"1.09600000"变成了：1.9600000

另外，一个建议：BigDecimal转换成String时，默认是否可以这样转换：
BigDecimal dec = new BigDecimal("1.09600000");
String str = dec.stripTrailingZeros().toPlainString();

[zhao-qiwei]

感觉像是这个方法的问题：com.alibaba.fastjson2.util.IOUtils.writeDecimal

IOUtils.writeDecimal如果修改成这样，可以解决上面的问题，而且效率会更高：

    public static int writeDecimal(byte[] buf, int off, long unscaledVal, int scale) {
        if (unscaledVal < 0) {
            buf[off++] = '-';
            unscaledVal = -unscaledVal;
        }
        if (scale > 0) {
            boolean s = false;
            // 整数部分
            for (int i = POWER_TEN.length - 1; i >= 0; i--) {
                if (i == scale - 2) {
                    break;
                }
                byte c = '0';
                while (unscaledVal >= POWER_TEN[i]) {
                    unscaledVal -= POWER_TEN[i];
                    c++;
                }
                if (c > '0') {
                    s = true;
                }
                if (s) {
                    buf[off++] = c;
                }
            }
            if (!s) {
                buf[off++] = '0';
            }
            // 小数部分
            if (unscaledVal > 0) {
                buf[off++] = '.';
                for (int i = scale - 2; i >= 0; i--) {
                    if (unscaledVal == 0) {
                        break;
                    }
                    byte c = '0';
                    while (unscaledVal >= POWER_TEN[i]) {
                        unscaledVal -= POWER_TEN[i];
                        c++;
                    }
                    buf[off++] = c;
                }
                if (unscaledVal > 0) {
                    buf[off++] = (byte) ('0' + unscaledVal);
                }
            }
        } else {
            boolean s = false;
            for (int i = POWER_TEN.length - 1; i >= 0; i--) {
                byte c = '0';
                while (unscaledVal >= POWER_TEN[i]) {
                    unscaledVal -= POWER_TEN[i];
                    c++;
                }
                if (c > '0') {
                    s = true;
                }
                if (s) {
                    buf[off++] = c;
                }
            }
            buf[off++] = (byte) ('0' + unscaledVal);
            for (int i = scale; i < 0; i++) {
                buf[off++] = '0';
            }
        }
        return off;
    }

    // @formatter:off 
    static final long[] POWER_TEN = {
            10,
            100,
            1000,
            10000,
            100000,
            1000000,
            10000000,
            100000000,
            1000000000,
            10000000000L,
            100000000000L,
            1000000000000L,
            10000000000000L,
            100000000000000L,
            1000000000000000L,
            10000000000000000L,
            100000000000000000L,
            1000000000000000000L,
    };
    // @formatter:off 

[wenshao]

https://oss.sonatype.org/content/repositories/snapshots/com/alibaba/fastjson2/fastjson2/2.0.40-SNAPSHOT/
问题已修复，请用2.0.40-SNAPSHOT帮忙验证

[wenshao]

感觉像是这个方法的问题：com.alibaba.fastjson2.util.IOUtils.writeDecimal

IOUtils.writeDecimal如果修改成这样，可以解决上面的问题，而且效率会更高：

    public static int writeDecimal(byte[] buf, int off, long unscaledVal, int scale) {
        if (unscaledVal < 0) {
            buf[off++] = '-';
            unscaledVal = -unscaledVal;
        }
        if (scale > 0) {
            boolean s = false;
            // 整数部分
            for (int i = POWER_TEN.length - 1; i >= 0; i--) {
                if (i == scale - 2) {
                    break;
                }
                byte c = '0';
                while (unscaledVal >= POWER_TEN[i]) {
                    unscaledVal -= POWER_TEN[i];
                    c++;
                }
                if (c > '0') {
                    s = true;
                }
                if (s) {
                    buf[off++] = c;
                }
            }
            if (!s) {
                buf[off++] = '0';
            }
            // 小数部分
            if (unscaledVal > 0) {
                buf[off++] = '.';
                for (int i = scale - 2; i >= 0; i--) {
                    if (unscaledVal == 0) {
                        break;
                    }
                    byte c = '0';
                    while (unscaledVal >= POWER_TEN[i]) {
                        unscaledVal -= POWER_TEN[i];
                        c++;
                    }
                    buf[off++] = c;
                }
                if (unscaledVal > 0) {
                    buf[off++] = (byte) ('0' + unscaledVal);
                }
            }
        } else {
            boolean s = false;
            for (int i = POWER_TEN.length - 1; i >= 0; i--) {
                byte c = '0';
                while (unscaledVal >= POWER_TEN[i]) {
                    unscaledVal -= POWER_TEN[i];
                    c++;
                }
                if (c > '0') {
                    s = true;
                }
                if (s) {
                    buf[off++] = c;
                }
            }
            buf[off++] = (byte) ('0' + unscaledVal);
            for (int i = scale; i < 0; i++) {
                buf[off++] = '0';
            }
        }
        return off;
    }

    // @formatter:off 
    static final long[] POWER_TEN = {
            10,
            100,
            1000,
            10000,
            100000,
            1000000,
            10000000,
            100000000,
            1000000000,
            10000000000L,
            100000000000L,
            1000000000000L,
            10000000000000L,
            100000000000000L,
            1000000000000000L,
            10000000000000000L,
            100000000000000000L,
            1000000000000000000L,
    };
    // @formatter:off 

有benchmark数据么？

[zhao-qiwei]

没有，
不过这个用的是减法，原来的用的是除法。
通常减法要比除法效率高。

[zhao-qiwei]

2.0.41-SNAPSHOT版本中已解决。

[wenshao]

https://github.com/alibaba/fastjson2/releases/tag/2.0.41
请用新版本