Shouldn't we use an exception in the method of determining whether it's an integer?

What does the isInteger() method mean?Consider two patterns.

If it is 1, I don't think there is any need to make any significant changes from the current implementation, because the implementation is exactly what it means.Rather, it is difficult to distinguish between integers that exceed the int range (simply \A[+-]?0*\d{1,10}\z, where "2147483647" also matches "2147483648" in the range.The regular expression is more complex because Integer.parseInt() can interpret so-called full-width numbers (U+FF10'0' to U+FF19'9').Therefore, using exception handling for Integer.parseInt() is quite normal considering its readability and ease of implementation.If you try to perform string analysis by force, you will almost end up doing the same thing as implementing Integer.parseInt(), which will be wasteful.If you dare to fix it, it might be a good idea to return early without catch NullPointerException.

private boolean isInteger(String str){
    if(str==null)return false;

    try{
        Integer.parseInt(str);
    } catch(NumberFormatExceptione){
        return false;
    }

    return true;
}

Regardless of the implementation of Integer.parseInt(), if you want to see if it's an integer decimal representation, regardless of int, it might mean something like 2.

What is the decimal representation of an integer?For example, the following definitions are possible:

Consists of one or more characters in the range
• U+0030'0' to U+0039'9'.
• You can start with U+002B'+' or U+002D'-'.
• There is no limit to the number of digits.
• Any number of U+0030'0' may be buried on the left.("42" as well as "00000042")

With this definition, using regular expressions would be \A[+-]?\d+\z, so it would look like this:

private boolean isInteger(String str){
    return java.util.regex.pattern.matches("\\A[+-]?\\d+\\z", str);
}

You do not necessarily need to use regular expressions.If you are not good at regular expressions, you can do the following:

private static boolean isInteger (String str) {
    if(str.isEmpty()) return false;

    var first = str.charAt(0);
    varskip=first=='+'||first=='-'?1:0;
    return str.chars().skip(skip).allMatch(c->c>='0'&c<='9');
}

Of course, you cannot use Integer.parseInt() to implement this 2.

There are many books and articles in the world, including Effective Java, that say, "I recommend you to write this code," but you don't have to force yourself to follow them.Instead of following the principles, we should consider whether the meaning of the principles applies to the current code, and conversely, whether there is any deterioration in readability or efficiency.There's no answer like this way.It's important to ask for more, but if you ask too much, it can only reduce efficiency, so it may be important to have a sense of balance.

I didn't read Effective Java, but if the quoted text is to the same effect as other best practices for handling exceptions, "You should not use the method of throwing exceptions.It should be rewritten by another means. is not an argument.

The key is whether isInterger throws exceptions and how they are used.What happens to the internal implementation of isInteger is not a point.

If isInteger is a method that throws exceptions when it does not meet the criteria, and it is just like checking parameters for higher methods, it is a bad practice.