try - Cómo verificar si una cadena es numérica en Java
validar si un dato es string en java (30)
¿Cómo verificarías si un String era un número antes de analizarlo?
Coincidencia de regex
Este es otro ejemplo de la expresión regular "CraigTP" actualizada con más validaciones.
public static boolean isNumeric(String str)
{
return str.matches("^(?:(?://-{1})?//d+(?://.{1}//d+)?)$");
}
- Solo un signo negativo - permitido y debe estar en principio.
- Después del signo negativo debe haber un dígito.
- Sólo un signo decimal . permitido.
- Después del signo decimal debe haber un dígito.
Prueba de regex
1 -- **VALID**
1. -- INVALID
1.. -- INVALID
1.1 -- **VALID**
1.1.1 -- INVALID
-1 -- **VALID**
--1 -- INVALID
-1. -- INVALID
-1.1 -- **VALID**
-1.1.1 -- INVALID
// por favor revise el siguiente código
public static boolean isDigitsOnly(CharSequence str) {
final int len = str.length();
for (int i = 0; i < len; i++) {
if (!Character.isDigit(str.charAt(i))) {
return false;
}
}
return true;
}
Aquí está mi clase para verificar si una cadena es numérica. También corrige cadenas numéricas:
caracteristicas:
- Elimina los ceros innecesarios ["12.0000000" -> "12"]
- Elimina los ceros innecesarios ["12.0580000" -> "12.058"]
- Elimina los caracteres no numéricos ["12.00sdfsdf00" -> "12"]
- Maneja valores de cadena negativos ["-12,020000" -> "-12.02"]
- Elimina múltiples puntos ["-12.0.20.000" -> "-12.02"]
- No hay bibliotecas extra, solo Java estándar
Aqui tienes...
public class NumUtils {
/**
* Transforms a string to an integer. If no numerical chars returns a String "0".
*
* @param str
* @return retStr
*/
static String makeToInteger(String str) {
String s = str;
double d;
d = Double.parseDouble(makeToDouble(s));
int i = (int) (d + 0.5D);
String retStr = String.valueOf(i);
System.out.printf(retStr + " ");
return retStr;
}
/**
* Transforms a string to an double. If no numerical chars returns a String "0".
*
* @param str
* @return retStr
*/
static String makeToDouble(String str) {
Boolean dotWasFound = false;
String orgStr = str;
String retStr;
int firstDotPos = 0;
Boolean negative = false;
//check if str is null
if(str.length()==0){
str="0";
}
//check if first sign is "-"
if (str.charAt(0) == ''-'') {
negative = true;
}
//check if str containg any number or else set the string to ''0''
if (!str.matches(".*//d+.*")) {
str = "0";
}
//Replace '','' with ''.'' (for some european users who use the '','' as decimal separator)
str = str.replaceAll(",", ".");
str = str.replaceAll("[^//d.]", "");
//Removes the any second dots
for (int i_char = 0; i_char < str.length(); i_char++) {
if (str.charAt(i_char) == ''.'') {
dotWasFound = true;
firstDotPos = i_char;
break;
}
}
if (dotWasFound) {
String befDot = str.substring(0, firstDotPos + 1);
String aftDot = str.substring(firstDotPos + 1, str.length());
aftDot = aftDot.replaceAll("//.", "");
str = befDot + aftDot;
}
//Removes zeros from the begining
double uglyMethod = Double.parseDouble(str);
str = String.valueOf(uglyMethod);
//Removes the .0
str = str.replaceAll("([0-9])//.0+([^0-9]|$)", "$1$2");
retStr = str;
if (negative) {
retStr = "-"+retStr;
}
return retStr;
}
static boolean isNumeric(String str) {
try {
double d = Double.parseDouble(str);
} catch (NumberFormatException nfe) {
return false;
}
return true;
}
}
Aquí estaba mi respuesta al problema.
Un método de captura de conveniencia que puede utilizar para analizar cualquier cadena con cualquier tipo de analizador: isParsable(Object parser, String str) . El analizador puede ser una Class o un object . Esto también le permitirá utilizar analizadores personalizados que haya escrito y debería funcionar para cada escenario, por ejemplo:
isParsable(Integer.class, "11");
isParsable(Double.class, "11.11");
Object dateFormater = new java.text.SimpleDateFormat("yyyy.MM.dd G ''at'' HH:mm:ss z");
isParsable(dateFormater, "2001.07.04 AD at 12:08:56 PDT");
Aquí está mi código completo con descripciones de métodos.
import java.lang.reflect.*;
/**
* METHOD: isParsable<p><p>
*
* This method will look through the methods of the specified <code>from</code> parameter
* looking for a public method name starting with "parse" which has only one String
* parameter.<p>
*
* The <code>parser</code> parameter can be a class or an instantiated object, eg:
* <code>Integer.class</code> or <code>new Integer(1)</code>. If you use a
* <code>Class</code> type then only static methods are considered.<p>
*
* When looping through potential methods, it first looks at the <code>Class</code> associated
* with the <code>parser</code> parameter, then looks through the methods of the parent''s class
* followed by subsequent ancestors, using the first method that matches the criteria specified
* above.<p>
*
* This method will hide any normal parse exceptions, but throws any exceptions due to
* programmatic errors, eg: NullPointerExceptions, etc. If you specify a <code>parser</code>
* parameter which has no matching parse methods, a NoSuchMethodException will be thrown
* embedded within a RuntimeException.<p><p>
*
* Example:<br>
* <code>isParsable(Boolean.class, "true");<br>
* isParsable(Integer.class, "11");<br>
* isParsable(Double.class, "11.11");<br>
* Object dateFormater = new java.text.SimpleDateFormat("yyyy.MM.dd G ''at'' HH:mm:ss z");<br>
* isParsable(dateFormater, "2001.07.04 AD at 12:08:56 PDT");<br></code>
* <p>
*
* @param parser The Class type or instantiated Object to find a parse method in.
* @param str The String you want to parse
*
* @return true if a parse method was found and completed without exception
* @throws java.lang.NoSuchMethodException If no such method is accessible
*/
public static boolean isParsable(Object parser, String str) {
Class theClass = (parser instanceof Class? (Class)parser: parser.getClass());
boolean staticOnly = (parser == theClass), foundAtLeastOne = false;
Method[] methods = theClass.getMethods();
// Loop over methods
for (int index = 0; index < methods.length; index++) {
Method method = methods[index];
// If method starts with parse, is public and has one String parameter.
// If the parser parameter was a Class, then also ensure the method is static.
if(method.getName().startsWith("parse") &&
(!staticOnly || Modifier.isStatic(method.getModifiers())) &&
Modifier.isPublic(method.getModifiers()) &&
method.getGenericParameterTypes().length == 1 &&
method.getGenericParameterTypes()[0] == String.class)
{
try {
foundAtLeastOne = true;
method.invoke(parser, str);
return true; // Successfully parsed without exception
} catch (Exception exception) {
// If invoke problem, try a different method
/*if(!(exception instanceof IllegalArgumentException) &&
!(exception instanceof IllegalAccessException) &&
!(exception instanceof InvocationTargetException))
continue; // Look for other parse methods*/
// Parse method refuses to parse, look for another different method
continue; // Look for other parse methods
}
}
}
// No more accessible parse method could be found.
if(foundAtLeastOne) return false;
else throw new RuntimeException(new NoSuchMethodException());
}
/**
* METHOD: willParse<p><p>
*
* A convienence method which calls the isParseable method, but does not throw any exceptions
* which could be thrown through programatic errors.<p>
*
* Use of {@link #isParseable(Object, String) isParseable} is recommended for use so programatic
* errors can be caught in development, unless the value of the <code>parser</code> parameter is
* unpredictable, or normal programtic exceptions should be ignored.<p>
*
* See {@link #isParseable(Object, String) isParseable} for full description of method
* usability.<p>
*
* @param parser The Class type or instantiated Object to find a parse method in.
* @param str The String you want to parse
*
* @return true if a parse method was found and completed without exception
* @see #isParseable(Object, String) for full description of method usability
*/
public static boolean willParse(Object parser, String str) {
try {
return isParsable(parser, str);
} catch(Throwable exception) {
return false;
}
}
Como @CraigTP mencionó en su excelente respuesta, también tengo problemas de rendimiento similares en el uso de Excepciones para probar si la cadena es numérica o no. Así que termino dividiendo la cadena y uso java.lang.Character.isDigit() .
public static boolean isNumeric(String str)
{
for (char c : str.toCharArray())
{
if (!Character.isDigit(c)) return false;
}
return true;
}
De acuerdo con el Javadoc , Character.isDigit(char) reconocerá correctamente los dígitos no latinos. En cuanto al rendimiento, creo que un simple número de N comparaciones donde N es el número de caracteres en la cadena sería más eficiente desde el punto de vista informático que hacer una comparación de expresiones regulares.
ACTUALIZACIÓN: Como señaló Jean-François Corbett en el comentario, el código anterior solo validaría los enteros positivos, que cubren la mayoría de mi caso de uso. A continuación se muestra el código actualizado que valida correctamente los números decimales de acuerdo con la configuración regional predeterminada utilizada en su sistema, asumiendo que el separador decimal solo ocurre una vez en la cadena.
public static boolean isStringNumeric( String str )
{
DecimalFormatSymbols currentLocaleSymbols = DecimalFormatSymbols.getInstance();
char localeMinusSign = currentLocaleSymbols.getMinusSign();
if ( !Character.isDigit( str.charAt( 0 ) ) && str.charAt( 0 ) != localeMinusSign ) return false;
boolean isDecimalSeparatorFound = false;
char localeDecimalSeparator = currentLocaleSymbols.getDecimalSeparator();
for ( char c : str.substring( 1 ).toCharArray() )
{
if ( !Character.isDigit( c ) )
{
if ( c == localeDecimalSeparator && !isDecimalSeparatorFound )
{
isDecimalSeparatorFound = true;
continue;
}
return false;
}
}
return true;
}
Con Apache Commons Lang 3.5 y superior: NumberUtils.isCreatable or StringUtils.isNumeric .
Con Apache Commons Lang 3.4 e inferior: NumberUtils.isNumber o StringUtils.isNumeric .
También puede usar StringUtils.isNumericSpace que devuelve true para cadenas vacías e ignora los espacios internos en la cadena. (Los javadocs vinculados contienen ejemplos detallados para cada método).
Este es un ejemplo simple para esta comprobación:
public static boolean isNumericString(String input) {
boolean result = false;
if(input != null && input.length() > 0) {
char[] charArray = input.toCharArray();
for(char c : charArray) {
if(c >= ''0'' && c <= ''9'') {
// it is a digit
result = true;
} else {
result = false;
break;
}
}
}
return result;
}
Esto generalmente se hace con una función simple definida por el usuario (es decir, la función "esNumérica" de su propio rollo).
Algo como:
public static boolean isNumeric(String str)
{
try
{
double d = Double.parseDouble(str);
}
catch(NumberFormatException nfe)
{
return false;
}
return true;
}
Sin embargo, si está llamando mucho a esta función, y espera que muchas de las verificaciones falle debido a que no es un número, el rendimiento de este mecanismo no será excelente, ya que depende de las excepciones que se producen para cada falla. que es una operación bastante cara.
Un enfoque alternativo puede ser usar una expresión regular para verificar la validez de ser un número:
public static boolean isNumeric(String str)
{
return str.matches("-?//d+(//.//d+)?"); //match a number with optional ''-'' and decimal.
}
Sin embargo, tenga cuidado con el mecanismo RegEx anterior, ya que fallará si utiliza dígitos no árabes (es decir, números distintos del 0 al 9). Esto se debe a que la parte "/ d" del RegEx solo coincidirá con [0-9] y, de hecho, no tiene conocimiento internacional numérico. (¡Gracias a OregonGhost por señalar esto!)
O incluso otra alternativa es usar el objeto java.text.NumberFormat incorporado de Java para ver si, después de analizar la cadena, la posición del analizador está al final de la cadena. Si es así, podemos asumir que toda la cadena es numérica:
public static boolean isNumeric(String str)
{
NumberFormat formatter = NumberFormat.getInstance();
ParsePosition pos = new ParsePosition(0);
formatter.parse(str, pos);
return str.length() == pos.getIndex();
}
Java 8 expresiones lambda.
String someString = "123123";
boolean isNumeric = someString.chars().allMatch( Character::isDigit );
La biblioteca de guayaba de Google proporciona un buen método de ayuda para hacer esto: Ints.tryParse . Lo usa como Integer.parseInt pero devuelve null lugar de lanzar una excepción si la cadena no se analiza a un entero válido. Tenga en cuenta que devuelve Integer, no int, por lo que debe convertirlo / autobox de nuevo a int.
Ejemplo:
String s1 = "22";
String s2 = "22.2";
Integer oInt1 = Ints.tryParse(s1);
Integer oInt2 = Ints.tryParse(s2);
int i1 = -1;
if (oInt1 != null) {
i1 = oInt1.intValue();
}
int i2 = -1;
if (oInt2 != null) {
i2 = oInt2.intValue();
}
System.out.println(i1); // prints 22
System.out.println(i2); // prints -1
Sin embargo, a partir de la versión actual - Guava r11 - todavía está marcado como @Beta.
No lo he evaluado. Mirando el código fuente, hay una sobrecarga de mucha comprobación de cordura pero al final usan Character.digit(string.charAt(idx)) , similar, pero ligeramente diferente a, la respuesta de @Ibrahim arriba. No hay excepción en el manejo de gastos generales bajo las coberturas en su implementación.
Las excepciones son caras, pero en este caso el RegEx toma mucho más tiempo. El código a continuación muestra una prueba simple de dos funciones: una con excepciones y la otra con expresiones regulares. En mi máquina, la versión RegEx es 10 veces más lenta que la excepción.
import java.util.Date;
public class IsNumeric {
public static boolean isNumericOne(String s) {
return s.matches("-?//d+(//.//d+)?"); //match a number with optional ''-'' and decimal.
}
public static boolean isNumericTwo(String s) {
try {
Double.parseDouble(s);
return true;
} catch (Exception e) {
return false;
}
}
public static void main(String [] args) {
String test = "12345.F";
long before = new Date().getTime();
for(int x=0;x<1000000;++x) {
//isNumericTwo(test);
isNumericOne(test);
}
long after = new Date().getTime();
System.out.println(after-before);
}
}
Para hacer coincidir solo los enteros de base diez positivos, que contienen solo dígitos ASCII, use:
public static boolean isNumeric(String maybeNumeric) {
return maybeNumeric != null && maybeNumeric.matches("[0-9]+");
}
Por eso me gusta el enfoque Try * en .NET. Además del método Parse tradicional que es como el de Java, también tiene un método TryParse. No soy bueno en la sintaxis de Java (¿de parámetros?), Así que trate lo siguiente como una especie de pseudocódigo. Aunque debería aclarar el concepto.
boolean parseInteger(String s, out int number)
{
try {
number = Integer.parseInt(myString);
return true;
} catch(NumberFormatException e) {
return false;
}
}
Uso:
int num;
if (parseInteger("23", out num)) {
// Do something with num.
}
Puedes usar NumberFormat#parse :
try
{
NumberFormat.getInstance().parse(value);
}
catch(ParseException e)
{
// Not a number.
}
Si estás en Android, entonces debes usar:
android.text.TextUtils.isDigitsOnly(CharSequence str)
la documentación se puede encontrar aquí
mantenlo simple Casi todo el mundo puede "reprogramar" (lo mismo).
Si usa Java para desarrollar la aplicación de Android, puede usar la función TextUtils.isDigitsOnly .
Un enfoque de buen desempeño que evita el intento de captura y el manejo de números negativos y notación científica.
Pattern PATTERN = Pattern.compile( "^(-?0|-?[1-9]//d*)(//.//d+)?(E//d+)?$" );
public static boolean isNumeric( String value )
{
return value != null && PATTERN.matcher( value ).matches();
}
¿Por qué todos están presionando para obtener soluciones de excepción / expresión regular?
Si bien puedo entender que la mayoría de las personas están bien con el uso de try / catch, si quieres hacerlo con frecuencia ... puede ser extremadamente agotador.
Lo que hice aquí fue tomar la expresión regular, los métodos parseNumber () y el método de búsqueda matricial para ver cuál era el más eficiente. Esta vez, solo miré números enteros.
public static boolean isNumericRegex(String str) {
if (str == null)
return false;
return str.matches("-?//d+");
}
public static boolean isNumericArray(String str) {
if (str == null)
return false;
char[] data = str.toCharArray();
if (data.length <= 0)
return false;
int index = 0;
if (data[0] == ''-'' && data.length > 1)
index = 1;
for (; index < data.length; index++) {
if (data[index] < ''0'' || data[index] > ''9'') // Character.isDigit() can go here too.
return false;
}
return true;
}
public static boolean isNumericException(String str) {
if (str == null)
return false;
try {
/* int i = */ Integer.parseInt(str);
} catch (NumberFormatException nfe) {
return false;
}
return true;
}
Los resultados en velocidad que obtuve fueron:
Done with: for (int i = 0; i < 10000000; i++)...
With only valid numbers ("59815833" and "-59815833"):
Array numeric took 395.808192 ms [39.5808192 ns each]
Regex took 2609.262595 ms [260.9262595 ns each]
Exception numeric took 428.050207 ms [42.8050207 ns each]
// Negative sign
Array numeric took 355.788273 ms [35.5788273 ns each]
Regex took 2746.278466 ms [274.6278466 ns each]
Exception numeric took 518.989902 ms [51.8989902 ns each]
// Single value ("1")
Array numeric took 317.861267 ms [31.7861267 ns each]
Regex took 2505.313201 ms [250.5313201 ns each]
Exception numeric took 239.956955 ms [23.9956955 ns each]
// With Character.isDigit()
Array numeric took 400.734616 ms [40.0734616 ns each]
Regex took 2663.052417 ms [266.3052417 ns each]
Exception numeric took 401.235906 ms [40.1235906 ns each]
With invalid characters ("5981a5833" and "a"):
Array numeric took 343.205793 ms [34.3205793 ns each]
Regex took 2608.739933 ms [260.8739933 ns each]
Exception numeric took 7317.201775 ms [731.7201775 ns each]
// With a single character ("a")
Array numeric took 291.695519 ms [29.1695519 ns each]
Regex took 2287.25378 ms [228.725378 ns each]
Exception numeric took 7095.969481 ms [709.5969481 ns each]
With null:
Array numeric took 214.663834 ms [21.4663834 ns each]
Regex took 201.395992 ms [20.1395992 ns each]
Exception numeric took 233.049327 ms [23.3049327 ns each]
Exception numeric took 6603.669427 ms [660.3669427 ns each] if there is no if/null check
Descargo de responsabilidad: no pretendo que estos métodos estén 100% optimizados, son solo para la demostración de los datos
Excepciones ganadas si y solo si el número es de 4 caracteres o menos, y cada cadena es siempre un número ... en cuyo caso, ¿por qué incluso tener un cheque?
En resumen, es extremadamente doloroso si te topas con números no válidos con frecuencia con el try / catch, lo que tiene sentido. Una regla importante que siempre sigo es que NUNCA use try / catch para el flujo del programa . Este es un ejemplo de por qué.
Curiosamente, el simple si char <0 || > 9 fue extremadamente simple de escribir, fácil de recordar (y debería funcionar en varios idiomas) y gana casi todos los escenarios de prueba.
El único inconveniente es que supongo que Integer.parseInt () podría manejar números no ASCII, mientras que el método de búsqueda de matrices no lo hace.
Para aquellos que se preguntan por qué dije que es fácil recordar la matriz de caracteres uno, si sabes que no hay signos negativos, puedes salirte con algo condensado como esto:
public static boolean isNumericArray(String str) {
if (str == null)
return false;
for (char c : str.toCharArray())
if (c < ''0'' || c > ''9'')
return false;
return true;
Por último, como nota final, sentí curiosidad por el operador del proyecto en el ejemplo aceptado con todos los votos arriba. Añadiendo en la asignación de
double d = Double.parseDouble(...)
no solo es inútil ya que ni siquiera utiliza el valor, sino que desperdicia el tiempo de procesamiento y aumenta el tiempo de ejecución en unos pocos nanosegundos (lo que llevó a un aumento de 100-200 ms en las pruebas). No veo por qué alguien haría eso, ya que en realidad es un trabajo extra para reducir el rendimiento.
Usted pensaría que se optimizaría ... aunque quizás debería revisar el código de bytes y ver qué está haciendo el compilador. Eso no explica por qué siempre se mostró más largo para mí, aunque si de alguna manera está optimizado ... por lo tanto, me pregunto qué está pasando. Como nota: por más tiempo, me refiero a ejecutar la prueba para 10000000 iteraciones, y ejecutar ese programa varias veces (10x +) siempre mostró que era más lento.
EDITAR: Se actualizó una prueba para Character.isDigit ()
Comprobación paralela de cadenas muy largas con IntStream
En Java 8, las siguientes pruebas prueban si todos los caracteres de los dados stringestán entre ''0'' y ''9''. Tenga en cuenta que la cadena vacía es aceptada:
string.chars().unordered().parallel().allMatch( i -> ''0'' <= i && ''9'' >= i )
No utilice excepciones para validar sus valores. Use Utils libs como apache NumberUtils:
NumberUtils.isNumber(myStringValue);
Editar :
Tenga en cuenta que, si su cadena comienza con un 0, NumberUtils interpretará su valor como hexadecimal.
NumberUtils.isNumber("07") //true
NumberUtils.isNumber("08") //false
Esta es la forma más rápida que conozco para verificar si la Cadena es Número o no:
public static boolean isNumber(String str){
int i=0, len=str.length();
boolean a=false,b=false,c=false, d=false;
if(i<len && (str.charAt(i)==''+'' || str.charAt(i)==''-'')) i++;
while( i<len && isDigit(str.charAt(i)) ){ i++; a=true; }
if(i<len && (str.charAt(i)==''.'')) i++;
while( i<len && isDigit(str.charAt(i)) ){ i++; b=true; }
if(i<len && (str.charAt(i)==''e'' || str.charAt(i)==''E'') && (a || b)){ i++; c=true; }
if(i<len && (str.charAt(i)==''+'' || str.charAt(i)==''-'') && c) i++;
while( i<len && isDigit(str.charAt(i)) ){ i++; d=true;}
return i==len && (a||b) && (!c || (c && d));
}
static boolean isDigit(char c){
return c==''0'' || c==''1'' || c==''2'' || c==''3'' || c==''4'' || c==''5'' || c==''6'' || c==''7'' || c==''8'' || c==''9'';
}
Modifiqué la solución de CraigTP para aceptar la notación científica y los puntos y la coma como separadores decimales también
^-?/d+([,/.]/d+)?([eE]-?/d+)?$
ejemplo
var re = new RegExp("^-?/d+([,/.]/d+)?([eE]-?/d+)?$");
re.test("-6546"); // true
re.test("-6546355e-4456"); // true
re.test("-6546.355e-4456"); // true, though debatable
re.test("-6546.35.5e-4456"); // false
re.test("-6546.35.5e-4456.6"); // false
Puedes usar el objeto java.util.Scanner.
public static boolean isNumeric(String inputData) {
Scanner sc = new Scanner(inputData);
return sc.hasNextInt();
}
Si ustedes usan el siguiente método para verificar:
public static boolean isNumeric(String str) {
NumberFormat formatter = NumberFormat.getInstance();
ParsePosition pos = new ParsePosition(0);
formatter.parse(str, pos);
return str.length() == pos.getIndex();
}
Luego, qué sucedió con la entrada de una cadena muy larga, como llamo a este método:
System.out.println(isNumeric("94328948243242352525243242524243425452342343948923"));
El resultado es "verdadero", ¡también es un número demasiado grande! ¡Lo mismo pasará si usas regex para verificar! Así que prefiero usar el método de "análisis" para verificar, como esto:
public static boolean isNumeric(String str) {
try {
int number = Integer.parseInt(str);
return true;
} catch (Exception e) {
return false;
}
}
¡Y el resultado es lo que esperaba!
Analícelo (es decir, con Integer#parseInt) y simplemente capture la excepción. =)
Para aclarar: la función parseInt comprueba si puede analizar el número en cualquier caso (obviamente) y si desea analizarlo de todos modos, no va a tener ningún impacto en el rendimiento al realizar el análisis.
Si no desea analizarlo (o analizarlo muy, muy raramente), es posible que desee hacerlo de manera diferente, por supuesto.
Aquí hay dos métodos que podrían funcionar. (Sin usar excepciones). Nota: Java es un valor de paso por valor predeterminado y el valor de una cadena es la dirección de los datos del objeto de la cadena. Entonces, cuando estás haciendo
stringNumber = stringNumber.replaceAll(" ", "");
Ha cambiado el valor de entrada para que no tenga espacios. Puedes quitar esa línea si quieres.
private boolean isValidStringNumber(String stringNumber)
{
if(stringNumber.isEmpty())
{
return false;
}
stringNumber = stringNumber.replaceAll(" ", "");
char [] charNumber = stringNumber.toCharArray();
for(int i =0 ; i<charNumber.length ;i++)
{
if(!Character.isDigit(charNumber[i]))
{
return false;
}
}
return true;
}
Aquí hay otro método en caso de que quiera permitir flotantes. Este método supuestamente permite que los números en el formulario pasen 1.123.123.123.123.123.123 que acabo de hacer, y creo que necesita más pruebas para asegurarse de que funciona.
private boolean isValidStringTrueNumber(String stringNumber)
{
if(stringNumber.isEmpty())
{
return false;
}
stringNumber = stringNumber.replaceAll(" ", "");
int countOfDecimalPoint = 0;
boolean decimalPointPassed = false;
boolean commaFound = false;
int countOfDigitsBeforeDecimalPoint = 0;
int countOfDigitsAfterDecimalPoint =0 ;
int commaCounter=0;
int countOfDigitsBeforeFirstComma = 0;
char [] charNumber = stringNumber.toCharArray();
for(int i =0 ; i<charNumber.length ;i++)
{
if((commaCounter>3)||(commaCounter<0))
{
return false;
}
if(!Character.isDigit(charNumber[i]))//Char is not a digit.
{
if(charNumber[i]=='','')
{
if(decimalPointPassed)
{
return false;
}
commaFound = true;
//check that next three chars are only digits.
commaCounter +=3;
}
else if(charNumber[i]==''.'')
{
decimalPointPassed = true;
countOfDecimalPoint++;
}
else
{
return false;
}
}
else //Char is a digit.
{
if ((commaCounter>=0)&&(commaFound))
{
if(!decimalPointPassed)
{
commaCounter--;
}
}
if(!commaFound)
{
countOfDigitsBeforeFirstComma++;
}
if(!decimalPointPassed)
{
countOfDigitsBeforeDecimalPoint++;
}
else
{
countOfDigitsAfterDecimalPoint++;
}
}
}
if((commaFound)&&(countOfDigitsBeforeFirstComma>3))
{
return false;
}
if(countOfDecimalPoint>1)
{
return false;
}
if((decimalPointPassed)&&((countOfDigitsBeforeDecimalPoint==0)||(countOfDigitsAfterDecimalPoint==0)))
{
return false;
}
return true;
}
Creo que la única forma de saber de manera confiable si una cadena es un número, es analizarla. Así que simplemente lo analizaría, y si es un número, ¡obtendrás el número en un int gratis!
Puede usar NumberUtils.isCreatable () desde Apache Commons Lang .
Dado que NumberUtils.isNumber quedará en desuso en 4.0, entonces use NumberUtils.isCreatable () en su lugar.
// only int
public static boolean isNumber(int num)
{
return (num >= 48 && c <= 57); // 0 - 9
}
// is type of number including . - e E
public static boolean isNumber(String s)
{
boolean isNumber = true;
for(int i = 0; i < s.length() && isNumber; i++)
{
char c = s.charAt(i);
isNumber = isNumber & (
(c >= ''0'' && c <= ''9'') || (c == ''.'') || (c == ''e'') || (c == ''E'') || (c == '''')
);
}
return isInteger;
}
// is type of number
public static boolean isInteger(String s)
{
boolean isInteger = true;
for(int i = 0; i < s.length() && isInteger; i++)
{
char c = s.charAt(i);
isInteger = isInteger & ((c >= ''0'' && c <= ''9''));
}
return isInteger;
}
public static boolean isNumeric(String s)
{
try
{
Double.parseDouble(s);
return true;
}
catch (Exception e)
{
return false;
}
}
public static boolean isNumeric(String str)
{
return str.matches("-?//d+(.//d+)?");
}
La expresión regular de CraigTP (que se muestra arriba) produce algunos falsos positivos. Por ejemplo, "23y4" se contará como un número porque ''.'' coincide con cualquier carácter no el punto decimal.
También rechazará cualquier número con un ''+'' inicial.
Una alternativa que evita estos dos problemas menores es
public static boolean isNumeric(String str)
{
return str.matches("[+-]?//d*(//.//d+)?");
}