Comment vérifier si une chaîne de caractères est numérique en Java

Introduction

Dans ce laboratoire (lab), vous allez apprendre différentes méthodes pour vérifier si une chaîne de caractères donnée en Java représente une valeur numérique. Nous commencerons par explorer comment tenter de convertir une chaîne de caractères en entier et gérer les erreurs potentielles lorsque la chaîne n'est pas un nombre valide.

Ensuite, vous découvrirez comment exploiter le pouvoir des expressions régulières pour effectuer une vérification numérique plus flexible et robuste. Enfin, nous approfondirons notre compréhension pour gérer les chaînes représentant des nombres négatifs et des valeurs décimales, afin que nos vérifications numériques soient exhaustives.

Skills Graph

Tenter de convertir une chaîne de caractères en entier

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

Java propose une méthode intégrée pour cela en utilisant la méthode Integer.parseInt(). Cependant, que se passe-t-il si la chaîne de caractères ne représente pas réellement un nombre valide ? Découvrons-le en écrivant un simple programme Java.

1. Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE s'il n'est pas déjà ouvert.

2. Remplacez tout le contenu du fichier par le code suivant :

   public class HelloJava {
       public static void main(String[] args) {
           String numberString = "123";
           int number = Integer.parseInt(numberString);
           System.out.println("Successfully parsed: " + number);
   
           String invalidString = "abc";
           try {
               int invalidNumber = Integer.parseInt(invalidString);
               System.out.println("This line will not be reached.");
           } catch (NumberFormatException e) {
               System.out.println("Error: Could not parse '" + invalidString + "' to an integer.");
               System.out.println("Exception details: " + e.getMessage());
           }
       }
   }

   Examinons les nouvelles parties de ce code :

   • String numberString = "123"; : Nous créons une variable de type chaîne de caractères numberString et lui assignons la valeur "123".
   • int number = Integer.parseInt(numberString); : C'est le cœur de la conversion. Integer.parseInt() tente de convertir la chaîne de caractères "123" en entier. Comme "123" est une représentation valide d'un entier, cela réussira, et la valeur entière 123 sera stockée dans la variable number.
   • String invalidString = "abc"; : Nous créons une autre variable de type chaîne de caractères invalidString et lui assignons la valeur "abc". Cette chaîne de caractères ne représente pas un entier valide.
   • try { ... } catch (NumberFormatException e) { ... } : Il s'agit d'un bloc try-catch, qui est utilisé pour gérer les erreurs (exceptions) en Java.
     • Le code à l'intérieur du bloc try est l'endroit où nous plaçons l'opération susceptible de causer une erreur. Dans ce cas, il s'agit de Integer.parseInt(invalidString).
     • Si Integer.parseInt("abc") échoue car "abc" n'est pas un nombre valide, il "lèvera" une NumberFormatException.
     • Le bloc catch (NumberFormatException e) "attrape" ce type spécifique d'exception. Le code à l'intérieur du bloc catch sera alors exécuté.
   • System.out.println("Error: Could not parse '" + invalidString + "' to an integer."); : Cette ligne sera affichée si la NumberFormatException se produit.
   • System.out.println("Exception details: " + e.getMessage()); : Cela affiche un message plus précis sur l'erreur fourni par l'objet d'exception e.

3. Enregistrez le fichier (Ctrl+S ou Cmd+S).

4. Compilez le programme dans le terminal :

   javac HelloJava.java

   S'il n'y a pas d'erreurs, vous ne verrez aucun résultat.

5. Exécutez le programme compilé :

   java HelloJava

   Vous devriez voir un résultat similaire à ceci :

   Successfully parsed: 123
   Error: Could not parse 'abc' to an integer.
   Exception details: For input string: "abc"

   Ce résultat montre que la première tentative de conversion a réussi, mais que la deuxième tentative avec la chaîne de caractères invalide "abc" a entraîné une NumberFormatException, et notre bloc catch l'a gérée correctement en affichant un message d'erreur.

Cela démontre l'importance de gérer les erreurs potentielles lors de la conversion de chaînes de caractères en nombres, car toutes les chaînes de caractères ne peuvent pas être converties avec succès. L'utilisation de blocs try-catch est une méthode standard pour gérer de telles situations en Java.

Utiliser des expressions régulières pour vérifier si une chaîne est numérique

Dans l'étape précédente, nous avons vu que Integer.parseInt() lève une exception si la chaîne de caractères n'est pas un entier valide. Bien que le bloc try-catch soit utile pour gérer l'erreur lorsqu'elle se produit, il peut arriver que vous souhaitiez vérifier si une chaîne de caractères peut être convertie en nombre avant d'effectuer la conversion. C'est là que les expressions régulières (Regex) sont utiles.

