使用BigDecimal去掉小数点后无用的0

使用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 '-'

* ('\u002D') 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(BkgFYxmJnew 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(doublehttp:// v1, double v2) {http://

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);

}

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。