Java 8 lambda表达式。

String someString = "123123";
boolean isNumeric = someString.chars().allMatch( Character::isDigit );

这就是为什么我喜欢。net中的Try*方法。除了像Java一样的传统Parse方法之外，还有一个TryParse方法。我不擅长Java语法(输出参数?)，所以请将以下内容视为某种伪代码。但它应该让概念变得清晰。

boolean parseInteger(String s, out int number)
{
    try {
        number = Integer.parseInt(myString);
        return true;
    } catch(NumberFormatException e) {
        return false;
    }
}

用法:

int num;
if (parseInteger("23", out num)) {
    // Do something with num.
}

这通常是通过一个简单的用户定义函数来完成的(例如，roll your-own的“isNumeric”函数)。

喜欢的东西:

public static boolean isNumeric(String str) { 
  try {  
    Double.parseDouble(str);  
    return true;
  } catch(NumberFormatException e){  
    return false;  
  }  
}

然而，如果您经常调用这个函数，并且由于不是一个数字，您希望许多检查失败，那么这种机制的性能就不会很好，因为您依赖于每次失败都会抛出异常，这是一个相当昂贵的操作。

另一种方法可能是使用正则表达式来检查是否是一个数字:

public static boolean isNumeric(String str) {
  return str.matches("-?\\d+(\\.\\d+)?");  //match a number with optional '-' and decimal.
}

但是要小心上面的RegEx机制，因为如果你使用非阿拉伯数字(即0到9以外的数字)，它会失败。这是因为RegEx的“\d”部分只匹配[0-9]，并且有效地不具有国际数字意识。(感谢OregonGhost指出这一点!)

甚至另一种替代方法是使用Java内置的Java .text. numberformat对象来查看解析字符串后解析器的位置是否位于字符串的末尾。如果是，我们可以假设整个字符串都是数字:

public static boolean isNumeric(String str) {
  ParsePosition pos = new ParsePosition(0);
  NumberFormat.getInstance().parse(str, pos);
  return str.length() == pos.getIndex();
}

我认为唯一可靠地判断字符串是否是数字的方法是解析它。所以我只是解析它，如果它是一个数字，你可以免费得到整数形式的数字!

为什么每个人都在推动异常/正则表达式解决方案?

虽然我能理解大多数人都喜欢使用try/catch，但如果你想频繁地使用它……这可能会非常累人。

我在这里所做的是使用regex、parsennumber()方法和数组搜索方法来查看哪个是最有效的。这一次，我只研究了整数。

public static boolean isNumericRegex(String str) {
    if (str == null)
        return false;
    return str.matches("-?\\d+");
}

public static boolean isNumericArray(String str) {
    if (str == null)
        return false;
    char[] data = str.toCharArray();
    if (data.length <= 0)
        return false;
    int index = 0;
    if (data[0] == '-' && data.length > 1)
        index = 1;
    for (; index < data.length; index++) {
        if (data[index] < '0' || data[index] > '9') // Character.isDigit() can go here too.
            return false;
    }
    return true;
}

public static boolean isNumericException(String str) {
    if (str == null)
        return false;
    try {  
        /* int i = */ Integer.parseInt(str);
    } catch (NumberFormatException nfe) {  
        return false;  
    }
    return true;
}

我得到的速度结果是:

Done with: for (int i = 0; i < 10000000; i++)...

With only valid numbers ("59815833" and "-59815833"):
    Array numeric took 395.808192 ms [39.5808192 ns each]
    Regex took 2609.262595 ms [260.9262595 ns each]
    Exception numeric took 428.050207 ms [42.8050207 ns each]
    // Negative sign
    Array numeric took 355.788273 ms [35.5788273 ns each]
    Regex took 2746.278466 ms [274.6278466 ns each]
    Exception numeric took 518.989902 ms [51.8989902 ns each]
    // Single value ("1")
    Array numeric took 317.861267 ms [31.7861267 ns each]
    Regex took 2505.313201 ms [250.5313201 ns each]
    Exception numeric took 239.956955 ms [23.9956955 ns each]
    // With Character.isDigit()
    Array numeric took 400.734616 ms [40.0734616 ns each]
    Regex took 2663.052417 ms [266.3052417 ns each]
    Exception numeric took 401.235906 ms [40.1235906 ns each]

