web-dev-qa-db-fra.com

Comment vérifier si une chaîne ne contient que des chiffres dans Java

Dans Java pour la classe String, il existe une méthode appelée correspond, comment utiliser cette méthode pour vérifier si ma chaîne contient uniquement des chiffres utilisant une expression régulière. J'ai essayé avec les exemples ci-dessous, mais les deux m'ont renvoyé faux comme résultat.

String regex = "[0-9]";
String data = "23343453";
System.out.println(data.matches(regex));

String regex = "^[0-9]";
String data = "23343453";
System.out.println(data.matches(regex));
javastring
134
Chaitanya

Essayer

String regex = "[0-9]+";

ou

String regex = "\\d+";

Selon Java expressions régulières , le + signifie "une ou plusieurs fois" et \d signifie "un chiffre".

Remarque: la "double barre oblique inversée" est une séquence d'échappement permettant d'obtenir une seule barre oblique inversée. Par conséquent, \\d dans une chaîne Java vous donne la valeur réelle. résultat: \d

Références:

Edit: En raison d'une certaine confusion dans les autres réponses, je suis en train d'écrire un scénario de test et expliquerai quelques détails supplémentaires.

Tout d'abord, si vous avez des doutes sur l'exactitude de cette solution (ou d'autres solutions), exécutez le scénario de test suivant:

String regex = "\\d+";

// positive test cases, should all be "true"
System.out.println("1".matches(regex));
System.out.println("12345".matches(regex));
System.out.println("123456789".matches(regex));

// negative test cases, should all be "false"
System.out.println("".matches(regex));
System.out.println("foo".matches(regex));
System.out.println("aa123bb".matches(regex));

Question 1:

N’est-il pas nécessaire d’ajouter ^ et $ à la regex pour qu’elle ne corresponde pas à "aa123bb"?

Non. En Java, la méthode matches (spécifiée dans la question) correspond à une chaîne complète et non à des fragments. En d'autres termes, il n'est pas nécessaire d'utiliser ^\\d+$ (même s'il est également correct). Veuillez voir le dernier cas de test négatif.

Veuillez noter que si vous utilisez un "vérificateur de regex" en ligne, cela peut se comporter différemment. Pour faire correspondre des fragments d'une chaîne en Java, vous pouvez utiliser la méthode find, décrite en détail ici:

Différence entre matches () et find () dans Java Regex

Question 2:

Cette expression rationnelle ne correspond-elle pas également à la chaîne vide, ""? *

Non. Une expression rationnelle \\d* correspond à la chaîne vide, mais \\d+ ne correspond pas. L'étoile * signifie zéro ou plus, alors que le plus + signifie un ou plusieurs. Veuillez voir le premier cas de test négatif.

Question 3

N'est-il pas plus rapide de compiler un motif regex?

Oui. Il est en effet plus rapide de compiler un motif regex une fois que plutôt à chaque invocation de matches, et donc si les implications en termes de performances sont importantes alors un Pattern peut être compilé et utilisé comme ceci:

Pattern pattern = Pattern.compile(regex);
System.out.println(pattern.matcher("1").matches());
System.out.println(pattern.matcher("12345").matches());
System.out.println(pattern.matcher("123456789").matches());
311
vikingsteve

Vous pouvez également utiliser NumberUtil.isNumber (String str) à partir d'Apache Commons

33
Apurv

Une autre solution, qui n'a pas encore été postée:

String regex = "\\p{Digit}+"; // uses POSIX character class
8
jlordo
Long.parseLong(data)

et attraper une exception, il gère le signe moins.

Bien que le nombre de chiffres soit limité, cela crée en fait une variable des données pouvant être utilisées, ce qui est, je suppose, le cas d'utilisation le plus courant.

5
NimChimpsky

Vous devez autoriser plus d’un chiffre (le signe +) comme dans:

String regex = "[0-9]+"; 
String data = "23343453"; 
System.out.println(data.matches(regex));
5
Carlo Pellegrini

L'utilisation d'expressions régulières est coûteuse en termes de performances. Essayer d'analyser une chaîne comme une valeur longue est inefficace et peu fiable, et peut ne pas être ce dont vous avez besoin.

Je suggère simplement de vérifier si chaque caractère est un chiffre, ce qui peut être efficacement fait en utilisant Java 8 expressions lambda:

boolean isNumeric = someString.chars().allMatch(x -> Character.isDigit(x));
5
Max Malysh

Selon la Java Documentation d'Oracle:

private static final Pattern NUMBER_PATTERN = Pattern.compile(
        "[\\x00-\\x20]*[+-]?(NaN|Infinity|((((\\p{Digit}+)(\\.)?((\\p{Digit}+)?)" +
        "([eE][+-]?(\\p{Digit}+))?)|(\\.((\\p{Digit}+))([eE][+-]?(\\p{Digit}+))?)|" +
        "(((0[xX](\\p{XDigit}+)(\\.)?)|(0[xX](\\p{XDigit}+)?(\\.)(\\p{XDigit}+)))" +
        "[pP][+-]?(\\p{Digit}+)))[fFdD]?))[\\x00-\\x20]*");
boolean isNumber(String s){
return NUMBER_PATTERN.matcher(s).matches()
}
1
user3034617

Nous pouvons utiliser soit Pattern.compile("[0-9]+.[0-9]+") ou Pattern.compile("\\d+.\\d+"). Ils ont la même signification.

le motif [0-9] signifie un chiffre. Identique à '\ d'. "+" signifie qu'il apparaît plus de fois. '.' pour entier ou float.

Essayez le code suivant:

import Java.util.regex.Pattern;

    public class PatternSample {

        public boolean containNumbersOnly(String source){
            boolean result = false;
            Pattern pattern = Pattern.compile("[0-9]+.[0-9]+"); //correct pattern for both float and integer.
            pattern = Pattern.compile("\\d+.\\d+"); //correct pattern for both float and integer.

            result = pattern.matcher(source).matches();
            if(result){
                System.out.println("\"" + source + "\""  + " is a number");
            }else
                System.out.println("\"" + source + "\""  + " is a String");
            return result;
        }

        public static void main(String[] args){
            PatternSample obj = new PatternSample();
            obj.containNumbersOnly("123456.a");
            obj.containNumbersOnly("123456 ");
            obj.containNumbersOnly("123456");
            obj.containNumbersOnly("0123456.0");
            obj.containNumbersOnly("0123456a.0");
        }

    }

Sortie:

"123456.a" is a String
"123456 " is a String
"123456" is a number
"0123456.0" is a number
"0123456a.0" is a String
0
Luan Vo

Essayez cette partie du code:

void containsOnlyNumbers(String str)
{
    try {
        Integer num = Integer.valueOf(str);
        System.out.println("is a number");
    } catch (NumberFormatException e) {
        // TODO: handle exception
        System.out.println("is not a number");
    }

}
0
siva