Самый изящный способ обнаружить, если Строка является числом?

Вы могли использовать regex, т.е. что-то как String.matches("^[\\d\\-\\.]+$"); (если Вы не тестируете на отрицательные числа или числа с плавающей точкой, Вы могли бы упростить немного).

Не уверенный, было ли это быстрее, чем метод, который Вы обрисовали в общих чертах все же.

Править: в свете всего этого противоречия я решил сделать тест и получить некоторые данные о том, как быстро каждый из этих методов был. Не так правильность, но как быстро они работали.

Можно читать о моих результатах на моем блоге. (Подсказка: Jon Skeet FTW).

Корректный regex на самом деле подан Двойной javadocs:

Чтобы постараться не называть этот метод на недопустимой строке и иметь NumberFormatException быть брошенным, регулярное выражение ниже может использоваться для экранирования входной строки:

    final String Digits     = "(\\p{Digit}+)";
    final String HexDigits  = "(\\p{XDigit}+)";
    // an exponent is 'e' or 'E' followed by an optionally 
    // signed decimal integer.
    final String Exp        = "[eE][+-]?"+Digits;
    final String fpRegex    =
        ("[\\x00-\\x20]*"+  // Optional leading "whitespace"
         "[+-]?(" + // Optional sign character
         "NaN|" +           // "NaN" string
         "Infinity|" +      // "Infinity" string

         // A decimal floating-point string representing a finite positive
         // number without a leading sign has at most five basic pieces:
         // Digits . Digits ExponentPart FloatTypeSuffix
         // 
         // Since this method allows integer-only strings as input
         // in addition to strings of floating-point literals, the
         // two sub-patterns below are simplifications of the grammar
         // productions from the Java Language Specification, 2nd 
         // edition, section 3.10.2.

         // Digits ._opt Digits_opt ExponentPart_opt FloatTypeSuffix_opt
         "((("+Digits+"(\\.)?("+Digits+"?)("+Exp+")?)|"+

         // . Digits ExponentPart_opt FloatTypeSuffix_opt
         "(\\.("+Digits+")("+Exp+")?)|"+

   // Hexadecimal strings
   "((" +
    // 0[xX] HexDigits ._opt BinaryExponent FloatTypeSuffix_opt
    "(0[xX]" + HexDigits + "(\\.)?)|" +

    // 0[xX] HexDigits_opt . HexDigits BinaryExponent FloatTypeSuffix_opt
    "(0[xX]" + HexDigits + "?(\\.)" + HexDigits + ")" +

    ")[pP][+-]?" + Digits + "))" +
         "[fFdD]?))" +
         "[\\x00-\\x20]*");// Optional trailing "whitespace"

    if (Pattern.matches(fpRegex, myString))
        Double.valueOf(myString); // Will not throw NumberFormatException
    else {
        // Perform suitable alternative action
    }

Это не допускает локализованные представления, однако:

Для интерпретации представлений локализованной строки значения с плавающей точкой используйте подклассы NumberFormat.

См. java.text. NumberFormat (javadoc).

NumberFormat nf = NumberFormat.getInstance(Locale.FRENCH);
Number myNumber = nf.parse(myString);
int myInt = myNumber.intValue();
double myDouble = myNumber.doubleValue();

Использовать StringUtils.isDouble(String) в Apache палата общин.

Я использовал бы Джакарту Ленг свободного городского населения, как всегда! Но я понятия не имею, быстра ли их реализация или нет. Это не полагается на Исключения, которые могли бы быть хорошей мудрой производительностью бедра...

Большинство этих ответов является несколько приемлемыми решениями. Все regex решения имеют проблему того, чтобы не быть корректным для всех случаев, о которых можно заботиться.

Если Вы действительно хотите удостовериться, что Строка является верным номером, то я использовал бы Ваше собственное решение. Не забывайте, что, я воображаю, что большую часть времени Строка будет верным номером и не повысит исключение. Таким образом, большую часть времени производительность будет идентична производительности Double.valueOf ().

Я предполагаю, что это действительно не ответ, за исключением того, что он проверяет Ваш начальный инстинкт.

Randy

Усиление от г-на Skeet:

private boolean IsValidDoubleChar(char c)
{
    return "0123456789.+-eE".indexOf(c) >= 0;
}

public boolean isDouble(String value)
{
    for (int i=0; i < value.length(); i++)
    {
        char c = value.charAt(i);
        if (IsValidDoubleChar(c))
            continue;
        return false;
    }
    try
    {
        Double.parseDouble(value);
        return true;
    }
    catch (NumberFormatException e)
    {
        return false;
    }
}

Ответ следующего Phill я могу предложить другой regex?

String.matches("^-?\\d+(\\.\\d+)?$");

Я предпочитаю использовать цикл по символу Строк [] представление и использовать Character.isDigit () метод. Если элегантность желаема, я думаю, что это является самым читаемым:

package tias;

public class Main {
  private static final String NUMERIC = "123456789";
  private static final String NOT_NUMERIC = "1L5C";

  public static void main(String[] args) {
    System.out.println(isStringNumeric(NUMERIC));
    System.out.println(isStringNumeric(NOT_NUMERIC));
  }

  private static boolean isStringNumeric(String aString) {
    if (aString == null || aString.length() == 0) {
      return false;
    }
    for (char c : aString.toCharArray() ) {
      if (!Character.isDigit(c)) {
        return false;
      }
    }
    return true;
  }

}

Если Вы хотите что-то, что это горячо быстро, и у Вас есть очень четкое представление о том, какие форматы Вы хотите принять, можно создать конечный автомат DFA вручную. Это по существу, как regexes работают под капотом так или иначе, но можно избежать regex шага компиляции этот путь, и это может быть быстрее, чем универсальный regex компилятор.