Les expressions régulières sont des motifs puissants utilisés pour trouver des combinaisons de caractères dans les chaînes de caractères. Nous pouvons utiliser un motif d'expression régulière simple pour vérifier si une chaîne de caractères ne contient que des chiffres.

1. Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE.

2. Remplacez tout le contenu du fichier par le code suivant :

   public class HelloJava {
       public static void main(String[] args) {
           String numberString = "123";
           String invalidString = "abc";
           String mixedString = "123a";
   
           System.out.println("Checking string: \"" + numberString + "\"");
           if (numberString.matches("\\d+")) {
               System.out.println("  Matches the pattern (contains only digits).");
               int number = Integer.parseInt(numberString);
               System.out.println("  Parsed integer: " + number);
           } else {
               System.out.println("  Does not match the pattern.");
           }
   
           System.out.println("\nChecking string: \"" + invalidString + "\"");
           if (invalidString.matches("\\d+")) {
               System.out.println("  Matches the pattern (contains only digits).");
           } else {
               System.out.println("  Does not match the pattern.");
           }
   
           System.out.println("\nChecking string: \"" + mixedString + "\"");
           if (mixedString.matches("\\d+")) {
               System.out.println("  Matches the pattern (contains only digits).");
           } else {
               System.out.println("  Does not match the pattern.");
           }
       }
   }

   Analysons les nouvelles parties :

   • numberString.matches("\\d+") : C'est la partie essentielle. La méthode matches() est disponible sur tous les objets de type chaîne de caractères en Java. Elle vérifie si l'ensemble de la chaîne de caractères correspond au motif d'expression régulière donné.
   • "\\d+" : C'est le motif d'expression régulière.
     • \\d : Cela correspond à n'importe quel chiffre (de 0 à 9). Nous utilisons \\ car \ est un caractère spécial dans les chaînes de caractères Java, donc nous devons l'échapper.
     • + : C'est un quantificateur qui signifie "un ou plusieurs" de l'élément précédent. Ainsi, \\d+ signifie "un ou plusieurs chiffres".
   • La condition if vérifie le résultat de matches(). Si elle retourne true, cela signifie que la chaîne de caractères est composée entièrement d'un ou plusieurs chiffres. Si elle retourne false, cela signifie que la chaîne de caractères contient des caractères autres que des chiffres ou est vide.

3. Enregistrez le fichier (Ctrl+S ou Cmd+S).

4. Compilez le programme dans le terminal :

   javac HelloJava.java

   Vous ne devriez voir aucun résultat si la compilation réussit.

5. Exécutez le programme compilé :

   java HelloJava

   Vous devriez voir un résultat similaire à ceci :

   Checking string: "123"
     Matches the pattern (contains only digits).
     Parsed integer: 123
   
   Checking string: "abc"
     Does not match the pattern.
   
   Checking string: "123a"
     Does not match the pattern.

   Comme vous pouvez le voir, la vérification matches("\\d+") a correctement identifié "123" comme ne contenant que des chiffres, tandis que "abc" et "123a" ne correspondent pas au motif. Cette approche vous permet de valider le format de la chaîne de caractères avant d'essayer de la convertir, évitant potentiellement des NumberFormatException dans certains cas.

Gérer les nombres négatifs et décimaux

Dans les étapes précédentes, nous nous sommes concentrés sur la conversion de nombres entiers positifs. Cependant, les nombres peuvent également être négatifs ou avoir des décimales. Dans cette étape, nous allons apprendre à gérer ces cas lors de la conversion de chaînes de caractères en nombres en Java.

Java propose différentes méthodes pour convertir différents types de nombres :

• Integer.parseInt() : Pour les nombres entiers (entiers).
• Double.parseDouble() : Pour les nombres à virgule (nombres à virgule flottante).

Modifions notre programme pour gérer les entiers négatifs et les nombres décimaux.

1. Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE.

