怎么用BigDecimal去掉小数点后没用的0
更新:HHH   时间:2023-1-7


本篇内容介绍了“怎么用BigDecimal去掉小数点后没用的0”的有关知识,在实际案例的操作过程中,不少人都会遇到这样的困境,接下来就让小编带领大家学习一下如何处理这些情况吧!希望大家仔细阅读,能够学有所成!

目录
  • 如题:BigDecimal去掉小数点后没用的0

    • 解决:BigDecimal,有方法解决stripTrailingZeros()

    • demo

    • 方法二:

  • Java BigDecimal 小数点处理

    • 保留两位小数

      • 方法一:

      • 方式二:

      • 方式三:

    • 四舍五入

    如题:BigDecimal去掉小数点后没用的0

    比如:数据库存储的是Decimal(5,2)类型保留两位数。

    如果展示数据5.00,5.10等字样感觉很不爽,如何做呢?

    只战术5和5.1

    解决:BigDecimal,有方法解决stripTrailingZeros()

    看源码:

    /**
         * Returns a string representation of this {@code BigDecimal}
         * without an exponent field.  For values with a positive scale,
         * the number of digits to the right of the decimal point is used
         * to indicate scale.  For values with a zero or negative scale,
         * the resulting string is generated as if the value were
         * converted to a numerically equal value with zero scale and as
         * if all the trailing zeros of the zero scale value were present
         * in the result.
         *
         * The entire string is prefixed by a minus sign character '-'
         * (<tt>'&#92;u002D'</tt>) if the unscaled value is less than
         * zero. No sign character is prefixed if the unscaled value is
         * zero or positive.
         *
         * Note that if the result of this method is passed to the
         * {@linkplain #BigDecimal(String) string constructor}, only the
         * numerical value of this {@code BigDecimal} will necessarily be
         * recovered; the representation of the new {@code BigDecimal}
         * may have a different scale.  In particular, if this
         * {@code BigDecimal} has a negative scale, the string resulting
         * from this method will have a scale of zero when processed by
         * the string constructor.
         *
         * (This method behaves analogously to the {@code toString}
         * method in 1.4 and earlier releases.)
         *
         * @return a string representation of this {@code BigDecimal}
         * without an exponent field.
         * @since 1.5
         * @see #toString()
         * @see #toEngineeringString()
         */
        public String toPlainString() {
            if(scale==0) {
                if(intCompact!=INFLATED) {
                    return Long.toString(intCompact);
                } else {
                    return intVal.toString();
                }
            }
            if(this.scale<0) { // No decimal point
                if(signum()==0) {
                    return "0";
                }
                int tailingZeros = checkScaleNonZero((-(long)scale));
                StringBuilder buf;
                if(intCompact!=INFLATED) {
                    buf = new StringBuilder(20+tailingZeros);
                    buf.append(intCompact);
                } else {
                    String str = intVal.toString();
                    buf = new StringBuilder(str.length()+tailingZeros);
                    buf.append(str);
                }
                for (int i = 0; i < tailingZeros; i++)
                    buf.append('0');
                return buf.toString();
            }
            String str ;
            if(intCompact!=INFLATED) {
                str = Long.toString(Math.abs(intCompact));
            } else {
                str = intVal.abs().toString();
            }
            return getValueString(signum(), str, scale);
        }
     /**
         * Returns a {@code BigDecimal} which is numerically equal to
         * this one but with any trailing zeros removed from the
         * representation.  For example, stripping the trailing zeros from
         * the {@code BigDecimal} value {@code 600.0}, which has
         * [{@code BigInteger}, {@code scale}] components equals to
         * [6000, 1], yields {@code 6E2} with [{@code BigInteger},
         * {@code scale}] components equals to [6, -2].  If
         * this BigDecimal is numerically equal to zero, then
         * {@code BigDecimal.ZERO} is returned.
         *
         * @return a numerically equal {@code BigDecimal} with any
         * trailing zeros removed.
         * @since 1.5
         */
        public BigDecimal stripTrailingZeros() {
            if (intCompact == 0 || (intVal != null && intVal.signum() == 0)) {
                return BigDecimal.ZERO;
            } else if (intCompact != INFLATED) {
                return createAndStripZerosToMatchScale(intCompact, scale, Long.MIN_VALUE);
            } else {
                return createAndStripZerosToMatchScale(intVal, scale, Long.MIN_VALUE);
            }
        }

    demo

    public class StringUtils {
        public static void main(String[] args) {
            System.out.println(BigDecimal.ZERO);
            System.out.println(new BigDecimal("2.0"));
            System.out.println(new Double("0"));
            System.out.println(new BigDecimal("2.00"));
            String d = new BigDecimal("100.10").stripTrailingZeros().toPlainString();
            System.out.println(d);
            System.out.println(new BigDecimal("100.10").stripTrailingZeros().toPlainString());
        }
    }

    结果:

    方法二:

     private static final DecimalFormat decimalFormat = new DecimalFormat("###################.###########");
        public static void main(String[] args) throws Exception{
            System.out.print( "格式化结果:");
            System.out.println(decimalFormat.format(new BigDecimal("10.10")));
        }

    结果:

    Java BigDecimal 小数点处理

    保留两位小数

    方法一:
    {
       double   c=3.154215;
       java.text.DecimalFormat myformat=new java.text.DecimalFormat("0.00");
       String str = myformat.format(c);   
    }
    方式二:
    {
       java.text.DecimalFormat   df   =new   java.text.DecimalFormat("#.00");
       df.format(你要格式化的数字);
       例:new java.text.DecimalFormat("#.00").format(3.1415926)
       #.00 表示两位小数 #.0000四位小数 以此类推...
    }
    方式三:
    {
       double d = 3.1415926;
       String result = String .format("%.2f");
       %.2f %. 表示 小数点前任意位数   2 表示两位小数 格式后的结果为f 表示浮点型
    }

    四舍五入

    {
    double   f   =   111231.5585;
    BigDecimal   b   =   new   BigDecimal(f);
    //保留2位小数
    double   f1   =   b.setScale(2,   BigDecimal.ROUND_HALF_UP).doubleValue();
    }
    public class PreciseCompute {
    //默认除法运算精度
    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 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 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();
    }
     
    /**
    * 提供(相对)精确的除法运算,当发生除不尽的情况时,精确到
    * 小数点以后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();
    }
     
    /**
    * 提供精确的小数位四舍五入处理。
    * @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));
       BigDecimal ne = new BigDecimal("1");
       return b.divide(one, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    }
    }

    my code:

    private BigDecimal formatComma2BigDecimal(Object obj) {
    		String val = String.valueOf(obj);
    		if (val == null)
    			return new BigDecimal("0.00");
     
    		val = val.replaceAll(",", "");
    		if (!isNumber(val))
    			return new BigDecimal("0.00");
     
    		BigDecimal decimal = new BigDecimal(val);
    		decimal = decimal.setScale(2, RoundingMode.HALF_UP); 
    		return decimal;
     
    	}
    	private String formatCommaAnd2Point(Object obj) {
    		BigDecimal decimal = formatComma2BigDecimal(obj);
     
    		DecimalFormat df = new DecimalFormat("#,###.00");
    		String decimalStr = df.format(decimal).equals(".00")?"0.00":df.format(decimal);
    		if(decimalStr.startsWith(".")){
    			decimalStr = "0"+decimalStr;
    		}
    		return decimalStr;
    	}
    	private boolean isDouble(String value) {
    		try {
    			Double.parseDouble(value);
    			if (value.contains("."))
    				return true;
    			return false;
    		} catch (NumberFormatException e) {
    			return false;
    		}
    	}
    	private boolean isInteger(String value) {
    		try {
    			Integer.parseInt(value);
    			return true;
    		} catch (NumberFormatException e) {
    			return false;
    		}
    	}
    	private boolean isNumber(String value) {
    		return isInteger(value) || isDouble(value);
    	}

    “怎么用BigDecimal去掉小数点后没用的0”的内容就介绍到这里了,感谢大家的阅读。如果想了解更多行业相关的知识可以关注天达云网站,小编将为大家输出更多高质量的实用文章!

    返回开发技术教程...