What's the Best Way to Check If a String Represents an Integer in Java

Determine if a String is an Integer in Java

The most naive way would be to iterate over the String and make sure all the elements are valid digits for the given radix. This is about as efficient as it could possibly get, since you must look at each element at least once. I suppose we could micro-optimize it based on the radix, but for all intents and purposes this is as good as you can expect to get.

public static boolean isInteger(String s) {
    return isInteger(s,10);
}

public static boolean isInteger(String s, int radix) {
    if(s.isEmpty()) return false;
    for(int i = 0; i < s.length(); i++) {
        if(i == 0 && s.charAt(i) == '-') {
            if(s.length() == 1) return false;
            else continue;
        }
        if(Character.digit(s.charAt(i),radix) < 0) return false;
    }
    return true;
}

Alternatively, you can rely on the Java library to have this. It's not exception based, and will catch just about every error condition you can think of. It will be a little more expensive (you have to create a Scanner object, which in a critically-tight loop you don't want to do. But it generally shouldn't be too much more expensive, so for day-to-day operations it should be pretty reliable.

public static boolean isInteger(String s, int radix) {
    Scanner sc = new Scanner(s.trim());
    if(!sc.hasNextInt(radix)) return false;
    // we know it starts with a valid int, now make sure
    // there's nothing left!
    sc.nextInt(radix);
    return !sc.hasNext();
}

If best practices don't matter to you, or you want to troll the guy who does your code reviews, try this on for size:

public static boolean isInteger(String s) {
    try { 
        Integer.parseInt(s); 
    } catch(NumberFormatException e) { 
        return false; 
    } catch(NullPointerException e) {
        return false;
    }
    // only got here if we didn't return false
    return true;
}

What's the best way to check if a String represents an integer in Java?

If you are not concerned with potential overflow problems this function will perform about 20-30 times faster than using Integer.parseInt().

public static boolean isInteger(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 < '0' || c > '9') {
            return false;
        }
    }
    return true;
}

How to check if a string is a valid integer?

You can't do if (int i = 0), because assignment returns the assigned value (in this case 0) and if expects an expression that evaluates either to true, or false.

On the other hand, if your goal is to check, whether jTextField.getText() returns a numeric value, that can be parsed to int, you can attempt to do the parsing and if the value is not suitable, NumberFormatException will be raised, to let you know.

try {
    op1 = Integer.parseInt(jTextField1.getText());
} catch (NumberFormatException e) {
    System.out.println("Wrong number");
    op1 = 0;
}

How to check if a String is numeric in Java

With Apache Commons Lang 3.5 and above: NumberUtils.isCreatable or StringUtils.isNumeric.

With Apache Commons Lang 3.4 and below: NumberUtils.isNumber or StringUtils.isNumeric.

You can also use StringUtils.isNumericSpace which returns true for empty strings and ignores internal spaces in the string. Another way is to use NumberUtils.isParsable which basically checks the number is parsable according to Java. (The linked javadocs contain detailed examples for each method.)

Check if a String is Integer

You can try a regex like:

Code

private boolean isInteger(String str) {
    return str.matches("\\-?\\d+");
}

Edit

Thanks @Maloubobola for noting that my first attempt would not parse signed integers.

How can I check if a value is of type Integer?

If input value can be in numeric form other than integer , check by

if (x == (int)x)
{
   // Number is integer
}

If string value is being passed , use Integer.parseInt(string_var).
Please ensure error handling using try catch in case conversion fails.

check string for integers?

this shows you how to do it

import java.util.Scanner;

public class EvenOdd {
  public static void main(String[] args) {
    System.out.print("Enter a character or number. Seriously, though, it is meant to be a number, but you can put whatever you want here. If it isn't a number however, you will get an error message.");
    try (Scanner in = new Scanner(System.in)) {
      int n;
      while (true) {
        String input=in.nextLine();
        try {
          n = Integer.parseInt(input);
          break;
        } catch (NumberFormatException e) {
          System.out.println("you did not enter just an integer, please try again");
        }
      }
      if (n % 2 == 0) {
        System.out.println(n + " is even");
      } else {
        System.out.println(n + " is odd");
      }
    }
  }
}

boolean method to check if a string can be parsed as an int

First of all: If you're not interested in the actual numeric value, it might be easier to use regular expressions:

final static Pattern IsIntegerPattern = Pattern.compile("^\\d+$");

public boolean isInteger(String str) {
    return IsIntegerPattern.matcher(str).matches();
}

This avoids unecessary exceptions being raised and catched.

About the result being true all the time: That's not actually true. It will return false if the last incoming edge is not a number because you iterate over all edges and check if they are integers but don't break the loop if you reach an edge with a non-integer value. Subsequent edges with valid integer values will "overwrite" that information.

So your implementation should look like this:

public void checkParsability()
{
    //while positive int edges is true and therefore all edges can be parsed as positive integers
    if (positive_int_edges)

    {
        for (Node n : this.nodeList)
        {
            for (Edge a : n.getOutgoingEdges()) {
                this.setPositive_int_edges(isInteger(a.getLabel()));
                //positive_int_edges = isInteger(a.getLabel());
                break;
            ]

            for (Edge a : n.getIncomingEdges()) {
                this.setPositive_int_edges(isInteger(a.getLabel()));
                //positive_int_edges = isInteger(a.getLabel());
                break;
            }
        }
    }
    //return positive_int_edges;
}