doubleValue()、toString()、toPlainString()与科学计数法

   public static void mapToObject(Map<String, Object> map, Object o) {
        JavaBeanMapUtil util = new JavaBeanMapUtil();
        util.registerClass(o.getClass());
        for (Map.Entry<String, Object> entry : map.entrySet()) {
            String key = entry.getKey();
            Object val = entry.getValue();
            util.setValue(key, val, o);
        }
    }

    /**
     * 根据反射设置某字段的值
     *
     * @param name
     * @param value
     */
    public <T> void setValue(String name, Object value, Object ob) {
        try {
            PropertyDescriptor pd = new PropertyDescriptor(name, this.classBind);
            Method wM = pd.getWriteMethod();// 获得写方法
            Class<?> parameterType = wM.getParameterTypes()[0];
            if (parameterType == String.class) {
                wM.invoke(ob, String.valueOf(value));
            } else if (parameterType == int.class || parameterType == Integer.class) {
                String str = String.valueOf(value);
                if (StringUtils.isNotBlank(str)) {
                    wM.invoke(ob, new BigDecimal(String.valueOf(value)).intValue());
                }
            } else if (parameterType == double.class || parameterType == Double.class) {
                String str = String.valueOf(value);
                if (StringUtils.isNotBlank(str)) {
                    wM.invoke(ob, new BigDecimal(String.valueOf(value)).doubleValue());
                }
            } else if (parameterType == BigDecimal.class) {
                String str = String.valueOf(value);
                if (StringUtils.isNotBlank(str)) {
                    wM.invoke(ob, new BigDecimal(String.valueOf(str)).toPlainString());
                }
            } else if (parameterType == Date.class) {
                String str = String.valueOf(value);
                if (StringUtils.isNotBlank(str)) {
                    Long dt = new Long(str);
                    wM.invoke(ob, new Date(dt));
                }
            } else if (parameterType.isArray()) {
                Object[] list = null;
                if (value instanceof List) {
                    list = ((List<?>) value).toArray();
                } else {
                    list = (Object[]) value;
                }
                Object[] args = new Object[list.length];
                for (int index = 0; index < list.length; index++) {
                    Object item = list[index];
                    if (item instanceof Number) {// 如果是数字
                        args[index] = item;
                    } else if (item instanceof String) {// 如果是字符串
                        args[index] = item;
                    } else {
                        args[index] = item;
                    }
                }
                wM.invoke(ob, args);
            } else {
                Type[] parameters = wM.getGenericParameterTypes();
                if (parameters.length > 0) {
                    if (parameters[0] instanceof ParameterizedType) {
                        ParameterizedType pt = (ParameterizedType) parameters[0];
                        Type[] actualTypeArguments = pt.getActualTypeArguments();
                        if (actualTypeArguments.length == 1) {
                            List<Object> args = new ArrayList<Object>();
                            Object[] list = null;
                            if (value instanceof List) {
                                list = ((List<?>) value).toArray();
                            } else {
                                list = (Object[]) value;
                            }
                            for (Object item : list) {
                                if (item instanceof Number) {
                                    args.add(item);
                                } else if (item instanceof String) {
                                    args.add(item);
                                } else {
                                    args.add(item);
                                }
                            }
                            wM.invoke(ob, args);
                        } else if (actualTypeArguments.length == 2) {// MAP 场合
                            Map<Object, Object> targetMp = (Map<Object, Object>) value;
                            Map<Object, Object> args = new HashMap<Object, Object>();
                            for (Object key : targetMp.keySet()) {
                                Object val = targetMp.get(key);
                                if (val instanceof Number) {
                                    args.put(key, val);
                                } else if (val instanceof String) {
                                    args.put(key, val);
                                } else {
                                    args.put(key, val);
                                }
                            }
                            wM.invoke(ob, args);
                        }
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

import java.math.BigDecimal;
 
public class Test {
 
    public static void main(String[] args) {
        BigDecimal a1 = new BigDecimal("1");
        // 小数位数递增
        for (int i = 0; i < 20; i++) {
            a1 = a1.multiply(new BigDecimal("0.1"));
            System.out.println("----------------------" + (i + 1) + "位小数时的输出结果-------------------------");
            System.out.println("doubleValue方法显示数值：                         " + a1.doubleValue());
            System.out.println("toString方法显示数值：                                 " + a1.toString());
            System.out.println("toPlainString方法显示数值：                    " + a1.toPlainString());
        }
        System.out.println("\n\n");
        a1 = new BigDecimal("1");
        // 整数位数递增
        for (int i = 1; i < 20; i++) {
            a1 = a1.multiply(new BigDecimal("10"));
            System.out.println("----------------------" + (i + 1) + "位整数时的输出结果-------------------------");
            System.out.println("doubleValue方法显示数值：                         " + a1.doubleValue());
            System.out.println("toString方法显示数值：                                 " + a1.toString());
            System.out.println("toPlainString方法显示数值：                    " + a1.toPlainString());
        }
        System.out.println("\n\n");
        // 始终两位小数位，整数位递增
        a1 = new BigDecimal("1");
        for (int i = 1; i < 30; i++) {
            a1 = a1.setScale(0, BigDecimal.ROUND_DOWN).multiply(new BigDecimal("10.11"));
            System.out.println("----------------------" + i + "位整数,2位小数时的输出结果-------------------------");
            System.out.println("doubleValue方法显示数值：                         " + a1.doubleValue());
            System.out.println("toString方法显示数值：                                 " + a1.toString());
            System.out.println("toPlainString方法显示数值：                    " + a1.toPlainString());
        }
        System.out.println("\n\n");
        // 小数位、整数位同时递增
        a1 = new BigDecimal("1");
        for (int i = 1; i < 30; i++) {
            if (i % 2 == 0) {
                a1 = a1.multiply(new BigDecimal("10"));
            } else {
                a1 = a1.multiply(new BigDecimal("10.1"));
            }
            System.out.println(
                    "----------------------" + (i + 1) + "位整数," + ((i + 1) / 2) + "位小数时的输出结果-------------------------");
            System.out.println("doubleValue方法显示数值：                         " + a1.doubleValue());
            System.out.println("toString方法显示数值：                                 " + a1.toString());
            System.out.println("toPlainString方法显示数值：                    " + a1.toPlainString());
        }
    }
}

当整数、小数位数皆增长时，doubleValue()变为科学计数法，其他两种方法不变。

由以上测试，得出结论，toString()在某些情况下显示数值会变为科学计数法，而toPlainString()始终精确显示数值本身。