una - validar solo numeros en java consola

Cómo comprobar si una cadena contiene solo dígitos en Java

Question

Esta pregunta ya tiene una respuesta aquí:

• Java String - Vea si una cadena contiene solo números y no letras 14 respuestas

En Java para la clase String hay un método llamado matches, cómo usar este método para verificar si mi cadena tiene solo dígitos usando la expresión regular. Intenté con los ejemplos a continuación, pero ambos me devolvieron falso como resultado.

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));

Answer 1

De acuerdo con la documentación de Java de 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()
}

Answer 2

Debe permitir más de un dígito (el signo + ) como en:

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

Answer 3

El uso de expresiones regulares es costoso en términos de rendimiento. Tratar de analizar cadena como un valor largo es ineficiente y poco confiable, y puede no ser lo que necesita.

Lo que sugiero es simplemente verificar si cada carácter es un dígito, lo que se puede hacer eficientemente usando expresiones Java 8 lambda:

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

Answer 4

Podemos usar Pattern.compile("[0-9]+.[0-9]+") o Pattern.compile("//d+.//d+") . Ellos tienen el mismo significado.

el patrón [0-9] significa dígito. Lo mismo que ''/ d''. ''+'' significa que aparece más veces. ''''. para entero o flotante.

Intenta seguir el código:

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");
}
}

Salida:

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

Answer 5

Prueba esta parte del código:

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");
}
}

Answer 6

También puede usar NumberUtil.isNumber (String str) de Apache Commons

Answer 7

Tratar

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

o

String regex = "//d+";

Según expresiones regulares de Java, + significa "una o más veces" y /d significa "un dígito".

Nota: la "doble barra diagonal inversa" es una secuencia de escape para obtener una sola barra diagonal inversa; por lo tanto, //d en una cadena Java le da el resultado real: /d

Referencias

Expresiones regulares de Java

Secuencias de escape de caracteres de Java

Editar: debido a cierta confusión en otras respuestas, estoy escribiendo un caso de prueba y explicaré algunas cosas más en detalle.

En primer lugar, si tiene dudas sobre la corrección de esta solución (u otras), ejecute este caso de prueba:

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));

Pregunta 1: ¿No es necesario agregar ^ y $ a la expresión regular, por lo que no coincidirá con "aa123bb"?

No. En java, el método de matches (que se especificó en la pregunta) coincide con una cadena completa, no con fragmentos. En otras palabras, no es necesario usar ^//d+$ (aunque también es correcto). Por favor vea el último caso de prueba negativo.

Tenga en cuenta que si utiliza un "corrector de expresiones regulares" en línea, esto puede comportarse de manera diferente. Para hacer coincidir fragmentos de una cadena en Java, puede usar el método find lugar, que se describe en detalle aquí:

Diferencia entre matches () y find () en Java Regex

Pregunta 2: ¿Esta expresión regular tampoco coincidirá con la cadena vacía, "" ?

No. Una regex //d* coincidiría con la cadena vacía, pero //d+ no. La estrella * significa cero o más, mientras que el más + significa uno o más. Por favor vea el primer caso de prueba negativo.

Pregunta 3: ¿No es más rápido compilar un Patrón regex?

Sí. De hecho, es más rápido compilar un Patrón regex una vez, en lugar de en cada invocación de matches , por lo que si las implicaciones de rendimiento son importantes, entonces un Pattern se puede compilar y usar así:

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());

Answer 8

Una solución más, que aún no se ha publicado,

String regex = "//p{Digit}+"; // uses POSIX character class

Answer 9

Long.parseLong(data)

y captura la excepción, maneja el signo menos.

Aunque el número de dígitos es limitado, esto realmente crea una variable de los datos que se puede utilizar, que es, me imagino, el caso de uso más común.