[JAVA] Vérifiez si une chaîne peut être convertie en int sans utiliser Integer # parseInt

Si vous souhaitez vérifier si la chaîne de caractères d'entrée est convertie en type int, vous pouvez voir le code source qui juge comme suit.

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

__ Personnellement, je me sentais mal à l'aise avec cette méthode, comme la convertir en faux si elle ne fonctionnait pas, puis en serrant les exceptions, alors j'ai été en quelque sorte évité. __ Pour le dire clairement, j'ai une aversion physiologique.

C'est pourquoi j'ai créé une méthode __ pour vérifier si une chaîne donnée peut être convertie en int sans utiliser __ʻInteger # parseInt` (´ ・ ω ・ ｀)

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
        
        //Même la valeur limite peut être évaluée avec précision.
        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 Ajout de cas de test.===
        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        
    }
    

    /**
     *Détermine si la chaîne est un entier décimal et appartient à la catégorie int.
     * @param str La chaîne de caractères à juger.
     * @Vrai si la chaîne de retour est un entier décimal et appartient à la catégorie int.
     */
    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-Il y avait une erreur de logique, donc cela a été complètement corrigé.===
//    /**
//     *Détermine si la chaîne est un entier décimal et appartient à la catégorie int.
//     * @param str La chaîne de caractères à juger.
//     * @Vrai si la chaîne de retour est un entier décimal et appartient à la catégorie int.
//     */
//    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;
//    }
}

C'est un algorithme, ou quelque chose de très simple, il vérifie simplement caractère par caractère pour voir si un argument donné peut être converti en un entier. La seule différence avec la méthode d'utilisation de ʻInteger # parseInt` est qu'elle n'utilise pas d'exceptions, mais je pense personnellement qu'elle est plus sophistiquée que "false si c'est une exception". Satisfaction de soi (´ ・ ω ・ ｀)