Java 同时验证int和float值

我通过对象的getter获得一个名为

amount

的值，如下所示

假设对象是

h

h.getAmount()

现在我需要开发一个验证器，它将验证

amount

应该是integer类型，如果不是，它将抛出异常，我已经开发了这个验证器，如下所示

private  boolean isint (String amount){
    boolean isValid = true;
    try {
        Integer.parseInt(amount); 
    }
    catch(NumberFormatException e){
        isValid = false;
    }
     return isValid;
}

现在的问题是来自

h

的

amount

是一个整数，如

1234

，但它也可以是一个浮点数，如

1258.26

。因此，在float的情况下，它抛出一个

NumberFormatException

---

我怎样才能使它对两个值都完美，无论是整数还是浮点值？

您可以像这样使用

regex

：-

if (str.matches("[-+]?[0-9]*\\.?[0-9]+")) { // You can use the `\\d` instead of `0-9` too!
    // Is a number - int, float, double         
}

[-+]？-表示符号

[0-9]*\.？[0-9]+-用于数字和数字之间的小数点

更新：-

如果也需要处理指数，则可以使用下面的

regex

String regex = "[-+]?[0-9]*\\.?[0-9]+([eE][-+]?[0-9]+)?";

---

首先，如果您有一个名为

isInt

的函数，那么它应该正好做到这一点——检查它是否为整数。不多也不少

你可以试试那样的

enum VarType {
    INTEGER, FLOAT, STRING, EMPTY
}

private VarType getVarType(String amount){
     if (amount.length() ==0) {
       return VarType.EMPTY;
     }
     if (amount.contains(".")) { 
       try {
         Float.parseFloat(amount); 
       }
       catch(NumberFormatException e){
         return ValType.STRING;
       }
       return ValType.FLOAT;
     } else {
       try {
         Integer.parseInt(amount); 
       }
       catch(NumberFormatException e){
         return ValType.STRING;
       }
       return ValType.INTEGER;
     }
}

不过我不推荐这样做，因为以这种方式使用异常非常昂贵。异常应该按照其名称使用，以处理特殊情况、异常，而不是作为标准流

我会这样做：

public class ParseVarTest {

    static enum VarType {
        INTEGER, FLOAT, STRING, EMPTY
    }

    private static VarType getVarType(String amount){
        boolean onlyDigits = true;
        int dotCount = 0;
        if (amount == null) {
            return VarType.EMPTY;
        }
        String trimmed = amount.trim();
        if (trimmed.length() == 0) {
            return VarType.EMPTY;
        }
        int a=0;
        if (trimmed.charAt(0) == '-') {
            a++;
        }
        for (int max=trimmed.length(); a<max; a++) {
            if ( trimmed.charAt(a) == '.' ) {
                dotCount++;
                if (dotCount>1) break;
            } else if ( !Character.isDigit(trimmed.charAt(a)) ) {
                onlyDigits = false;
                break;
            }  
        }

        if (onlyDigits) {
            if (dotCount ==0) {
                return VarType.INTEGER;
            } else if (dotCount ==1) {
                return VarType.FLOAT;
            } else {
                return VarType.STRING;
            }
        }
        return VarType.STRING;
    }

    public static void main(String[] args) {
        String[] vars = {"", "  ", "123", "-5123", "1234.41", "-1234.41", "-1234..41","a12312", "523sdf234sdf.123"};
        for (String var: vars) {
            System.out.print(var);
            System.out.print(": \t");
            System.out.println(getVarType(var));
        }
    }

}

公共类ParseVarTest{
静态枚举变量类型{
整数、浮点、字符串、空
}
私有静态VarType getVarType（字符串金额）{
布尔值onlyDigits=true；
int dotCount=0；
如果（金额==null）{
返回VarType.EMPTY；
}
String trimmed=amount.trim（）；
如果（trimmed.length（）==0）{
返回VarType.EMPTY；
}
int a=0；
if（trimmed.charAt（0）='-'）{
a++；
}
对于（int max=trimmed.length（）；a1）中断；
}如果（！Character.isDigit（trimmed.charAt（a）），则为else{
onlyDigits=false；
打破
}  
}
如果（仅数字）{
if（dotCount==0）{
返回VarType.INTEGER；
}else if（dotCount==1）{
返回VarType.FLOAT；
}否则{
返回VarType.STRING；
}
}
返回VarType.STRING；
}
公共静态void main（字符串[]args）{
字符串[]vars={“”、“123”、“-5123”、“1234.41”、“-1234.41”、“-1234..41”、“a12312”、“523sdf234sdf.123”}；
for（字符串变量：vars）{
系统输出打印（var）；
系统输出打印（“：\t”）；
System.out.println（getVarType（var））；
}
}
}

