Comment vérifier si une chaîne de caractères peut être convertie en entier en Java

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si une chaîne de caractères peut être convertie en entier en Java. Il s'agit d'une compétence fondamentale pour gérer les entrées utilisateur ou les données provenant de sources externes.

Vous explorerez la méthode Integer.parseInt() pour tenter la conversion, apprendrez à gérer les erreurs potentielles à l'aide de NumberFormatException, et découvrirez des techniques pour valider une chaîne de caractères avant de tenter de la parser, afin d'assurer un code robuste et exempt d'erreurs.

Essayer de parser avec Integer.parseInt()

Dans cette étape, nous allons explorer comment convertir une String (chaîne de caractères) en int (nombre entier) en Java. C'est une tâche courante en programmation, notamment lorsque vous avez besoin d'obtenir des entrées numériques d'un utilisateur ou de lire des nombres à partir d'un fichier.

Java fournit une méthode intégrée appelée Integer.parseInt() à cet effet. Voyons comment elle fonctionne.

Tout d'abord, assurez-vous d'être dans le répertoire ~/project. Vous pouvez utiliser la commande cd ~/project dans le Terminal si nécessaire.
Maintenant, créons un nouveau fichier Java nommé StringToInt.java dans le répertoire ~/project. Vous pouvez le faire en cliquant avec le bouton droit dans l'Explorateur de fichiers à gauche, en sélectionnant "Nouveau fichier" et en tapant StringToInt.java.
Ouvrez le fichier StringToInt.java dans l'Éditeur de code et collez le code suivant :
```
public class StringToInt {
    public static void main(String[] args) {
        String numberString = "123";
        int numberInt = Integer.parseInt(numberString);

        System.out.println("The string is: " + numberString);
        System.out.println("The integer is: " + numberInt);
    }
}
```
Examinons les nouvelles parties :
- String numberString = "123"; : Nous déclarons une variable de type String nommée numberString et lui assignons la valeur "123". Notez que "123" est entouré de guillemets doubles, indiquant qu'il s'agit d'une chaîne de caractères.
- int numberInt = Integer.parseInt(numberString); : C'est le cœur de cette étape. Nous appelons la méthode Integer.parseInt(), en passant notre numberString comme argument. Cette méthode tente de convertir la chaîne de caractères "123" en un entier. Le résultat est stocké dans une variable de type int nommée numberInt.
- System.out.println("The string is: " + numberString); : Cette ligne affiche la chaîne de caractères originale.
- System.out.println("The integer is: " + numberInt); : Cette ligne affiche l'entier converti.
Enregistrez le fichier (Ctrl+S ou Cmd+S).
Maintenant, compilons le programme. Ouvrez le Terminal et exécutez la commande suivante :
```
javac StringToInt.java
```
Si la compilation réussit, vous ne devriez voir aucun message de sortie, et un fichier StringToInt.class sera créé dans le répertoire ~/project.
Enfin, exécutez le programme compilé :
```
java StringToInt
```
Vous devriez voir la sortie suivante :
```
The string is: 123
The integer is: 123
```
Comme vous pouvez le voir, la méthode Integer.parseInt() a réussi à convertir la chaîne de caractères "123" en l'entier 123.

Dans l'étape suivante, nous explorerons ce qui se passe lorsque la chaîne de caractères ne peut pas être convertie en un entier.

Attraper l'exception NumberFormatException

Dans l'étape précédente, nous avons réussi à convertir une chaîne de caractères contenant uniquement des chiffres en un entier en utilisant Integer.parseInt(). Mais que se passe-t-il si la chaîne de caractères contient des caractères qui ne sont pas des chiffres ? Allons-y découvrir.

Lorsque Integer.parseInt() tente de convertir une chaîne de caractères qui n'est pas une représentation valide d'un nombre, il lance une NumberFormatException. Il s'agit d'un type d'erreur qui indique un problème avec le format de la chaîne de caractères représentant un nombre.

Pour gérer de telles erreurs de manière élégante, nous pouvons utiliser un bloc try-catch. Un bloc try-catch nous permet de « tester » un morceau de code qui peut causer une erreur, et si une erreur se produit, nous pouvons la « capturer » et la gérer de manière spécifique, empêchant ainsi notre programme de planter.

Modifions notre programme StringToInt.java pour démontrer cela.

Ouvrez le fichier StringToInt.java dans l'éditeur WebIDE.
Modifiez le code pour inclure un bloc try-catch et changez la chaîne de caractères d'entrée :
```
public class StringToInt {
    public static void main(String[] args) {
        String numberString = "abc"; // This string cannot be parsed as an integer

        try {
            int numberInt = Integer.parseInt(numberString);
            System.out.println("The string is: " + numberString);
            System.out.println("The integer is: " + numberInt);
        } catch (NumberFormatException e) {
            System.out.println("Error: Could not convert the string to an integer.");
            System.out.println("Details: " + e.getMessage());
        }
    }
}
```
Voici ce que nous avons ajouté :
- String numberString = "abc"; : Nous avons changé la chaîne de caractères en "abc", qui n'est clairement pas un entier valide.
- try { ... } : Le code à l'intérieur du bloc try est ce que nous voulons tester. Dans ce cas, il s'agit de l'appel à Integer.parseInt().
- catch (NumberFormatException e) { ... } : Si une NumberFormatException se produit à l'intérieur du bloc try, le code à l'intérieur du bloc catch sera exécuté.
- System.out.println("Error: Could not convert the string to an integer."); : Cette ligne affiche un message d'erreur convivial pour l'utilisateur.
- System.out.println("Details: " + e.getMessage()); : Cette ligne affiche plus de détails sur l'exception, ce qui peut être utile pour le débogage.
Enregistrez le fichier (Ctrl+S ou Cmd+S).
Compilez le programme modifié dans le Terminal :
```
javac StringToInt.java
```
Exécutez le programme compilé :
```
java StringToInt
```
Cette fois-ci, parce que "abc" ne peut pas être analysé comme un entier, l'exception NumberFormatException sera capturée, et vous devriez voir une sortie similaire à celle-ci :
```
Error: Could not convert the string to an integer.
Details: For input string: "abc"
```
Au lieu de faire planter le programme, le bloc catch a géré l'erreur et affiché un message utile. C'est une bien meilleure expérience pour l'utilisateur !

