Java
利用BigDecimal的方法
@Test
public void TestCompare() {
// JAVA中Float类型的小数超过4位(前面都是0，例如0.0001)会转成科学计数法存储
Float f = 0.0001F;
// 转BigDecimal的时候避免精度丢失，先转成String类型
String fStr = Float.toString(f);
System.out.println(fStr);
// 使用stripTrailingZeros()方法去掉小数后面多余的0
String s3 = new BigDecimal(fStr).stripTrailingZeros().toPlainString();
System.out.println(s3);
}
正则（去除前面的0）
String str = "000000121";
int result = Integer.parseInt(str);
System.out.println(result);
String str2 = "000000100021.1230004000";
String replace = str2.replace("^0*", "");
System.out.println(replace);
String s = str2.replaceAll("^(0+)", "");
System.out.println(s);
// 121
// 000000100021.1230004000
// 100021.1230004000
正则（去除后面的0）
/**
* 去掉给定字符串（小数）后面的无效0
*
* @param value 小数的字符串表示
* @return 如果转换失败，返回null
*/
public static String convertByPattern(String value) {
String regex = "^(-?\\d*)(\\.?0*)$";
Matcher matcher = Pattern.compile(regex).matcher(value);
if (matcher.find()) {
return matcher.group(1);
}
String regex1 = "^(-?\\d*\\.\\d*[1-9])(0*)$";
Matcher matcher1 = Pattern.compile(regex1).matcher(value);
if (matcher1.find()) {
return matcher1.group(1);
}
return null;
}
@Test
public void test1() {
System.out.println(NumberValidationUtils.convertByPattern("000"));
System.out.println(NumberValidationUtils.convertByPattern("001.00"));
System.out.println(NumberValidationUtils.convertByPattern("0.0"));
System.out.println(NumberValidationUtils.convertByPattern("00100.00100"));
System.out.println(NumberValidationUtils.convertByPattern("zs.1200"));
System.out.println(NumberValidationUtils.convertByPattern("00100.00100"));
}
000
001
0
00100.001
null
00100.001
当使用正则匹配的时候，需要代码中的两种正则表达式来进行匹配判断组合。第一种正则表达式用来匹配小数点后面全是0的值，例如122.000。第二种正则表达式用来匹配小数点后面存在非0数值的值，例如109.00200。
上述方法支持正数和负数的处理
在正则表达式中，使用分组的方式来实现，在正则匹配过程中，将要保留的部分放在第一个括号中，即组1，那么最终获取值的时候，就可以使用group(1)直接拿到
关于两个表达式：
表达式1：^(-?\d*)(.?0*)$：
-？：正负数的匹配均支持
\d*：0个到n个数字，即匹配整数部分
到这里，小数点前面部分就匹配完了，所以前面的部分可以作为第一组
.？：可以匹配0个或1个小数点
0*：可以匹配0个或1个数值0
第二个分组可有可无。因为表达式1主要使用用来识别出无小数点或者是小数点后面是若干个0的格式
表达式2：^(-?\d*.\d*[1-9])(0*)$：
-？：正负数的匹配均支持
\d*：0个到n个数字，即匹配整数部分
.：匹配小数点
\d*[1-9]：匹配小数部分，因为表达式2的目的是匹配小数点后面存在非0数值。那么[1-9]就是用来匹配最后一个非0数值的
(0*) $：如果最后一个为是非0数值，那么不会匹配到任何。如果最后一位是0，那么这里匹配到的就是最后一个非0数值后面的所有0
————————————————
版权声明：本文为CSDN博主「安一缸」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/javadocdoc/article/details/122989219
保留小数
{
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();
}
}
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);
}
判断数字长度
正则表达式表示 decimal(10,4),限制最多输入10位数，小数位最多占4位，整数位最多占6位
let str='8903.9090';
let reg= /^\d{1,6}$|^\d{1,6}[.]\d{1,8}$/;
if(reg.test(str)){//true
//balabala
}
3316
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