对于这样一项简单的任务来说，时间相当长，但是：

• 没有正则表达式

• 最多对字符串进行一次扫描

• 国际海事组织

• 快速

---

但是，此解决方案不会验证值的范围。字符串

1000000000

仍将被识别为

VarType.INTEGER

，即使该值无法放入Java中的

int

变量。

使用Double.parseDouble。。。（方法名称更改为

isNumber

，以更好地反映方法的含义）

。。。可以简化为

private  boolean isNumber (String amount){
    try {
        Double.parseDouble(amount);             
    }
    catch(NumberFormatException e){
        return false;            
    }
    return true;
}

---

如果你说的是整数或几位小数，你可能在说货币或数量，BigDecimal是理想的和浮点不是很好（由于舍入错误）

否则，您所说的是双浮点值

newbigdecimal（str）

将为您解析整数或十进制，但它也将接受指数；例1.4E2表示140

也许您想先使用正则表达式模式来验证它

if (! str.matches( "[-+]?(\\d+)|(\\d*\\.\\d+)")) 
    throw new NumberFormatException();

---

此模式接受没有任何前导数字的小数，例如.14159，这应该是允许的。

正如建议的那样，最好使用

long

和

double

而不是

int

和

float

顺便问一下，你不能简单地检查一下浮动吗？如果它是一个

int

，则它可以始终是一个

float

正在运行演示：

输出：

> 1234                 IS     a valid Integer or Float    
> 1234.56              IS     a valid Integer or Float    
> 1234.56.78           IS NOT a valid Integer or Float     
> abc                  IS NOT a valid Integer or Float     
> 2147483647           IS     a valid Integer or Float    
> 3.4028235E38         IS     a valid Integer or Float    
> -2147483648          IS     a valid Integer or Float    
> 1.4E-45              IS     a valid Integer or Float

---

若你们不允许非整数的数字，那个么为什么系统会给你们非整数的值呢？你们的getter应该指定它返回一个整数或浮点？为什么要将其作为

字符串

进行后续处理？字符串的内容应该是一个序列化的整数值，但可以是一个小数。一个丑陋的方法是确定字符串是否包含

，然后相应地采取行动。我建议使用

长

和

双

而不是

int

和

float

因为它们的精度是原来的两倍，几乎可以免费为您节省一些错误行为。您可以拥有一个有效的

float

数字，它不包含

但不是有效的

int

值。e、 g.

1000000000

@PeterLawrey是的，这里不考虑数值范围。谢谢你的评论。在这种情况下，使用异常的解决方案会更好。我建议OP使用

double

，但如果OP只使用

int

或

float

的话，对于这两种方法都不适用的值，此方法可以返回true。@PeterLawrey同意。我的回答假设OP希望允许一个数值范围。从Double.MIN_值到Double.MAX_值。如果OP想要限制为浮点大小数字，请使用parseFloat等。这些值都不适合浮点或整数。需要OP提供更多信息，但我实际上认为这是他想要知道的。。。“是否输入了数字？”。。。我们没有关于如何处理它的任何信息。。。或者它应该被限制到什么大小的数据类型。同意，B

public static boolean isFloat(String number){
    try {
       return !new Float(number).isNaN();
    } catch (NumberFormatException e){
        return false;
    }
}

> 1234                 IS     a valid Integer or Float    
> 1234.56              IS     a valid Integer or Float    
> 1234.56.78           IS NOT a valid Integer or Float     
> abc                  IS NOT a valid Integer or Float     
> 2147483647           IS     a valid Integer or Float    
> 3.4028235E38         IS     a valid Integer or Float    
> -2147483648          IS     a valid Integer or Float    
> 1.4E-45              IS     a valid Integer or Float