1.Bigdecimal回傳資料小數后0自動被洗掉的問題
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import java.io.IOException;
import java.math.BigDecimal;
import java.math.RoundingMode;
public class BigDecimalSerialize extends JsonSerializer<BigDecimal> {
@Override
public void serialize(BigDecimal bigDecimal, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
if (null != bigDecimal) {
jsonGenerator.writeString(bigDecimal.setScale(BigDecimal.ROUND_CEILING, RoundingMode.HALF_DOWN).toPlainString() );
} else {
jsonGenerator.writeString(BigDecimal.ZERO.toPlainString());
}
}
}
在需要處理的欄位上使用
@JsonSerialize(using = BigDecimalSerialize.class)
private BigDecimal amount;
2.BigDecimal格式化保留2為小數，不足則補0
public class NumberFormat {
public static void main(String[] s){
System.out.println(formatToNumber(new BigDecimal("3.435")));
System.out.println(formatToNumber(new BigDecimal(0)));
System.out.println(formatToNumber(new BigDecimal("0.00")));
System.out.println(formatToNumber(new BigDecimal("0.001")));
System.out.println(formatToNumber(new BigDecimal("0.006")));
System.out.println(formatToNumber(new BigDecimal("0.206")));
}
/**
* @desc 1.0~1之間的BigDecimal小數，格式化后失去前面的0,則前面直接加上0，
* 2.傳入的引數等于0，則直接回傳字串"0.00"
* 3.大于1的小數，直接格式化回傳字串
* @param obj傳入的小數
* @return
*/
public static String formatToNumber(BigDecimal obj) {
DecimalFormat df = new DecimalFormat("#.00");
if(obj.compareTo(BigDecimal.ZERO)==0) {
return "0.00";
}else if(obj.compareTo(BigDecimal.ZERO)>0&&obj.compareTo(new BigDecimal(1))<0){
return "0"+df.format(obj).toString();
}else {
return df.format(obj).toString();
}
}
}
3.Bigdecimal通用工具類
import java.math.BigDecimal;
/**
* 用于高精確處理常用的數學運算
*/
public class ArithmeticUtils {
//默認除法運算精度
private static final int DEF_DIV_SCALE = 10;
private static final String TEN_THOUSAND_UNIT = "萬";
private static final String HUNDRED_MILLION_UNIT = "億";
private static final BigDecimal TEN_HUNDRED_THOUSAND = new BigDecimal(10000);
private static final BigDecimal ONE_HUNDRED_MILLION = new BigDecimal(100000000);
private static final BigDecimal TEN_THOUSAND = new BigDecimal(10000);
/**
* 提供精確的加法運算
*
* @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 BigDecimal add(String v1, String v2) {
BigDecimal b1 = new BigDecimal(v1);
BigDecimal b2 = new BigDecimal(v2);
return b1.add(b2);
}
/**
* 提供精確的加法運算
*
* @param v1 被加數
* @param v2 加數
* @param scale 保留scale 位小數
* @return 兩個引數的和
*/
public static String add(String v1, String v2, int scale) {
if (scale < 0) {
throw new IllegalArgumentException(
"The scale must be a positive integer or zero");
}
BigDecimal b1 = new BigDecimal(v1);
BigDecimal b2 = new BigDecimal(v2);
return b1.add(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
}
/**
* 提供精確的減法運算
*
* @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 BigDecimal sub(String v1, String v2) {
BigDecimal b1 = new BigDecimal(v1);
BigDecimal b2 = new BigDecimal(v2);
return b1.subtract(b2);
}
/**
* 提供精確的減法運算
*
* @param v1 被減數
* @param v2 減數
* @param scale 保留scale 位小數
* @return 兩個引數的差
*/
public static String sub(String v1, String v2, int scale) {
if (scale < 0) {
throw new IllegalArgumentException(
"The scale must be a positive integer or zero");
}
BigDecimal b1 = new BigDecimal(v1);
BigDecimal b2 = new BigDecimal(v2);
return b1.subtract(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
}
/**
* 提供精確的乘法運算
*
* @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();
}
/**
* 提供精確的乘法運算
*
* @param v1 被乘數
* @param v2 乘數
* @return 兩個引數的積
*/
public static BigDecimal mul(String v1, String v2) {
BigDecimal b1 = new BigDecimal(v1);
BigDecimal b2 = new BigDecimal(v2);
return b1.multiply(b2);
}
/**
* 提供精確的乘法運算
*
* @param v1 被乘數
* @param v2 乘數
* @param scale 保留scale 位小數
* @return 兩個引數的積
*/
public static double mul(double v1, double v2, int scale) {
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return round(b1.multiply(b2).doubleValue(), scale);
}
/**
* 提供精確的乘法運算
*
* @param v1 被乘數
* @param v2 乘數
* @param scale 保留scale 位小數
* @return 兩個引數的積
*/
public static String mul(String v1, String v2, int scale) {
if (scale < 0) {
throw new IllegalArgumentException(
"The scale must be a positive integer or zero");
}
BigDecimal b1 = new BigDecimal(v1);
BigDecimal b2 = new BigDecimal(v2);
return b1.multiply(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
}
/**
* 提供（相對）精確的除法運算，當發生除不盡的情況時，精確到
* 小數點以后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();
}
/**
* 提供（相對）精確的除法運算，當發生除不盡的情況時，由scale引數指
* 定精度，以后的數字四舍五入
*
* @param v1 被除數
* @param v2 除數
* @param scale 表示需要精確到小數點以后幾位
* @return 兩個引數的商
*/
public static String div(String v1, String v2, int scale) {
if (scale < 0) {
throw new IllegalArgumentException("The scale must be a positive integer or zero");
}
BigDecimal b1 = new BigDecimal(v1);
BigDecimal b2 = new BigDecimal(v1);
return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).toString();
}
/**
* 提供精確的小數位四舍五入處理
*
* @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));
return b.setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue();
}
/**
* 提供精確的小數位四舍五入處理
*
* @param v 需要四舍五入的數字
* @param scale 小數點后保留幾位
* @return 四舍五入后的結果
*/
public static String round(String v, int scale) {
if (scale < 0) {
throw new IllegalArgumentException(
"The scale must be a positive integer or zero");
}
BigDecimal b = new BigDecimal(v);
return b.setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
}
/**
* 取余數
*
* @param v1 被除數
* @param v2 除數
* @param scale 小數點后保留幾位
* @return 余數
*/
public static String remainder(String v1, String v2, int scale) {
if (scale < 0) {
throw new IllegalArgumentException(
"The scale must be a positive integer or zero");
}
BigDecimal b1 = new BigDecimal(v1);
BigDecimal b2 = new BigDecimal(v2);
return b1.remainder(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
}
/**
* 取余數 BigDecimal
*
* @param v1 被除數
* @param v2 除數
* @param scale 小數點后保留幾位
* @return 余數
*/
public static BigDecimal remainder(BigDecimal v1, BigDecimal v2, int scale) {
if (scale < 0) {
throw new IllegalArgumentException(
"The scale must be a positive integer or zero");
}
return v1.remainder(v2).setScale(scale, BigDecimal.ROUND_HALF_UP);
}
/**
* 比較大小
*
* @param v1 被比較數
* @param v2 比較數
* @return 如果v1 大于v2 則 回傳true 否則false
*/
public static boolean compare(String v1, String v2) {
BigDecimal b1 = new BigDecimal(v1);
BigDecimal b2 = new BigDecimal(v2);
int bj = b1.compareTo(b2);
boolean res;
if (bj > 0)
res = true;
else
res = false;
return res;
}
/**
* 過萬/億自動轉換單位 回傳格式 數值_單位
* @param var 待轉換引數
* @param scale 保留位數
* @return 帶單位的數字字串
*/
public static String amountConversion(String var, boolean isTenThousand, @Nullable Integer scale) {
// 引數校驗
Assert.notNull(var, "The var cannot be empty");
Pattern pattern = Pattern.compile("(^[+-]?[0-9]+)|(^[+-]?[0-9]+\\.[0-9]+)");
if (!pattern.matcher(var).matches()) {
throw new IllegalArgumentException("var must be number");
}
BigDecimal amount = new BigDecimal(var);
if (scale == null) {
scale = CommonConstant.FOUR_SCALE;
}
if (amount.abs().compareTo(TEN_HUNDRED_THOUSAND) < 0) {
//如果小于1萬
return amount.stripTrailingZeros().setScale(scale, RoundingMode.HALF_UP).toPlainString() + "_" + (isTenThousand ? TEN_THOUSAND_UNIT : "");
}
if (amount.abs().compareTo(ONE_HUNDRED_MILLION) < 0) {
//如果大于1萬小于1億
return amount.divide(TEN_THOUSAND, scale, RoundingMode.HALF_UP).stripTrailingZeros().toPlainString() + "_" + (isTenThousand ? HUNDRED_MILLION_UNIT : TEN_THOUSAND_UNIT);
}
return amount.divide(ONE_HUNDRED_MILLION, scale, RoundingMode.HALF_UP).stripTrailingZeros().toPlainString() + "_" + (isTenThousand ? TEN_THOUSAND_UNIT + HUNDRED_MILLION_UNIT : HUNDRED_MILLION_UNIT);
}
}
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/552464.html
標籤：Java
下一篇：返回列表