Quel est le meilleur moyen de vérifier si une chaîne représente un entier en Java?
J'utilise normalement l'idiome suivant pour vérifier si une chaîne peut être convertie en un entier.
public boolean isInteger( String input ) {
try {
Integer.parseInt( input );
return true;
}
catch( Exception e ) {
return false;
}
}
Est-ce juste moi, ou est-ce que cela semble un peu féroce? Quel est le meilleur moyen?
Voir ma réponse (avec des points de repère, sur la base de la réponse précédente de CodingWithSpike ) pour voir pourquoi j'ai inversé ma position et accepté la réponse de Jonas Klemming à ce problème. Je pense que ce code original sera utilisé par la plupart des gens car il est plus rapide à mettre en œuvre et plus facile à gérer, mais il est beaucoup plus lent lorsque des données non entières sont fournies.
Si vous n'êtes pas concerné par des problèmes de débordement potentiels, cette fonction sera environ 20-30 fois plus rapide que d'utiliser Integer.parseInt().
public static boolean isInteger(String str) {
if (str == null) {
return false;
}
if (str.isEmpty()) {
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 < '0' || c > '9') {
return false;
}
}
return true;
}
Vous l'avez, mais vous ne devez attraper que NumberFormatException.
Fait un repère rapide. Les exceptions ne coûtent en réalité pas très cher, sauf si vous commencez à récupérer plusieurs méthodes et que la machine virtuelle Java doit effectuer beaucoup de travail pour mettre en place la pile d'exécution. En restant dans la même méthode, ils ne sont pas mauvais.
public void RunTests()
{
String str = "1234567890";
long startTime = System.currentTimeMillis();
for(int i = 0; i < 100000; i++)
IsInt_ByException(str);
long endTime = System.currentTimeMillis();
System.out.print("ByException: ");
System.out.println(endTime - startTime);
startTime = System.currentTimeMillis();
for(int i = 0; i < 100000; i++)
IsInt_ByRegex(str);
endTime = System.currentTimeMillis();
System.out.print("ByRegex: ");
System.out.println(endTime - startTime);
startTime = System.currentTimeMillis();
for(int i = 0; i < 100000; i++)
IsInt_ByJonas(str);
endTime = System.currentTimeMillis();
System.out.print("ByJonas: ");
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;
}
Sortie:
Par exception: 31
ByRegex: 453 (note: recompiler le motif à chaque fois)
ByJonas: 16
Je conviens que la solution de Jonas K est aussi la plus robuste. On dirait qu'il gagne :)
Puisqu'il est possible que les gens visitent encore ici et qu'ils soient biaisés contre Regex après les points de repère ... Je vais donc vous donner une version mise à jour du point de repère, avec une version compilée du Regex. Ce qui, contrairement aux précédents, montre que la solution Regex a toujours de bonnes performances.
Copié de Bill the Lizard 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
org.Apache.commons.lang.StringUtils.isNumeric
si la bibliothèque standard de Java manque vraiment de telles fonctions utilitaires
Je pense qu'Apache Commons est un "must have" pour tout programmeur Java
dommage qu'il ne soit pas encore porté sur Java5
Cela dépend en partie de ce que vous voulez dire par "peut être converti en un entier".
Si vous voulez dire "peut être converti en int en Java", la réponse de Jonas est un bon début, mais ne termine pas tout à fait le travail. Il passerait par exemple au 99999999999999999999999999999999. Je voudrais ajouter l'appel try/catch normal de votre propre question à la fin de la méthode.
Les vérifications caractère par caractère rejetteront efficacement les cas "pas un entier du tout", laissant "c'est un entier mais Java ne peut pas le gérer" afin de pouvoir intercepter la route d'exception plus lente. Vous pourriez le faire à la main aussi, mais ce serait un lot plus compliqué.
Juste un commentaire à propos de regexp. Tous les exemples fournis ici sont faux! Si vous voulez utiliser regexp, n'oubliez pas que la compilation du motif prend beaucoup de temps. Ce:
str.matches("^-?\\d+$")
et aussi ceci:
Pattern.matches("-?\\d+", input);
provoque la compilation du motif dans chaque appel de méthode. Pour l'utiliser correctement, suivez:
import Java.util.regex.Pattern;
/**
* @author Rastislav Komara
*/
public class NaturalNumberChecker {
public static final Pattern PATTERN = Pattern.compile("^\\d+$");
boolean isNaturalNumber(CharSequence input) {
return input != null && PATTERN.matcher(input).matches();
}
}
J'ai copié le code de la réponse rally25rs et ajouté quelques tests pour les données non entières. Les résultats sont indéniablement en faveur de la méthode publiée par Jonas Klemming. Les résultats de la méthode Exception que j'ai initialement publiés sont plutôt bons lorsque vous avez des données entières, mais ils sont les pires lorsque vous ne les avez pas, tandis que les résultats de la solution RegEx (que beaucoup de gens utiliseront parier) étaient constamment mauvais. Voir La réponse de Felipe pour un exemple de regex compilé, 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
Il existe une version goyave:
import com.google.common.primitives.Ints;
Integer intValue = Ints.tryParse(stringValue);
Il renverra null au lieu de déclencher une exception s'il ne parvient pas à analyser la chaîne.
C'est plus court, mais plus court n'est pas nécessairement meilleur (et il ne capture pas les valeurs entières qui sont hors limites, comme indiqué dans le commentaire de danatel ):
input.matches("^-?\\d+$");
Personnellement, étant donné que l'implémentation est gâchée par une méthode d'assistance et que la correction l'emporte sur la longueur, je voudrais simplement utiliser quelque chose comme ce que vous avez (moins la classe Exception de base, plutôt que la variable NumberFormatException).
Vous pouvez utiliser la méthode match de la classe string. Le [0-9] représente toutes les valeurs possibles, le + signifie qu'il doit comporter au moins un caractère et le *, qu'il peut contenir zéro caractère ou plus.
boolean isNumeric = yourString.matches("[0-9]+"); // 1 or more characters long, numbers only
boolean isNumeric = yourString.matches("[0-9]*"); // 0 or more characters long, numbers only
Voici une variante Java 8 de la réponse de Jonas Klemming:
public static boolean isInteger(String str) {
return str != null && str.length() > 0 &&
IntStream.range(0, str.length()).allMatch(i -> i == 0 && (str.charAt(i) == '-' || str.charAt(i) == '+')
|| Character.isDigit(str.charAt(i)));
}
Code de test:
public static void main(String[] args) throws NoSuchAlgorithmException, UnsupportedEncodingException {
Arrays.asList("1231231", "-1232312312", "+12313123131", "qwqe123123211", "2", "0000000001111", "", "123-", "++123",
"123-23", null, "+-123").forEach(s -> {
System.out.printf("%15s %s%n", s, isInteger(s));
});
}
Résultats du code de test:
1231231 true
-1232312312 true
+12313123131 true
qwqe123123211 false
2 true
0000000001111 true
false
123- false
++123 false
123-23 false
null false
+-123 false
Vous pouvez également utiliser la classe Scanner et utiliser hasNextInt () -, ce qui vous permet également de tester d'autres types, tels que float, etc.
Si votre tableau String contient des entiers et des chaînes purs, le code ci-dessous devrait fonctionner. Il suffit de regarder le premier caractère . ["4", "44", "abc", "77", "lien"]
if (Character.isDigit(string.charAt(0))) {
//Do something with int
}
Vous venez de vérifier 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 devez probablement prendre en compte le cas d'utilisation également:
Si la plupart du temps, vous vous attendez à ce que les chiffres soient valides, le fait de capturer l'exception ne fait qu'engendrer une surcharge de performances lorsque vous tentez de convertir des nombres non valides. Considérant que l'appel d'une méthode isInteger(), puis la conversion à l'aide de Integer.parseInt() entraînera toujours une surcharge de performances pour les nombres valides - les chaînes sont analysées deux fois, une par la vérification et une autre par la conversion.
Que diriez-vous:
return Pattern.matches("-?\\d+", input);
Si vous utilisez l'API Android, vous pouvez utiliser:
TextUtils.isDigitsOnly(str);
Une autre option:
private boolean isNumber(String s) {
boolean isNumber = true;
for (char c : s.toCharArray()) {
isNumber = isNumber && Character.isDigit(c);
}
return isNumber;
}
Si vous voulez vérifier si la chaîne représente un entier compris dans un type int, j'ai légèrement modifié la réponse des jonas, de sorte que les chaînes représentant des entiers supérieurs à Integer.MAX_VALUE ou inférieures à Integer.MIN_VALUE renverront désormais faux. Par exemple: "3147483647" renverra false car 3147483647 est supérieur à 2147483647 et de même, "-2147483649" renverra également false car -2147483649 est inférieur à -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;
}
Ceci est une modification du code Jonas 'qui vérifie si la chaîne est dans la plage pour pouvoir être convertie en un entier.
public static boolean isInteger(String str) {
if (str == null) {
return false;
}
int length = str.length();
int i = 0;
// set the length and value for highest positive int or lowest negative int
int maxlength = 10;
String maxnum = String.valueOf(Integer.MAX_VALUE);
if (str.charAt(0) == '-') {
maxlength = 11;
i = 1;
maxnum = String.valueOf(Integer.MIN_VALUE);
}
// verify digit length does not exceed int range
if (length > maxlength) {
return false;
}
// verify that all characters are numbers
if (maxlength == 11 && length == 1) {
return false;
}
for (int num = i; num < length; num++) {
char c = str.charAt(num);
if (c < '0' || c > '9') {
return false;
}
}
// verify that number value is within int range
if (length == maxlength) {
for (; i < length; i++) {
if (str.charAt(i) < maxnum.charAt(i)) {
return true;
}
else if (str.charAt(i) > maxnum.charAt(i)) {
return false;
}
}
}
return true;
}
J'ai vu beaucoup de réponses ici, mais la plupart d'entre elles sont capables de déterminer si la chaîne est numérique, mais elles ne vérifient pas si le nombre est dans la plage Integer ...
Par conséquent, je propose 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;
}
}
public class HelloWorld{
static boolean validateIP(String s){
String[] value = s.split("\\.");
if(value.length!=4) return false;
int[] v = new int[4];
for(int i=0;i<4;i++){
for(int j=0;j<value[i].length();j++){
if(!Character.isDigit(value[i].charAt(j)))
return false;
}
v[i]=Integer.parseInt(value[i]);
if(!(v[i]>=0 && v[i]<=255)) return false;
}
return true;
}
public static void main(String[] argv){
String test = "12.23.8.9j";
if(validateIP(test)){
System.out.println(""+test);
}
}
}
Cela fonctionne pour moi. Simplement identifier si une chaîne est une primitive ou un nombre.
private boolean isPrimitive(String value){
boolean status=true;
if(value.length()<1)
return false;
for(int i = 0;i<value.length();i++){
char c=value.charAt(i);
if(Character.isDigit(c) || c=='.'){
}else{
status=false;
break;
}
}
return status;
}
Quand les explications sont plus importantes que les performances
J'ai remarqué de nombreuses discussions sur l'efficacité de certaines solutions, mais aucune sur pourquoi une chaîne n'est pas un entier. En outre, tout le monde semblait supposer que le nombre "2.00" n'était pas égal à "2". Mathématiquement et humainement, ils sont égaux (même si l'informatique dit qu'ils ne le sont pas et pour une bonne raison). C'est pourquoi les solutions "Integer.parseInt" ci-dessus sont faibles (selon vos besoins).
Quoi qu'il en soit, pour rendre les logiciels plus intelligents et plus conviviaux, nous devons créer un logiciel qui pense comme nous et explique pourquoi quelque chose a échoué. Dans ce cas:
public static boolean isIntegerFromDecimalString(String possibleInteger) {
possibleInteger = possibleInteger.trim();
try {
// Integer parsing works great for "regular" integers like 42 or 13.
int num = Integer.parseInt(possibleInteger);
System.out.println("The possibleInteger="+possibleInteger+" is a pure integer.");
return true;
} catch (NumberFormatException e) {
if (possibleInteger.equals(".")) {
System.out.println("The possibleInteger=" + possibleInteger + " is NOT an integer because it is only a decimal point.");
return false;
} else if (possibleInteger.startsWith(".") && possibleInteger.matches("\\.[0-9]*")) {
if (possibleInteger.matches("\\.[0]*")) {
System.out.println("The possibleInteger=" + possibleInteger + " is an integer because it starts with a decimal point and afterwards is all zeros.");
return true;
} else {
System.out.println("The possibleInteger=" + possibleInteger + " is NOT an integer because it starts with a decimal point and afterwards is not all zeros.");
return false;
}
} else if (possibleInteger.endsWith(".") && possibleInteger.matches("[0-9]*\\.")) {
System.out.println("The possibleInteger="+possibleInteger+" is an impure integer (ends with decimal point).");
return true;
} else if (possibleInteger.contains(".")) {
String[] partsOfPossibleInteger = possibleInteger.split("\\.");
if (partsOfPossibleInteger.length == 2) {
//System.out.println("The possibleInteger=" + possibleInteger + " is split into '" + partsOfPossibleInteger[0] + "' and '" + partsOfPossibleInteger[1] + "'.");
if (partsOfPossibleInteger[0].matches("[0-9]*")) {
if (partsOfPossibleInteger[1].matches("[0]*")) {
System.out.println("The possibleInteger="+possibleInteger+" is an impure integer (ends with all zeros after the decimal point).");
return true;
} else if (partsOfPossibleInteger[1].matches("[0-9]*")) {
System.out.println("The possibleInteger=" + possibleInteger + " is NOT an integer because it the numbers after the decimal point (" +
partsOfPossibleInteger[1] + ") are not all zeros.");
return false;
} else {
System.out.println("The possibleInteger=" + possibleInteger + " is NOT an integer because it the 'numbers' after the decimal point (" +
partsOfPossibleInteger[1] + ") are not all numeric digits.");
return false;
}
} else {
System.out.println("The possibleInteger=" + possibleInteger + " is NOT an integer because it the 'number' before the decimal point (" +
partsOfPossibleInteger[0] + ") is not a number.");
return false;
}
} else {
System.out.println("The possibleInteger="+possibleInteger+" is NOT an integer because it has a strange number of decimal-period separated parts (" +
partsOfPossibleInteger.length + ").");
return false;
}
} // else
System.out.println("The possibleInteger='"+possibleInteger+"' is NOT an integer, even though it has no decimal point.");
return false;
}
}
Code de test:
String[] testData = {"0", "0.", "0.0", ".000", "2", "2.", "2.0", "2.0000", "3.14159", ".0001", ".", "$4.0", "3E24", "6.0221409e+23"};
int i = 0;
for (String possibleInteger : testData ) {
System.out.println("");
System.out.println(i + ". possibleInteger='" + possibleInteger +"' isIntegerFromDecimalString=" + isIntegerFromDecimalString(possibleInteger));
i++;
}
is_number = true;
try {
Integer.parseInt(mystr)
} catch (NumberFormatException e) {
is_number = false;
}
Ce que vous avez fait fonctionne, mais vous ne devriez probablement pas toujours vérifier cela. Les exceptions de lancer devraient être réservées à des situations "exceptionnelles" (peut-être que cela convient à votre cas) et sont très coûteuses en termes de performances.
Je n'aime pas la méthode avec regex, car regex ne peut pas vérifier les plages (Integer.MIN_VALUE, Integer.MAX_VALUE).
Si vous vous attendez à une valeur int dans la plupart des cas, et non int est quelque chose d'inhabituel, alors je suggère une version avec Integer.valueOf ou Integer.parseInt avec NumberFormatException interceptant. Avantage de cette approche - votre code a une bonne 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 String est un entier et que vous vous souciez de la performance, le meilleur moyen consiste à utiliser la mise en oeuvre Java jdk de Integer.parseInt, mais peu modifiée (en remplaçant la valeur renvoyée par la valeur false):
Cette fonction a de bonnes performances et garantit le résultat correct:
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;
}
Pour vérifier tous les caractères internationaux, vous pouvez simplement utiliser un double négatif.
if (! searchString.matches ("[^ 0-9] + $")) ...
[^ 0-9] + $ vérifie s'il existe des caractères non entiers. Le test échoue donc s'il est vrai. Juste pas ça et vous devenez vrai en cas de succès.
Number number;
try {
number = NumberFormat.getInstance().parse("123");
} catch (ParseException e) {
//not a number - do recovery.
e.printStackTrace();
}
//use number
Je crois qu'il n'y a aucun risque de rencontrer une exception, car comme vous pouvez le voir ci-dessous, vous analysez toujours en toute sécurité int à String et non l'inverse.
Alors:
Vous vérifiez si chaque emplacement de caractère de votre chaîne correspond au moinsun des caractères {"0", "1", "2", "3", "4", "5" , "6", "7", "8", "9"} .
if(aString.substring(j, j+1).equals(String.valueOf(i)))Vous somme toutes les fois que vous avez rencontré dans les emplacements les caractères Ci-dessus.
digits++;Et enfin vous vérifiez si le nombre de fois que vous avez rencontré des entiers sous la forme Caractères est égal à la longueur de la chaîne donnée.
if(digits == aString.length())
Et en 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:
C'est un entier !!
Ce n'est pas un entier !!
De même, vous pouvez valider si une String est une float ou une double mais dans ce cas, vous devez en rencontrer un seul. (point) dans la chaîne et bien sûr vérifier si digits == (aString.length()-1)
Là encore, il n’ya aucun risque de courir une exception d’analyse ici, mais si vous envisagez d’analyser une chaîne contenant un nombre (par exemple, int type de données), vous devez d’abord vérifier si elle convient au type de données. . Sinon, vous devez le lancer.
J'espère que j'ai aidé
Trouvez cela peut être utile:
public static boolean isInteger(String self) {
try {
Integer.valueOf(self.trim());
return true;
} catch (NumberFormatException nfe) {
return false;
}
}
Cela ne fonctionnerait que pour les 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;
}