una - validar solo numeros en java netbeans

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

Question

Tengo una cadena que cargué a lo largo de mi aplicación, y cambia de números a letras y cosas por el estilo. Tengo una instrucción if simple para ver si contiene letras o números, pero algo no funciona del todo correctamente. Aquí hay un fragmento.

String text = "abc";
String number;
if (text.contains("[a-zA-Z]+") == false && text.length() > 2) {
number = text;
}

Aunque la variable de text contiene letras, la condición vuelve a ser true . El y && deberían evaluar ya que ambas condiciones deben ser true para procesar el number = text;

===========================

Solución:

Pude resolver esto usando el siguiente código provisto por un comentario sobre esta pregunta. ¡Todas las otras publicaciones son válidas también!

Lo que utilicé que funcionó vino del primer comentario. ¡Aunque todos los códigos de ejemplo proporcionados parecen ser válidos también!

String text = "abc";
String number;
if (Pattern.matches("[a-zA-Z]+", text) == false && text.length() > 2) {
number = text;
}

Answer 1

A continuación, las expresiones regulares se pueden usar para verificar si una cadena tiene solo un número o no:

if (str.matches(".*[^0-9].*")) or if (str.matches(".*//D.*"))

Ambas condiciones anteriores serán true si String contiene números no numéricos. En false , la cadena tiene solo números.

Answer 2

Así es como lo haría:

if(text.matches("^[0-9]*$") && text.length() > 2){
//...
}

El $ evitará una coincidencia parcial, por ejemplo; 1B .

Answer 3

Ejemplo de prueba de trabajo

import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.commons.lang3.StringUtils;
public class PaserNo {
public static void main(String args[]) {
String text = "gg";
if (!StringUtils.isBlank(text)) {
if (stringContainsNumber(text)) {
int no=Integer.parseInt(text.trim());
System.out.println("inside"+no);
} else {
System.out.println("Outside");
}
}
System.out.println("Done");
}
public static boolean stringContainsNumber(String s) {
Pattern p = Pattern.compile("[0-9]");
Matcher m = p.matcher(s);
return m.find();
}
}

Sin embargo, su código se puede romper por "1a", etc. por lo que debe verificar la excepción

if (!StringUtils.isBlank(studentNbr)) {
try{
if (isStringContainsNumber(studentNbr)){
_account.setStudentNbr(Integer.parseInt(studentNbr.trim()));
}
}catch(Exception e){
e.printStackTrace();
logger.info("Exception during parse studentNbr"+e.getMessage());
}
}

El método para marcar no es cadena o no

private boolean isStringContainsNumber(String s) {
Pattern p = Pattern.compile("[0-9]");
Matcher m = p.matcher(s);
return m.find();
}

Answer 4

En cuanto a rendimiento, el parseInt y otros son mucho peores que otras soluciones, porque al menos requieren manejo de excepciones.

He realizado pruebas de jmh y he descubierto que iterar sobre String usando charAt y comparar caracteres con caracteres de límite es la manera más rápida de probar si la cadena contiene solo dígitos.

Pruebas JMH

Las pruebas comparan el rendimiento de Character.isDigit vs Pattern.matcher().matches vs Long.parseLong versus checking char values.

Estas formas pueden producir resultados diferentes para strings que no sean ascii y cadenas que contengan signos +/-.

Las pruebas se ejecutan en el modo de rendimiento ( mayor es mejor ) con 5 iteraciones de calentamiento y 5 iteraciones de prueba.

Resultados

Tenga en cuenta que parseLong es casi 100 veces más lento que isDigit para la primera carga de prueba.

## Test load with 25% valid strings (75% strings contain non-digit symbols)
Benchmark Mode Cnt Score Error Units
testIsDigit thrpt 5 9.275 ± 2.348 ops/s
testPattern thrpt 5 2.135 ± 0.697 ops/s
testParseLong thrpt 5 0.166 ± 0.021 ops/s
## Test load with 50% valid strings (50% strings contain non-digit symbols)
Benchmark Mode Cnt Score Error Units
testCharBetween thrpt 5 16.773 ± 0.401 ops/s
testCharAtIsDigit thrpt 5 8.917 ± 0.767 ops/s
testCharArrayIsDigit thrpt 5 6.553 ± 0.425 ops/s
testPattern thrpt 5 1.287 ± 0.057 ops/s
testIntStreamCodes thrpt 5 0.966 ± 0.051 ops/s
testParseLong thrpt 5 0.174 ± 0.013 ops/s
testParseInt thrpt 5 0.078 ± 0.001 ops/s

Banco de pruebas

