La plus élégante façon de détecter si une Chaîne est un nombre?

Vous pouvez utiliser une expression régulière, c'est à dire quelque chose comme String.matches("^[\\d\\-\\.]+$"); (si vous n'êtes pas de test pour les nombres négatifs ou des nombres à virgule flottante vous pouvez simplifier un peu).

Pas sûr que cela serait plus rapide que la méthode que vous avez décrites.

Edit: à la lumière de toute cette controverse, j'ai décidé de faire un test et obtenir quelques données sur la façon rapide de chacune de ces méthodes ont été. Non pas tant l'exactitude, mais juste comment rapidement ils ont couru.

Vous pouvez lire à propos de mes résultats sur mon blog. (Astuce: Jon Skeet FTW).

OriginalL'auteur

La bonne regex est donné dans le Double javadoc:

Pour éviter l'appel de cette méthode sur une chaîne non valide et avoir un NumberFormatException être jetés, l'expression régulière ci-dessous peut être utilisé pour l'écran de la chaîne d'entrée:

    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
    }

Cela ne permet pas pour localisées représentations, cependant:

À interpréter localisée représentations de chaîne de valeur à virgule flottante, l'utilisation des sous-classes de NumberFormat.

OriginalL'auteur Michael Myers

Profitant de M. 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;
    }
}

OriginalL'auteur plinth

La plupart de ces réponses sont un peu des solutions acceptables. Tous les regex solutions de la question des ne pas être correcte pour tous les cas, vous pouvez s'inquiéter.

Si vous voulez vraiment vous assurer que la Chaîne est un nombre valide, alors je voudrais utiliser votre propre solution. N'oubliez pas que, j'imagine, que la plupart du temps, la Chaîne sera un valide nombre et ne lèvera une exception. Ainsi, la plupart du temps, les performances seront identiques à celui de la Double.valueOf().

Je suppose que ce n'est pas vraiment une réponse, sauf qu'il valide votre premier instinct.

Randy

OriginalL'auteur Randy Stegbauer

Je préfère utiliser une boucle sur les Chaînes de caractères de type char[] de la représentation et de l'utilisation du Personnage.appel isdigit() la méthode. Si l'élégance est souhaité, je pense que c'est le plus lisible:

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

}

OriginalL'auteur