栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

字符串 ---- 去除字符数字无效前后无效的0

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

字符串 ---- 去除字符数字无效前后无效的0

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

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

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

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

 
public static double div(double v1, double v2) {
   return div(v1, v2, DEF_DIV_SCALE);
}
 

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

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
}

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/973331.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号