Quelle est la meilleure façon de vérifier si une Chaîne de caractères représente un nombre entier en Java?

Vous l'avez, mais vous ne devez attraper NumberFormatException.

Puisqu'il y a possibilité que les gens continuent de visiter ici et seront biaisés contre les Regex après les benchmarks... Donc je vais donner une version mise à jour de l'indice de référence, avec une version compilée de la Regex. Qui s'est opposée à la précédente repères, cette montre Regex solution en fait a toujours de bonnes performances.

Copié à partir de Bill le Lézard et mis à jour avec la version compilée:

private final Pattern pattern = Pattern.compile("^-?\\d+$");
public void runTests() {
String big_int = "1234567890";
String non_int = "1234XY7890";
long startTime = System.currentTimeMillis();
for(int i = 0; i < 100000; i++)
IsInt_ByException(big_int);
long endTime = System.currentTimeMillis();
System.out.print("ByException - integer data: ");
System.out.println(endTime - startTime);
startTime = System.currentTimeMillis();
for(int i = 0; i < 100000; i++)
IsInt_ByException(non_int);
endTime = System.currentTimeMillis();
System.out.print("ByException - non-integer data: ");
System.out.println(endTime - startTime);
startTime = System.currentTimeMillis();
for(int i = 0; i < 100000; i++)
IsInt_ByRegex(big_int);
endTime = System.currentTimeMillis();
System.out.print("\nByRegex - integer data: ");
System.out.println(endTime - startTime);
startTime = System.currentTimeMillis();
for(int i = 0; i < 100000; i++)
IsInt_ByRegex(non_int);
endTime = System.currentTimeMillis();
System.out.print("ByRegex - non-integer data: ");
System.out.println(endTime - startTime);
startTime = System.currentTimeMillis();
for (int i = 0; i < 100000; i++)
IsInt_ByCompiledRegex(big_int);
endTime = System.currentTimeMillis();
System.out.print("\nByCompiledRegex - integer data: ");
System.out.println(endTime - startTime);
startTime = System.currentTimeMillis();
for (int i = 0; i < 100000; i++)
IsInt_ByCompiledRegex(non_int);
endTime = System.currentTimeMillis();
System.out.print("ByCompiledRegex - non-integer data: ");
System.out.println(endTime - startTime);
startTime = System.currentTimeMillis();
for(int i = 0; i < 100000; i++)
IsInt_ByJonas(big_int);
endTime = System.currentTimeMillis();
System.out.print("\nByJonas - integer data: ");
System.out.println(endTime - startTime);
startTime = System.currentTimeMillis();
for(int i = 0; i < 100000; i++)
IsInt_ByJonas(non_int);
endTime = System.currentTimeMillis();
System.out.print("ByJonas - non-integer data: ");
System.out.println(endTime - startTime);
}
private boolean IsInt_ByException(String str)
{
try
{
Integer.parseInt(str);
return true;
}
catch(NumberFormatException nfe)
{
return false;
}
}
private boolean IsInt_ByRegex(String str)
{
return str.matches("^-?\\d+$");
}
private boolean IsInt_ByCompiledRegex(String str) {
return pattern.matcher(str).find();
}
public boolean IsInt_ByJonas(String str)
{
if (str == null) {
return false;
}
int length = str.length();
if (length == 0) {
return false;
}
int i = 0;
if (str.charAt(0) == '-') {
if (length == 1) {
return false;
}
i = 1;
}
for (; i < length; i++) {
char c = str.charAt(i);
if (c <= '/' || c >= ':') {
return false;
}
}
return true;
}

Résultats:

ByException - integer data: 45
ByException - non-integer data: 465
ByRegex - integer data: 272
ByRegex - non-integer data: 131
ByCompiledRegex - integer data: 45
ByCompiledRegex - non-integer data: 26
ByJonas - integer data: 8
ByJonas - non-integer data: 2

Il dépend en partie de ce que vous entendez par "peut être converti en entier".

Si vous voulez dire "peut être converti en int en Java", alors la réponse de Jonas est un bon début, mais n'a pas tout à fait terminer le travail. Il passerait 999999999999999999999999999999 par exemple. Je voudrais ajouter à la normale try/catch appel à partir de votre propre question à la fin de la méthode.

Le caractère par caractère vérifie de façon efficace les rejeter "pas un nombre entier, à tous les" en cas, quitter "c'est un entier, mais Java ne peut pas le manipuler" les cas d'être pris par le ralentissement de l'exception de l'itinéraire. Vous pourrait faire ce peu à la main aussi, mais ce serait une beaucoup plus compliqué.

