How to check that the value of a String variable is an Integer in Java?

Code

package javaapplication7;

public class JavaApplication7 {

    public static boolean isNumeric(String cadena) {

        boolean resultado;

        try {
            Integer.parseInt(cadena);
            resultado = true;
        } catch (NumberFormatException excepcion) {
            resultado = false;
        }

        return resultado;
    }

    public static void main(String[] args) {

        String cadena = "500";
        int numero;

        if (isNumeric(cadena) == true) {
            numero = Integer.parseInt(cadena);
            System.out.println("Numero: " + numero);
        } else {
            System.out.println("No es un numero");
        }

    }

}

Result

Number

chain : 500

Number: 500

String

string : Hello world

It's not a number

Explanation

Using the possible exception that the Integer.parseInt() function throws , it is enough to enclose try/catchthe conversion of the string to a number in a .

When the type exception NumberFormatExceptionoccurs, then we determine that the conversion failed and therefore the string that was attempted to be converted is not a number, returning FALSE. Otherwise, it returns a TRUE.

See an example

If you do not use any external library that provides the functionality, it is best to define a utility class with a method that does the checking, similar to:

public boolean isInteger(String numero){
    try{
        Integer.parseInt(numero);
        return true;
    }catch(NumberFormatException e){
        return false;
    }
}

The reason it doesn't exist TryParse is because it's already implied.

If you check the prototype of Integer.parseIntyou can see that the method throws an exception when passing a string without a valid integer.

public static int parseInt(String s)
                    throws NumberFormatException

NumberFormatException is a checked exception. Java has two types of exceptions: checked and unchecked, the first type ALWAYS forces to enclose the call with the blocks try...catchto the method that throws it, while the second type does not.

If we parse the flow in C#

int resultado;
if (Int32.TryParse(cadena, out resultado))
  {
    // TODO1
  }
else 
  {
    // TODO2
  }

The equivalent in Java is

try
  {
    int resultado = Integer.parseInt(cadena);
    // TODO1
  } 
catch(NumberFormatException e) 
  {
    // TODO2
  }

As you can see TryParseit is implicit as it parseIntthrows an exception, which changes the flow of the program automatically.

P.S.

Any implementation of is discouraged TryParsesince, unlike C#, the primitive types in Java are always passed by value, this means that the proposed method would require parsing the string twice, once to return if the string actually contains an integer and the other to get its value, which is absurd.

//Ver si un String contiene un numero
      public static boolean verificarNumeros(String numOlet){
            boolean num=false;
            if((numOlet.contains("0")||numOlet.contains("1")||numOlet.contains("2"))||numOlet.contains("3")||numOlet.contains("4")||numOlet.contains("5")||numOlet.contains("6")||numOlet.contains("7")||numOlet.contains("8")||numOlet.contains("9")||numOlet.contains("!")){
                System.out.println("tiene numeros");
                num=true;
            }
        return num;

        }

An alternative to verify that the String only has digits as a character is always to go through the String and verify it so you avoid the exception.

public static void main(String[] args) {

    String nullType = null;
    String integerType = "123434";
    String characterType = "adsf4";

    System.out.println(isInteger(nullType));
    System.out.println(isInteger(integerType));
    System.out.println(isInteger(characterType));

}

public static boolean isInteger(String source) {

    if (source == null || source.isEmpty())
        return false;

    int index = 0;
    while (index < source.length() && 
            Character.isDigit(source.charAt(index))) {
        index++;
    }
    return index == source.length();
}

Edit: It is only valid for positive numbers, in the case of negatives you would have to make an extra purchase for the negative symbol.