[JAVA] Überprüfen Sie, ob eine Zeichenfolge ohne Verwendung von Integer # parseInt in int konvertiert werden kann

Wenn Sie überprüfen möchten, ob die eingegebene Zeichenfolge in den Typ int konvertiert wurde, wird möglicherweise der folgende Quellcode angezeigt.

try {
    Integer.parseInt(str);
    return true;
} catch (NumberFormatException e) {
    return false;
}

__ Ich persönlich fühlte mich mit dieser Methode unwohl, z. B. sie in false umzuwandeln, wenn sie nicht funktionierte, und dann die Ausnahmen zu quetschen. __ Um es klar auszudrücken, ich habe eine physiologische Abneigung.

Aus diesem Grund habe ich eine Methode __ erstellt, um zu überprüfen, ob die angegebene Zeichenfolge ohne Verwendung von __Integer # parseInt (´ ・ ω ・ ｀) in int konvertiert werden kann.

final public class IntegerUtils {
    
    public static void main(String[] args) {
        System.out.println(IntegerUtils.isInteger("123")); //=> true
        System.out.println(IntegerUtils.isInteger("-23")); //=> true
        System.out.println(IntegerUtils.isInteger("12A")); //=> false
        System.out.println(IntegerUtils.isInteger("ABC")); //=> false
        
        //Auch der Grenzwert kann genau beurteilt werden.
        System.out.println(IntegerUtils.isInteger("2147483647")); //=> true
        System.out.println(IntegerUtils.isInteger("2147483648")); //=> false
        System.out.println(IntegerUtils.isInteger("-2147483648")); //=> true
        System.out.println(IntegerUtils.isInteger("-2147483649")); //=> false
        
        // ==== 2017-05-16 Testfälle hinzugefügt.===
        System.out.println(IntegerUtils.isInteger("0")); //=> true
        System.out.println(IntegerUtils.isInteger("473")); //=> true
        System.out.println(IntegerUtils.isInteger("+42")); //=> true
        System.out.println(IntegerUtils.isInteger("-0")); //=> true

        System.out.println(IntegerUtils.isInteger("-")); //=> false
        System.out.println(IntegerUtils.isInteger("+5")); //=> true
        System.out.println(IntegerUtils.isInteger("１２３")); //=> true
        System.out.println(IntegerUtils.isInteger("١٢٣")); //=> true        
    }
    

    /**
     *Bestimmt, ob die Zeichenfolge eine Dezimalzahl ist und in die Kategorie int fällt.
     * @param str Die zu beurteilende Zeichenkette.
     * @True, wenn die Rückgabezeichenfolge eine Dezimalzahl ist und in die Kategorie int fällt.
     */
    public static final boolean isInteger(String str) {
        if (str == null
        		|| str.isEmpty()
        		|| str.equals("+")
        		|| str.equals("-")) {
            return false;
        }

        char first = str.charAt(0);
        int i = (first == '+' || first == '-') ? 1 : 0;
        int sign = (first == '-') ? -1 : 1;
        int len = str.length();
        long integer = 0;

        while (i < len) {
        	char ch = str.charAt(i++);
            int digit = Character.digit(ch, 10);
            if (digit == -1) {
            	return false;
            }

            integer = integer * 10 + sign * digit;
            if (integer < Integer.MIN_VALUE || Integer.MAX_VALUE < integer) {
                return false;
            }
        }
        return true;
    }



//    ==== 2017-05-16 In der Logik ist ein Fehler aufgetreten, der vollständig korrigiert wurde.===
//    /**
//     *Bestimmt, ob die Zeichenfolge eine Dezimalzahl ist und in die Kategorie int fällt.
//     * @param str Die zu beurteilende Zeichenkette.
//     * @True, wenn die Rückgabezeichenfolge eine Dezimalzahl ist und in die Kategorie int fällt.
//     */
//    public static final boolean isInteger(String str) {        
//        if (str == null || str.isEmpty()) {
//            return false;
//        }
//        
//        boolean isNegative = str.charAt(0) == '-';
//        int i = isNegative ? 1 : 0;
//        int sign = isNegative ? -1: 1;
//        int len = str.length();
//        long integer = 0;
//        
//        while (i < len) {
//            int digit = str.charAt(i++) - '0';
//            if (digit < 0 || 9 < digit) {
//                return false;
//            }
//            
//            integer = integer * 10 + sign * digit;
//            if (integer < Integer.MIN_VALUE || Integer.MAX_VALUE < integer) {
//                return false;
//            }
//        }
//        return true;
//    }
}

Es ist ein Algorithmus oder etwas sehr Einfaches. Es prüft nur Zeichen für Zeichen, ob ein bestimmtes Argument in eine Ganzzahl konvertiert werden kann. Der einzige Unterschied zur Verwendung von "Integer # parseInt" besteht darin, dass keine Ausnahmen verwendet werden, aber ich persönlich bin der Meinung, dass es komplexer ist als "false, wenn es sich um eine Ausnahme handelt". Selbstzufriedenheit (´ ´ ω ・ ｀)