Comment vérifier si une chaîne de caractères peut être convertie en nombre à virgule flottante en Java

Introduction

Dans ce laboratoire, vous apprendrez à déterminer si une chaîne de caractères donnée peut être convertie avec succès en un nombre à virgule flottante à double précision en Java. Nous explorerons le processus d'essai d'analyse d'une chaîne de caractères à l'aide de Double.parseDouble(), comprendrons comment gérer les erreurs potentielles de NumberFormatException qui peuvent survenir si la chaîne de caractères n'est pas une représentation numérique valide, et discuterons des méthodes pour vérifier si une chaîne de caractères respecte un format décimal valide. À la fin de ce laboratoire, vous disposerez des connaissances nécessaires pour convertir en toute sécurité et efficacement des chaînes de caractères en nombres à virgule flottante dans vos applications Java.

Skills Graph

Tenter l'analyse avec Double.parseDouble()

Dans cette étape, nous apprendrons à convertir une représentation sous forme de chaîne de caractères d'un nombre en un type numérique en Java. C'est une tâche courante lorsque vous recevez une entrée d'un utilisateur ou lisez des données à partir d'un fichier, car l'entrée est souvent initialement lue sous forme de texte (chaînes de caractères).

Java propose plusieurs façons d'effectuer cette conversion. L'une des méthodes les plus courantes pour convertir une chaîne de caractères en un nombre à virgule flottante à double précision consiste à utiliser la méthode Double.parseDouble().

Créons un simple programme Java pour illustrer cela.

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 :

   import java.util.Scanner;
   
   public class HelloJava {
       public static void main(String[] args) {
           Scanner scanner = new Scanner(System.in);
   
           System.out.print("Enter a decimal number: ");
           String userInput = scanner.nextLine();
   
           // Attempt to parse the input string into a double
           double number = Double.parseDouble(userInput);
   
           System.out.println("You entered: " + number);
   
           scanner.close();
       }
   }

   Examinons les nouvelles parties de ce code :

   • System.out.print("Enter a decimal number: "); : Cette ligne invite l'utilisateur à saisir un nombre décimal.
   • String userInput = scanner.nextLine(); : Cette ligne lit l'entrée de l'utilisateur sous forme de chaîne de caractères et la stocke dans la variable userInput.
   • double number = Double.parseDouble(userInput); : C'est le cœur de cette étape. Double.parseDouble() prend la chaîne de caractères userInput et tente de la convertir en une valeur de type double. Si la chaîne de caractères peut être interprétée avec succès comme un nombre décimal, la valeur double résultante est stockée dans la variable number.
   • System.out.println("You entered: " + number); : Cette ligne affiche la valeur double analysée à l'utilisateur.

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

4. Maintenant, compilez le programme modifié. Ouvrez le terminal en bas de l'éditeur WebIDE et assurez-vous que vous êtes dans le répertoire ~/project. Ensuite, exécutez la commande suivante :

   javac HelloJava.java

   Si la compilation réussit, vous ne verrez aucun message de sortie.

5. Enfin, exécutez le programme :

   java HelloJava

6. Le programme vous invitera à saisir un nombre décimal. Tapez un nombre décimal valide, comme 123.45, puis appuyez sur Entrée.

   Enter a decimal number: 123.45
   You entered: 123.45

   Le programme devrait analyser avec succès votre entrée et afficher le nombre à l'écran.

Dans cette étape, vous avez utilisé avec succès Double.parseDouble() pour convertir une représentation sous forme de chaîne de caractères valide d'un nombre décimal en une valeur de type double. Cependant, que se passe-t-il si l'utilisateur saisit quelque chose qui n'est pas un nombre valide ? Nous explorerons cela dans l'étape suivante.

Gérer la NumberFormatException

Dans l'étape précédente, nous avons vu comment Double.parseDouble() fonctionne lorsque la chaîne de caractères d'entrée est un nombre décimal valide. Mais que se passe-t-il si l'utilisateur saisit du texte qui ne peut pas être converti en nombre ? Essayons.