L'utilisation de blocs try-catch est cruciale pour écrire des programmes robustes capables de gérer des entrées ou des situations inattendues.

Valider la chaîne de caractères avant le parsing

Dans l'étape précédente, nous avons appris à capturer une NumberFormatException lorsque Integer.parseInt() échoue. Bien que la capture d'exceptions soit importante pour gérer les erreurs, il est souvent préférable d'empêcher l'erreur de se produire dès le départ.

Dans cette étape, nous allons apprendre à valider une chaîne de caractères avant de tenter de la parser en tant qu'entier. Cela consiste à vérifier si la chaîne de caractères ne contient que des chiffres.

Une façon de faire cela est d'itérer sur chaque caractère de la chaîne de caractères et de vérifier s'il s'agit d'un chiffre. Une autre approche courante consiste à utiliser des expressions régulières, mais pour les débutants, une simple boucle est plus facile à comprendre.

Modifions à nouveau notre programme StringToInt.java pour inclure une vérification de validation.

Ouvrez le fichier StringToInt.java dans l'éditeur WebIDE.

Remplacez le code existant par le suivant :

public class StringToInt {

    public static void main(String[] args) {
        String numberString = "123a"; // This string contains a non-digit character

        if (isValidInteger(numberString)) {
            int numberInt = Integer.parseInt(numberString);
            System.out.println("The string is: " + numberString);
            System.out.println("The integer is: " + numberInt);
        } else {
            System.out.println("Error: The string '" + numberString + "' is not a valid integer.");
        }
    }

    // Method to check if a string is a valid integer
    public static boolean isValidInteger(String str) {
        if (str == null || str.isEmpty()) {
            return false; // An empty or null string is not a valid integer
        }
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            if (i == 0 && (c == '-' || c == '+')) {
                // Allow a leading sign (+ or -)
                continue;
            }
            if (!Character.isDigit(c)) {
                return false; // Found a non-digit character
            }
        }
        return true; // All characters are digits (or a leading sign)
    }
}

Examinons les modifications :

Nous avons ajouté une nouvelle méthode appelée isValidInteger(String str). Cette méthode prend une chaîne de caractères en entrée et renvoie true si la chaîne de caractères représente un entier valide, et false sinon.
À l'intérieur de isValidInteger, nous vérifions d'abord si la chaîne de caractères est nulle ou vide.
Nous parcourons ensuite chaque caractère de la chaîne de caractères.
Character.isDigit(c) est une méthode intégrée de Java qui vérifie si un caractère est un chiffre.
Nous avons ajouté une vérification pour autoriser un signe plus ou moins au début.
Dans la méthode main, nous utilisons maintenant une instruction if-else. Nous appelons isValidInteger() pour vérifier la chaîne de caractères avant de tenter de la parser.
Si isValidInteger() renvoie true, nous procédons avec Integer.parseInt().
Si elle renvoie false, nous affichons un message d'erreur sans tenter de parser, évitant ainsi la NumberFormatException.

Enregistrez le fichier (Ctrl+S ou Cmd+S).
Compilez le programme modifié dans le Terminal :
```
javac StringToInt.java
```
Exécutez le programme compilé :
```
java StringToInt
```
Étant donné que la chaîne de caractères "123a" contient un caractère qui n'est pas un chiffre, la méthode isValidInteger renverra false, et vous devriez voir la sortie suivante :
```
Error: The string '123a' is not a valid integer.
```
Maintenant, changeons la chaîne de caractères en un entier valide pour voir l'autre branche de l'instruction if-else.
Changez la variable numberString en "456" dans le fichier StringToInt.java :
```
String numberString = "456";
```
Enregistrez le fichier.
Compilez et exécutez le programme à nouveau :
```
javac StringToInt.java
java StringToInt
```
Cette fois-ci, isValidInteger renverra true, et vous devriez voir :
```
The string is: 456
The integer is: 456
```

En validant la chaîne de caractères avant le parsing, nous pouvons gérer les entrées invalides de manière plus élégante et éviter les erreurs d'exécution telles que la NumberFormatException. C'est une bonne pratique pour écrire un code plus robuste et fiable.

Résumé

Dans ce laboratoire (lab), nous avons appris à convertir une String en un int en Java en utilisant la méthode Integer.parseInt(). Nous avons créé un fichier Java, écrit du code pour démontrer la conversion et compilé le programme. Cette méthode est essentielle pour gérer les entrées numériques provenant de diverses sources.