如题：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>"\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);
}
详细还是参看JavaSE 帮助文档吧~以上为个人经验，希望能给大家一个参考，也希望大家多多支持服务器之家。
原文链接：https://blog.csdn.net/qq_31564573/article/details/105534900