J'ai copié le code de rally25rs réponse, et a ajouté quelques tests pour les données non entier. Les résultats sont indéniablement en faveur de la méthode posté par Jonas Klemming. Les résultats de l'Exception de la méthode que j'ai posté sont assez bien quand vous avez des données entier, mais ils sont les pires quand vous ne le faites pas, alors que les résultats pour l'expression rationnelle de la solution (que je parie que beaucoup de gens utilisent) ont été constamment mauvais. Voir Felipe répondre pour la compilation d'un regex exemple, qui est beaucoup plus rapide.

public void runTests()
{
String big_int = "1234567890";
String non_int = "1234XY7890";
long startTime = System.currentTimeMillis();
for(int i = 0; i < 100000; i++)
IsInt_ByException(big_int);
long endTime = System.currentTimeMillis();
System.out.print("ByException - integer data: ");
System.out.println(endTime - startTime);
startTime = System.currentTimeMillis();
for(int i = 0; i < 100000; i++)
IsInt_ByException(non_int);
endTime = System.currentTimeMillis();
System.out.print("ByException - non-integer data: ");
System.out.println(endTime - startTime);
startTime = System.currentTimeMillis();
for(int i = 0; i < 100000; i++)
IsInt_ByRegex(big_int);
endTime = System.currentTimeMillis();
System.out.print("\nByRegex - integer data: ");
System.out.println(endTime - startTime);
startTime = System.currentTimeMillis();
for(int i = 0; i < 100000; i++)
IsInt_ByRegex(non_int);
endTime = System.currentTimeMillis();
System.out.print("ByRegex - non-integer data: ");
System.out.println(endTime - startTime);
startTime = System.currentTimeMillis();
for(int i = 0; i < 100000; i++)
IsInt_ByJonas(big_int);
endTime = System.currentTimeMillis();
System.out.print("\nByJonas - integer data: ");
System.out.println(endTime - startTime);
startTime = System.currentTimeMillis();
for(int i = 0; i < 100000; i++)
IsInt_ByJonas(non_int);
endTime = System.currentTimeMillis();
System.out.print("ByJonas - non-integer data: ");
System.out.println(endTime - startTime);
}
private boolean IsInt_ByException(String str)
{
try
{
Integer.parseInt(str);
return true;
}
catch(NumberFormatException nfe)
{
return false;
}
}
private boolean IsInt_ByRegex(String str)
{
return str.matches("^-?\\d+$");
}
public boolean IsInt_ByJonas(String str)
{
if (str == null) {
return false;
}
int length = str.length();
if (length == 0) {
return false;
}
int i = 0;
if (str.charAt(0) == '-') {
if (length == 1) {
return false;
}
i = 1;
}
for (; i < length; i++) {
char c = str.charAt(i);
if (c <= '/' || c >= ':') {
return false;
}
}
return true;
}

Résultats:

ByException - integer data: 47
ByException - non-integer data: 547
ByRegex - integer data: 390
ByRegex - non-integer data: 313
ByJonas - integer data: 0
ByJonas - non-integer data: 16