2. Remplacez tout le contenu du fichier par le code suivant :

   public class HelloJava {
       public static void main(String[] args) {
           String positiveIntString = "456";
           String negativeIntString = "-789";
           String decimalString = "123.45";
           String invalidString = "not a number";
   
           // Handling Integers (positive and negative)
           System.out.println("Attempting to parse integers:");
           try {
               int positiveInt = Integer.parseInt(positiveIntString);
               System.out.println("  Parsed '" + positiveIntString + "' as integer: " + positiveInt);
           } catch (NumberFormatException e) {
               System.out.println("  Could not parse '" + positiveIntString + "' as integer.");
           }
   
           try {
               int negativeInt = Integer.parseInt(negativeIntString);
               System.out.println("  Parsed '" + negativeIntString + "' as integer: " + negativeInt);
           } catch (NumberFormatException e) {
               System.out.println("  Could not parse '" + negativeIntString + "' as integer.");
           }
   
           try {
               int decimalAsInt = Integer.parseInt(decimalString);
               System.out.println("  Parsed '" + decimalString + "' as integer: " + decimalAsInt);
           } catch (NumberFormatException e) {
               System.out.println("  Could not parse '" + decimalString + "' as integer.");
           }
   
           // Handling Decimal Numbers
           System.out.println("\nAttempting to parse decimal numbers:");
           try {
               double decimal = Double.parseDouble(decimalString);
               System.out.println("  Parsed '" + decimalString + "' as double: " + decimal);
           } catch (NumberFormatException e) {
               System.out.println("  Could not parse '" + decimalString + "' as double.");
           }
   
           try {
               double intAsDouble = Double.parseDouble(positiveIntString);
               System.out.println("  Parsed '" + positiveIntString + "' as double: " + intAsDouble);
           } catch (NumberFormatException e) {
               System.out.println("  Could not parse '" + positiveIntString + "' as double.");
           }
   
            try {
               double invalidAsDouble = Double.parseDouble(invalidString);
               System.out.println("  Parsed '" + invalidString + "' as double: " + invalidAsDouble);
           } catch (NumberFormatException e) {
               System.out.println("  Could not parse '" + invalidString + "' as double.");
           }
       }
   }

   Voici ce qui se passe :

   • Nous avons maintenant des chaînes de caractères représentant un entier positif, un entier négatif, un nombre décimal et une chaîne invalide.
   • Nous utilisons Integer.parseInt() dans des blocs try-catch pour tenter de convertir les chaînes de caractères en entiers. Notez que Integer.parseInt() peut gérer le signe négatif (-). Cependant, il lèvera une NumberFormatException si la chaîne de caractères contient une virgule décimale ou des caractères non numériques.
   • Nous utilisons Double.parseDouble() dans des blocs try-catch pour tenter de convertir les chaînes de caractères en nombres décimaux (doubles). Double.parseDouble() peut gérer à la fois les entiers et les nombres à virgule. Il lèvera une NumberFormatException pour les chaînes de caractères qui ne sont pas des représentations valides d'un double.

3. Enregistrez le fichier (Ctrl+S ou Cmd+S).

4. Compilez le programme dans le terminal :

   javac HelloJava.java

   Vous ne devriez voir aucun résultat si la compilation réussit.

5. Exécutez le programme compilé :

   java HelloJava

   Vous devriez voir un résultat similaire à ceci :

   Attempting to parse integers:
     Parsed '456' as integer: 456
     Parsed '-789' as integer: -789
     Could not parse '123.45' as integer.
   
   Attempting to parse decimal numbers:
     Parsed '123.45' as double: 123.45
     Parsed '456' as double: 456.0
     Could not parse 'not a number' as double.

   Ce résultat montre que Integer.parseInt() a correctement converti les entiers positifs et négatifs, mais a échoué avec la chaîne de caractères décimale. Double.parseDouble() a réussi à convertir à la fois la chaîne de caractères décimale et la chaîne de caractères entière (en la représentant comme un double, par exemple 456.0), mais a échoué avec la chaîne de caractères invalide.

Cette étape démontre comment utiliser les méthodes de conversion appropriées pour différents types de nombres et renforce l'importance d'utiliser des blocs try-catch pour gérer les erreurs potentielles de NumberFormatException lorsque la chaîne de caractères d'entrée peut ne pas être au format attendu.

Résumé

Dans ce laboratoire, nous avons appris à vérifier si une chaîne de caractères est numérique en Java. Nous avons d'abord exploré l'utilisation de Integer.parseInt() pour tenter de convertir une chaîne de caractères en entier, en comprenant que cette méthode lève une NumberFormatException si la chaîne de caractères n'est pas une représentation valide d'un entier. Nous avons vu comment gérer cette exception à l'aide d'un bloc try-catch pour gérer de manière élégante les chaînes de caractères non numériques.

En nous appuyant sur cela, nous avons ensuite appris à utiliser les expressions régulières comme une approche plus flexible pour vérifier les chaînes de caractères numériques, qui peut gérer différents formats. Enfin, nous avons élargi notre compréhension pour inclure la gestion des nombres négatifs et décimaux lors de la détermination si une chaîne de caractères représente une valeur numérique.