@State(Scope.Benchmark)
public class StringIsNumberBenchmark {
private static final long CYCLES = 1_000_000L;
private static final String[] STRINGS = {"12345678901","98765432177","58745896328","35741596328", "123456789a1", "1a345678901", "1234567890 "};
private static final Pattern PATTERN = Pattern.compile("//d+");
@Benchmark
public void testPattern() {
for (int i = 0; i < CYCLES; i++) {
for (String s : STRINGS) {
boolean b = false;
b = PATTERN.matcher(s).matches();
}
}
}
@Benchmark
public void testParseLong() {
for (int i = 0; i < CYCLES; i++) {
for (String s : STRINGS) {
boolean b = false;
try {
Long.parseLong(s);
b = true;
} catch (NumberFormatException e) {
// no-op
}
}
}
}
@Benchmark
public void testCharArrayIsDigit() {
for (int i = 0; i < CYCLES; i++) {
for (String s : STRINGS) {
boolean b = false;
for (char c : s.toCharArray()) {
b = Character.isDigit(c);
if (!b) {
break;
}
}
}
}
}
@Benchmark
public void testCharAtIsDigit() {
for (int i = 0; i < CYCLES; i++) {
for (String s : STRINGS) {
boolean b = false;
for (int j = 0; j < s.length(); j++) {
b = Character.isDigit(s.charAt(j));
if (!b) {
break;
}
}
}
}
}
@Benchmark
public void testIntStreamCodes() {
for (int i = 0; i < CYCLES; i++) {
for (String s : STRINGS) {
boolean b = false;
b = s.chars().allMatch(c -> c > 47 && c < 58);
}
}
}
@Benchmark
public void testCharBetween() {
for (int i = 0; i < CYCLES; i++) {
for (String s : STRINGS) {
boolean b = false;
for (int j = 0; j < s.length(); j++) {
char charr = s.charAt(j);
b = ''0'' <= charr && charr <= ''9'';
if (!b) {
break;
}
}
}
}
}
}

Actualizado el 23 de febrero de 2018

• Agregue dos casos más, uno con charAt lugar de crear una matriz extra y otro con IntStream de códigos de char
• Agregue interrupción inmediata si no se encuentra un dígito para los casos de prueba en bucle
• Devolver falso para cadena vacía para casos de prueba en bucle

Actualizado el 23 de febrero de 2018

• Agregue un caso de prueba más (¡el más rápido!) Que compare el valor de char sin usar la secuencia

Answer 5

Este código ya está escrito. Si no te importa el golpe de rendimiento (extremadamente) menor, que probablemente no sea peor que hacer una coincidencia de Double.parseDouble() regulares, utiliza Integer.parseInt() o Double.parseDouble() . Eso le dirá de inmediato si una Cadena solo son números (o es un número, según corresponda). Si necesita manejar cadenas de números más largas, tanto BigInteger como los constructores deportivos BigDecimal aceptan cadenas. Cualquiera de estos lanzará una NumberFormatException si intenta pasarle un número no (integral o decimal, basado en el que elija, por supuesto). Alternativamente, dependiendo de sus requisitos, simplemente itere los caracteres en la Cadena y marque Character.isDigit() y / o Character.isLetter() .

Answer 6

Hay muchas instalaciones para obtener números de String s en Java (y viceversa). Puede omitir la parte de expresiones regulares para evitar la complicación de eso.

Por ejemplo, podría intentar y ver qué Double.parseDouble(String s) para usted. Debería arrojar una NumberFormatException si no encuentra un valor apropiado en la cadena. Sugeriría esta técnica porque en realidad podría hacer uso del valor representado por la String como un tipo numérico.

Answer 7

Puedes usar Regex.Match

if(text.matches("//d*")&& text.length() > 2){
System.out.println("number");
}

O puede usar onversions como Integer.parseInt(String) o mejor Long.parseLong(String) para números más grandes, como por ejemplo:

private boolean onlyContainsNumbers(String text) {
try {
Long.parseLong(text);
return true;
} catch (NumberFormatException ex) {
return false;
}
}

Y luego prueba con:

if (onlyContainsNumbers(text) && text.length() > 2) {
// do Stuff
}

Answer 8

Si va a procesar el número como texto, cambie:

if (text.contains("[a-zA-Z]+") == false && text.length() > 2){

a:

if (text.matches("[0-9]+") && text.length() > 2) {

En lugar de verificar que la cadena no contenga caracteres alfabéticos, verifique que solo contenga números.

Si realmente desea usar el valor numérico, use Integer.parseInt() o Double.parseDouble() como otros explicaron a continuación.

Como nota al margen, generalmente se considera una mala práctica comparar valores booleanos a true o false . Solo use if (condition) o if (!condition) .

Answer 9

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

Answer 10

boolean isNum = text.chars (). allMatch (c -> c> = 48 && c <= 57)

Answer 11

Apache Commons Lang proporciona org.apache.commons.lang.StringUtils.isNumeric(CharSequence cs) , que toma como argumento una String y comprueba si consta de caracteres puramente numéricos (incluidos los números de las escrituras no latinas). Ese método devuelve false si hay caracteres como espacio, menos, más y separadores decimales, como coma y punto.

Otros métodos de esa clase permiten verificaciones numéricas adicionales.

Answer 12

Para simplemente verificar la cadena que contiene solo ALPHABETS use el siguiente código:

if (text.matches("[a-zA-Z]+"){
// your operations
}

Para simplemente verificar la cadena que contiene solo NUMBER use el siguiente código:

if (text.matches("[0-9]+"){
// your operations
}

Espero que esto ayude a alguien!

Answer 13

Character first_letter_or_number = query.charAt(0);
//------------------------------------------------------------------------------
if (Character.isDigit())
{
}
else if (Character.isLetter())
{
}

Answer 14

import java.util.*;
class Class1 {
public static void main(String[] argh) {
boolean ans = CheckNumbers("123");
if (ans == true) {
System.out.println("String contains numbers only");
} else {
System.out.println("String contains other values as well");
}
}
public static boolean CheckNumbers(String input) {
for (int ctr = 0; ctr < input.length(); ctr++) {
if ("1234567890".contains(Character.valueOf(input.charAt(ctr)).toString())) {
continue;
} else {
return false;
}
}
return true;
}
}