Meilleure mise en œuvre pour un isNumber(string) méthode

J'ai juste couru quelques repères sur les performances de ces 2 méthodes (Sur Macbook Pro OSX Leopard Java 6). ParseInt est plus rapide. Voici le résultat:

This operation took 1562 ms.
This operation took 2251 ms.

Et voici mon code de référence:

public class IsIntegerPerformanceTest {

    public static boolean isIntegerParseInt(String str) {
        try {
            Integer.parseInt(str);
            return true;
        } catch (NumberFormatException nfe) {}
        return false;
    }

    public static boolean isIntegerRegex(String str) {
        return str.matches("^[0-9]+$");
    }

    public static void main(String[] args) {
        long starttime, endtime;
        int iterations = 1000000;
        starttime = System.currentTimeMillis();
        for (int i=0; i<iterations; i++) {
            isIntegerParseInt("123");
            isIntegerParseInt("not an int");
            isIntegerParseInt("-321");
        }
        endtime = System.currentTimeMillis();
        System.out.println("This operation took " + (endtime - starttime) + " ms.");
        starttime = System.currentTimeMillis();
        for (int i=0; i<iterations; i++) {
            isIntegerRegex("123");
            isIntegerRegex("not an int");
            isIntegerRegex("-321");
        }
        endtime = System.currentTimeMillis();
        System.out.println("This operation took " + (endtime - starttime) + " ms.");
    }
}

Notez également que votre regex de rejeter les nombres négatifs et la méthode parseInt va les accepter.

Si absolue la performance est la clé, et si vous êtes juste de vérification pour les entiers (et non des nombres à virgule flottante) je soupçonne que itération sur chaque caractère de la chaîne, retourner false si vous rencontrez quelque chose de pas dans la gamme de 0 à 9, sera la plus rapide.

RegEx est un plus généraliste solution ne sera donc probablement pas aussi rapide pour ce cas particulier. Une solution qui déclenche une exception aura quelques frais généraux supplémentaires dans ce cas. TryParse sera légèrement de plus si vous n'avez pas de soins sur la valeur de ce nombre, si oui ou non il est un certain nombre, puisque la conversion d'un nombre doit également avoir lieu.

Pour rien, mais une boucle interne qui a appelé à de nombreuses reprises, les différences entre toutes ces options doivent être insignifiants.

Certains langages, comme le C#, ont un TryParse (ou l'équivalent) qui fonctionne assez bien pour quelque chose comme ça.

public boolean IsInteger(string value)
{
  int i;
  return Int32.TryParse(value, i);
}

Vous pouvez créer une méthode d'extension pour une chaîne de caractères, et de rendre l'ensemble du processus de regarder plus propre...

public static bool IsInt(this string str)
{
    int i;
    return int.TryParse(str, out i);
}

Vous pouvez ensuite effectuer les opérations suivantes dans votre code...

if(myString.IsInt())....

public static boolean CheckString(String myString) {

char[] digits;

    digits = myString.toCharArray();
    for (char div : digits) {//for each element div of type char in the digits collection (digits is a collection containing div elements).
        try {
            Double.parseDouble(myString);
            System.out.println("All are numbers");
            return true;
        } catch (NumberFormatException e) {

            if (Character.isDigit(div)) {
                System.out.println("Not all are chars");

                return false;
            }
        }
    }

    System.out.println("All are chars");
    return true;
}

J'ai comme code:

public static boolean isIntegerRegex(String str) {
    return str.matches("^[0-9]+$");
}

Mais il sera bien plus lors de la création de Modèle avant de l'utiliser:

public static Pattern patternInteger = Pattern.compile("^[0-9]+$");
public static boolean isIntegerRegex(String str) {
  return patternInteger.matcher(str).matches();
}

S'appliquent, par l'épreuve, nous avons le résultat:

This operation isIntegerParseInt took 1313 ms.
This operation isIntegerRegex took 1178 ms.
This operation isIntegerRegexNew took 304 ms.

Avec:

public class IsIntegerPerformanceTest {
private static Pattern pattern = Pattern.compile("^[0-9]+$");
public static boolean isIntegerParseInt(String str) {
try {
Integer.parseInt(str);
return true;
} catch (NumberFormatException nfe) {
}
return false;
}
public static boolean isIntegerRegexNew(String str) {
return pattern.matcher(str).matches();
}
public static boolean isIntegerRegex(String str) {
return str.matches("^[0-9]+$");
}
public static void main(String[] args) {
long starttime, endtime;
int iterations = 1000000;
starttime = System.currentTimeMillis();
for (int i = 0; i < iterations; i++) {
isIntegerParseInt("123");
isIntegerParseInt("not an int");
isIntegerParseInt("-321");
}
endtime = System.currentTimeMillis();
System.out.println("This operation isIntegerParseInt took " + (endtime - starttime) + " ms.");
starttime = System.currentTimeMillis();
for (int i = 0; i < iterations; i++) {
isIntegerRegex("123");
isIntegerRegex("not an int");
isIntegerRegex("-321");
}
endtime = System.currentTimeMillis();
System.out.println("This operation took isIntegerRegex " + (endtime - starttime) + " ms.");
starttime = System.currentTimeMillis();
for (int i = 0; i < iterations; i++) {
isIntegerRegexNew("123");
isIntegerRegexNew("not an int");
isIntegerRegexNew("-321");
}
endtime = System.currentTimeMillis();
System.out.println("This operation took isIntegerRegexNew " + (endtime - starttime) + " ms.");
}
}

Je pense que les gens ici manque un point. L'utilisation de la même motif à plusieurs reprises est très facile d'optimisation. Il suffit d'utiliser un singleton de la répétition. De le faire, dans tous mes tests le try-catch approche ne jamais avoir une meilleure référence que le modèle de l'approche. Avec un succès de test try-catch prend deux fois plus de temps, avec un échec de test il est 6 fois plus lent.

public static final Pattern INT_PATTERN= Pattern.compile("^-?[0-9]+(\\.[0-9]+)?$");
public static boolean isInt(String s){
return INT_PATTERN.matcher(s).matches();
}

Pendant de longues numéros d'utiliser ceci:
(JAVA)

public static boolean isNumber(String string) {
try {
Long.parseLong(string);
} catch (Exception e) {
return false;
}
return true;
}

Une version modifiée de ma réponse précédente:

public static boolean isInteger(String in)
{
if (in != null)
{
char c;
int i = 0;
int l = in.length();
if (l > 0 && in.charAt(0) == '-')
{
i = 1;
}
if (l > i)
{
for (; i < l; i++)
{
c = in.charAt(i);
if (c < '0' || c > '9')
return false;
}
return true;
}
}
return false;
}

public static boolean CheckIfNumber(numéro de Chaîne){

    for(int i = 0; i < number.length(); i++){
try{
Double.parseDouble(number.substring(i));
}catch(NumberFormatException ex){
return false;
}
}
return true;     
}

J'ai eu ce problème avant, mais quand j'ai eu un nombre, puis un personnage, il serait toujours revenir en vrai, je pense que c'est la meilleure manière de le faire. Il suffit de vérifier si chaque char est un nombre. Un peu plus long, mais il prend soin si vous avez de la situation d'un utilisateur saisie "1abc". Pour quelque raison, quand j'ai essayé de try et catch sans itération, il a toujours pensé que c'était un numéro..