1. Assurez-vous que vous êtes dans le répertoire ~/project dans le terminal.

2. Exécutez le programme à nouveau :

   java HelloJava

3. Lorsque vous êtes invité à saisir un nombre décimal, tapez quelque chose qui n'est clairement pas un nombre, comme hello ou abc.

   Enter a decimal number: hello

4. Appuyez sur Entrée. Vous verrez probablement beaucoup de texte rouge dans le terminal. Il s'agit d'un message d'erreur, plus précisément d'une NumberFormatException.

   Exception in thread "main" java.lang.NumberFormatException: For input string: "hello"
       at java.base/jdk.internal.math.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:2050)
       at java.base/jdk.internal.math.FloatingDecimal.parseDouble(FloatingDecimal.java:110)
       at java.base/java.lang.Double.parseDouble(Double.java:651)
       at HelloJava.main(HelloJava.java:10)

   Cette NumberFormatException se produit car la chaîne de caractères "hello" ne peut pas être analysée en une valeur double valide. Lorsqu'une exception de ce type se produit et n'est pas gérée, le programme plante et cesse d'exécuter.

   Dans les applications du monde réel, vous ne voulez pas que votre programme plante simplement parce qu'un utilisateur saisit une entrée invalide. Vous avez besoin d'un moyen de gérer gracieusement de telles erreurs. En Java, nous utilisons les blocs try-catch pour gérer les exceptions.

   Un bloc try-catch fonctionne comme suit :

   • Le code qui peut causer une exception est placé à l'intérieur du bloc try.
   • Si une exception se produit à l'intérieur du bloc try, le code à l'intérieur du bloc catch est exécuté.
   • Si aucune exception ne se produit, le bloc catch est ignoré.

Modifions notre programme pour utiliser un bloc try-catch pour gérer la NumberFormatException.

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

2. Modifiez le code pour envelopper l'appel à Double.parseDouble() dans un bloc try-catch :

   import java.util.Scanner;
   
   public class HelloJava {
       public static void main(String[] args) {
           Scanner scanner = new Scanner(System.in);
   
           System.out.print("Enter a decimal number: ");
           String userInput = scanner.nextLine();
   
           try {
               // Attempt to parse the input string into a double
               double number = Double.parseDouble(userInput);
               System.out.println("You entered: " + number);
           } catch (NumberFormatException e) {
               // This code runs if a NumberFormatException occurs
               System.out.println("Invalid input. Please enter a valid decimal number.");
           }
   
           scanner.close();
       }
   }

   Dans ce code mis à jour :

   • La ligne Double.parseDouble(userInput); se trouve à l'intérieur du bloc try.
   • Le bloc catch (NumberFormatException e) spécifie que si une NumberFormatException se produit dans le bloc try, le code à l'intérieur du bloc catch doit être exécuté.
   • À l'intérieur du bloc catch, nous affichons un message d'erreur convivial pour l'utilisateur au lieu de laisser le programme planter.

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

4. Compilez le programme modifié :

   javac HelloJava.java

5. Exécutez le programme à nouveau :

   java HelloJava

6. Lorsque vous êtes invité, saisissez à nouveau une entrée invalide comme hello.

   Enter a decimal number: hello
   Invalid input. Please enter a valid decimal number.

   Cette fois-ci, au lieu de planter, le programme a capturé la NumberFormatException et affiché le message du bloc catch. C'est une bien meilleure expérience utilisateur !

Vous avez maintenant appris à utiliser les blocs try-catch pour gérer les exceptions telles que la NumberFormatException, rendant vos programmes plus robustes et conviviaux pour l'utilisateur.

Vérifier le format décimal valide

Dans l'étape précédente, nous avons réussi à gérer la NumberFormatException en utilisant un bloc try-catch. Cela empêche notre programme de planter lorsque l'entrée n'est pas un nombre valide. Cependant, l'approche actuelle tente toujours d'analyser la chaîne de caractères et ne capture l'erreur qu'après l'échec de l'analyse.