With invalid characters ("5981a5833" and "a"):
    Array numeric took 343.205793 ms [34.3205793 ns each]
    Regex took 2608.739933 ms [260.8739933 ns each]
    Exception numeric took 7317.201775 ms [731.7201775 ns each]
    // With a single character ("a")
    Array numeric took 291.695519 ms [29.1695519 ns each]
    Regex took 2287.25378 ms [228.725378 ns each]
    Exception numeric took 7095.969481 ms [709.5969481 ns each]

With null:
    Array numeric took 214.663834 ms [21.4663834 ns each]
    Regex took 201.395992 ms [20.1395992 ns each]
    Exception numeric took 233.049327 ms [23.3049327 ns each]
    Exception numeric took 6603.669427 ms [660.3669427 ns each] if there is no if/null check

免责声明:我并没有声称这些方法是100%优化的，它们只是为了演示数据

当且仅当数字为4个字符或更少，并且每个字符串总是一个数字时，例外获胜……既然如此，为什么还要支票呢?

简而言之，如果使用try/catch频繁地遇到无效数字，那将非常痛苦，这是有意义的。我一直遵循的一个重要规则是永远不要在程序流中使用try/catch。这是一个例子。

有趣的是，简单的if char <0 || >9写起来非常简单，容易记忆(应该可以在多种语言中工作)，并且赢得了几乎所有的测试场景。

唯一的缺点是，我猜Integer.parseInt()可能处理非ASCII数字，而数组搜索方法不。

对于那些想知道为什么我说很容易记住字符数组1的人来说，如果你知道没有负号，你可以很容易地得到一些像这样的浓缩:

public static boolean isNumericArray(String str) {
    if (str == null)
        return false;
    for (char c : str.toCharArray())
        if (c < '0' || c > '9')
            return false;
    return true;

最后，作为最后的说明，我很好奇在所有投票都被接受的例子中的赋值操作符。加上赋值

double d = Double.parseDouble(...)

不仅没有用，因为您甚至没有使用该值，而且它浪费了处理时间，并使运行时增加了几纳秒(这导致测试中增加了100-200毫秒)。我不明白为什么有人会这么做，因为这实际上是降低性能的额外工作。

你可能会认为这会被优化掉……虽然也许我应该检查字节码，看看编译器在做什么。这并不能解释为什么它对我来说总是更长，尽管它以某种方式被优化了……所以我想知道发生了什么。注意:这里所说的更长，我的意思是运行测试10000000次迭代，并且运行该程序多次(10x+)总是显示它更慢。

编辑:更新了Character.isDigit()的测试

谷歌的Guava库提供了一个很好的辅助方法:你可以像使用Integer一样使用它。parseInt，但如果字符串没有解析为有效整数，它将返回null而不是抛出异常。注意，它返回的是Integer，而不是int，所以你必须将它转换/自动装箱回int。

例子:

String s1 = "22";
String s2 = "22.2";
Integer oInt1 = Ints.tryParse(s1);
Integer oInt2 = Ints.tryParse(s2);

int i1 = -1;
if (oInt1 != null) {
    i1 = oInt1.intValue();
}
int i2 = -1;
if (oInt2 != null) {
    i2 = oInt2.intValue();
}

System.out.println(i1);  // prints 22
System.out.println(i2);  // prints -1

但是，在当前发行版(Guava r11)中，它仍然被标记为@Beta。

我还没有对它进行基准测试。查看源代码，有一些开销来自大量的完整性检查，但最终他们使用Character.digit(string.charAt(idx))，类似，但略有不同，从@Ibrahim上面的答案。在它们的实现中没有异常处理开销。