C'est plus courte, mais plus court n'est pas forcément mieux (et il ne sera pas attraper des valeurs entières qui sont hors de portée, comme l'a souligné dans danatel commentaire):

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

Personnellement, depuis la mise en œuvre est squirrelled loin dans une méthode d'aide et de l'exactitude des atouts de la longueur, je voudrais juste aller avec quelque chose comme ce que vous avez (moins la capture de la base de Exception classe plutôt que de NumberFormatException).

Comment sur:

return Pattern.matches("-?\\d+", input);

Vous suffit de cocher NumberFormatException:-

 String value="123";
try  
{  
int s=Integer.parseInt(any_int_val);
//do something when integer values comes 
}  
catch(NumberFormatException nfe)  
{  
//do something when string values comes 
}  

Vous pouvez également utiliser le Scanner de classe, et l'utilisation hasNextInt() - et cela vous permet de tester d'autres types, comme des flotteurs, etc.

Vous avez probablement besoin de prendre le cas d'utilisation en compte:

Si la plupart du temps vous vous attendez à des nombres pour être valide, la capture de l'exception n'est qu'en provoquant une surcharge de performance lors de la tentative de convertir les numéros non valides. Alors que l'appel de certains isInteger() méthode et ensuite de les convertir à l'aide de Integer.parseInt() sera toujours cause d'une surcharge de performance pour la validité des numéros - les cordes sont analysés deux fois, une fois par la case et une fois par la conversion.

Si vous utilisez l'API Android, vous pouvez utiliser:

TextUtils.isDigitsOnly(str);

Si vous voulez vérifier si la chaîne de caractères représente un entier qui correspond à un type int, j'ai fait une petite modification à l'jonas répondre, de sorte que les chaînes de caractères qui représentent des nombres entiers plus grands que Entier.MAX_VALUE ou plus petit que Entier.MIN_VALUE, sera de retour faux. Par exemple: "3147483647" sera de retour faux car 3147483647 est plus grand que 2147483647, et de même, "-2147483649" sera également de retour faux car -2147483649 est plus petit que -2147483648.

public static boolean isInt(String s) {
if(s == null) {
return false;
}
s = s.trim(); //Don't get tricked by whitespaces.
int len = s.length();
if(len == 0) {
return false;
}
//The bottom limit of an int is -2147483648 which is 11 chars long.
//[note that the upper limit (2147483647) is only 10 chars long]
//Thus any string with more than 11 chars, even if represents a valid integer, 
//it won't fit in an int.
if(len > 11) {
return false;
}
char c = s.charAt(0);
int i = 0;
//I don't mind the plus sign, so "+13" will return true.
if(c == '-' || c == '+') {
//A single "+" or "-" is not a valid integer.
if(len == 1) {
return false;
}
i = 1;
}
//Check if all chars are digits
for(; i < len; i++) {
c = s.charAt(i);
if(c < '0' || c > '9') {
return false;
}
}
//If we reached this point then we know for sure that the string has at
//most 11 chars and that they're all digits (the first one might be a '+'
//or '-' thought).
//Now we just need to check, for 10 and 11 chars long strings, if the numbers
//represented by the them don't surpass the limits.
c = s.charAt(0);
char l;
String limit;
if(len == 10 && c != '-' && c != '+') {
limit = "2147483647";
//Now we are going to compare each char of the string with the char in
//the limit string that has the same index, so if the string is "ABC" and
//the limit string is "DEF" then we are gonna compare A to D, B to E and so on.
//c is the current string's char and l is the corresponding limit's char
//Note that the loop only continues if c == l. Now imagine that our string
//is "2150000000", 2 == 2 (next), 1 == 1 (next), 5 > 4 as you can see,
//because 5 > 4 we can guarantee that the string will represent a bigger integer.
//Similarly, if our string was "2139999999", when we find out that 3 < 4,
//we can also guarantee that the integer represented will fit in an int.
for(i = 0; i < len; i++) {
c = s.charAt(i);
l = limit.charAt(i);
if(c > l) {
return false;
}
if(c < l) {
return true;
}
}
}
c = s.charAt(0);
if(len == 11) {
//If the first char is neither '+' nor '-' then 11 digits represent a 
//bigger integer than 2147483647 (10 digits).
if(c != '+' && c != '-') {
return false;
}
limit = (c == '-') ? "-2147483648" : "+2147483647";
//Here we're applying the same logic that we applied in the previous case
//ignoring the first char.
for(i = 1; i < len; i++) {
c = s.charAt(i);
l = limit.charAt(i);
if(c > l) {
return false;
}
if(c < l) {
return true;
}
}
}
//The string passed all tests, so it must represent a number that fits
//in an int...
return true;
}

Ce que vous avez fait des œuvres, mais vous ne devriez probablement pas de toujours vérifier de cette façon. De lever des exceptions doit être réservée aux situations "exceptionnelles" (peut-être qui s'adapte à votre cas, tout de même), et sont très coûteuses en termes de performances.

Cela ne peut fonctionner que pour des entiers positifs.

public static boolean isInt(String str) {
if (str != null && str.length() != 0) {
for (int i = 0; i < str.length(); i++) {
if (!Character.isDigit(str.charAt(i))) return false;
}
}
return true;        
}

Pour vérifier tous les int caractères, vous pouvez simplement utiliser un double négatif.

if (!searchString.matchs("[^0-9]+$")) ...

[^0-9]+$ vérifie s'il y a des caractères qui ne sont pas entiers, de sorte que le test échoue si c'est vrai. PAS juste que, et vous obtenez true en cas de succès.

Je crois qu'il y a zéro risque en cours d'exécution dans une exception, parce que comme vous pouvez le voir ci-dessous vous toujours en toute sécurité analyser int à String et non l'inverse.

Donc:

1. Vous vérifier si chaque slot de personnage dans votre chaîne de caractères correspond au moins à
   l'un des personnages {"0","1","2","3","4","5","6","7","8","9"}.

   if(aString.substring(j, j+1).equals(String.valueOf(i)))

2. Vous somme toutes les fois que vous avez rencontré dans les emplacements ci-dessus
   des personnages.

   digits++;

3. Et enfin, vous vérifier si le temps que vous avez rencontré des nombres entiers comme
   caractères est égale à la longueur de la chaîne.

   if(digits == aString.length())

Et, dans la pratique, nous avons:

    String aString = "1234224245";
int digits = 0;//count how many digits you encountered
for(int j=0;j<aString.length();j++){
for(int i=0;i<=9;i++){
if(aString.substring(j, j+1).equals(String.valueOf(i)))
digits++;
}
}
if(digits == aString.length()){
System.out.println("It's an integer!!");
}
else{
System.out.println("It's not an integer!!");
}
String anotherString = "1234f22a4245";
int anotherDigits = 0;//count how many digits you encountered
for(int j=0;j<anotherString.length();j++){
for(int i=0;i<=9;i++){
if(anotherString.substring(j, j+1).equals(String.valueOf(i)))
anotherDigits++;
}
}
if(anotherDigits == anotherString.length()){
System.out.println("It's an integer!!");
}
else{
System.out.println("It's not an integer!!");
}

Et les résultats sont les suivants:

C'est un entier!!

Ce n'est pas un entier!!

De la même façon, vous pouvez vérifier si un String est un float ou un double mais dans ces cas, vous avez à rencontrer seul . (dot) dans la Chaîne et, bien sûr vérifier si digits == (aString.length()-1)

Encore une fois, il y a zéro risque en cours d'exécution dans une analyse exception ici, mais si vous prévoyez sur l'analyse d'une chaîne de caractères qu'il est connu que contient un certain nombre (disons int type de données), vous devez d'abord vérifier si elle correspond au type de données. Sinon, vous devez le jeter.

J'espère que j'ai aidé

J'ai vu beaucoup de réponses ici, mais la plupart d'entre eux sont en mesure de déterminer si la Chaîne est numérique, mais ils ne parviennent pas à vérifier si le numéro est dans l'intervalle Entier...

Donc j'ai voulu quelque chose comme ceci:

public static boolean isInteger(String str) {
if (str == null || str.isEmpty()) {
return false;
}
try {
long value = Long.valueOf(str);
return value >= -2147483648 && value <= 2147483647;
} catch (Exception ex) {
return false;
}
}

Je n'aime pas la méthode avec la regex, parce que la regex ne peut pas vérifier les plages (Integer.MIN_VALUE, Integer.MAX_VALUE).

Si vous vous attendez int valeur dans la plupart des cas, et pas int est quelque chose de rare, alors je suggère version avec Integer.valueOf ou Integer.parseInt avec NumberFormatException attraper. L'avantage de cette approche - votre code a bien des raisons de lisibilité:

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

Si vous avez besoin de vérifier si la Chaîne est de type entier, et se soucient de perfomance alors le meilleur moyen est d'utiliser le jdk java mise en œuvre de Integer.parseInt, mais peu modifiée (en remplacement de lancer avec return false):

Cette fonction a une bonne perfomence et de la garantie de bon résultat:

   public static boolean isInt(String s) {
int radix = 10;
if (s == null) {
return false;
}
if (radix < Character.MIN_RADIX) {
return false;
}
if (radix > Character.MAX_RADIX) {
return false;
}
int result = 0;
boolean negative = false;
int i = 0, len = s.length();
int limit = -Integer.MAX_VALUE;
int multmin;
int digit;
if (len > 0) {
char firstChar = s.charAt(0);
if (firstChar < '0') { //Possible leading "+" or "-"
if (firstChar == '-') {
negative = true;
limit = Integer.MIN_VALUE;
} else if (firstChar != '+')
return false;
if (len == 1) //Cannot have lone "+" or "-"
return false;
i++;
}
multmin = limit / radix;
while (i < len) {
//Accumulating negatively avoids surprises near MAX_VALUE
digit = Character.digit(s.charAt(i++), radix);
if (digit < 0) {
return false;
}
if (result < multmin) {
return false;
}
result *= radix;
if (result < limit + digit) {
return false;
}
result -= digit;
}
} else {
return false;
}
return true;
}

Integer.valueOf(string); 

fonctionne pour moi la plupart du temps!