Une approche plus proactive consiste à vérifier si la chaîne de caractères d'entrée a un format décimal valide avant d'essayer de l'analyser. Cela peut être fait en utilisant des expressions régulières ou d'autres techniques de validation. Pour ce laboratoire (lab), nous utiliserons une vérification simple dans une boucle pour demander à l'utilisateur de fournir une entrée jusqu'à ce qu'un nombre décimal valide soit fourni.

Cette approche combine le bloc try-catch avec une boucle pour nous assurer d'obtenir une entrée valide.

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

2. Modifiez le code pour inclure une boucle qui continue jusqu'à ce qu'une entrée valide soit reçue :

   import java.util.Scanner;
   
   public class HelloJava {
       public static void main(String[] args) {
           Scanner scanner = new Scanner(System.in);
           double number = 0.0; // Initialize with a default value
           boolean validInput = false; // Flag to track valid input
   
           while (!validInput) {
               System.out.print("Enter a decimal number: ");
               String userInput = scanner.nextLine();
   
               try {
                   // Attempt to parse the input string into a double
                   number = Double.parseDouble(userInput);
                   validInput = true; // Set flag to true if parsing is successful
               } catch (NumberFormatException e) {
                   // This code runs if a NumberFormatException occurs
                   System.out.println("Invalid input. Please enter a valid decimal number.");
               }
           }
   
           System.out.println("You entered a valid number: " + number);
   
           scanner.close();
       }
   }

   Examinons les modifications :

   • double number = 0.0; : Nous initialisons la variable number en dehors de la boucle.
   • boolean validInput = false; : Nous introduisons une variable booléenne validInput pour contrôler la boucle. Elle est initialement false.
   • while (!validInput) : Cela crée une boucle while qui continue tant que validInput est false.
   • À l'intérieur du bloc try, si Double.parseDouble() réussit, nous définissons validInput sur true. Cela fera terminer la boucle après l'itération actuelle.
   • Si une NumberFormatException se produit, le bloc catch est exécuté, validInput reste false, et la boucle continuera, invitant l'utilisateur à fournir une nouvelle entrée.
   • Après que la boucle se termine (ce qui signifie que validInput est true), nous affichons un message confirmant que l'entrée valide a été reçue.

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

4. Compilez le programme modifié :

   javac HelloJava.java

5. Exécutez le programme :

   java HelloJava

6. Maintenant, essayez d'abord d'entrer une entrée invalide, puis entrez un nombre décimal valide.

   Enter a decimal number: abc
   Invalid input. Please enter a valid decimal number.
   Enter a decimal number: 1.2.3
   Invalid input. Please enter a valid decimal number.
   Enter a decimal number: 789.01
   You entered a valid number: 789.01

   Le programme continuera de demander une entrée jusqu'à ce que vous fournissiez une chaîne de caractères que Double.parseDouble() peut convertir avec succès.

Vous avez maintenant implémenté une boucle de validation d'entrée de base qui assure que votre programme reçoit un nombre décimal valide de l'utilisateur avant de continuer. C'est un modèle fondamental pour gérer les entrées utilisateur dans de nombreuses applications.

Résumé

Dans ce laboratoire (lab), nous avons appris à vérifier si une chaîne de caractères peut être convertie en un nombre à virgule flottante (double) en Java. Nous avons commencé par tenter d'analyser une chaîne de caractères en un nombre à virgule flottante en utilisant la méthode Double.parseDouble(). Cette méthode est un moyen courant de convertir les représentations sous forme de chaîne de caractères de nombres en types numériques, particulièrement utile lors de la gestion des entrées utilisateur ou des données lues à partir de fichiers. Nous avons implémenté un simple programme Java qui invite l'utilisateur à fournir une entrée, la lit sous forme de chaîne de caractères, puis utilise Double.parseDouble() pour la convertir en un nombre à virgule flottante, démontrant le processus de base de conversion d'une chaîne de caractères en nombre à virgule flottante.