Comment vérifier si un nombre est NaN en Java

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si un nombre à virgule flottante est "Not a Number" (NaN) en Java. Nous explorerons la méthode Double.isNaN(), comprendrons comment les valeurs NaN sont générées par des opérations sur les nombres à virgule flottante, et examinerons comment gérer les entrées non à virgule flottante dans le contexte des vérifications de NaN. À la fin de ce laboratoire, vous serez en mesure de détecter et de gérer de manière fiable les valeurs NaN dans vos programmes Java.

Utilisez Double.isNaN() pour la vérification

Dans cette étape, nous apprendrons à vérifier si un nombre à virgule flottante est "Not a Number" (NaN) en Java en utilisant la méthode Double.isNaN().

Les nombres à virgule flottante dans les ordinateurs peuvent parfois donner lieu à une valeur spéciale appelée NaN. Cela se produit lorsque le résultat d'un calcul est indéfini ou ne peut pas être représenté comme un nombre standard. Par exemple, diviser zéro par zéro ou prendre la racine carrée d'un nombre négatif peut donner un résultat NaN.

Il est important de pouvoir détecter les valeurs NaN dans vos programmes car elles se comportent différemment des nombres ordinaires. Par exemple, comparer une valeur NaN avec n'importe quel autre nombre (même un autre NaN) en utilisant les opérateurs de comparaison standard (==, <, >) donnera toujours false.

Java fournit une méthode spécifique pour vérifier les valeurs NaN : Double.isNaN(). Cette méthode prend une valeur de type double en entrée et renvoie true si la valeur est NaN, et false dans le cas contraire.

Créons un simple programme Java pour démontrer comment utiliser Double.isNaN().

Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE.
Remplacez le code existant par le suivant :
```
public class CheckNaN {
    public static void main(String[] args) {
        double result1 = 0.0 / 0.0; // This will result in NaN
        double result2 = 10.0 / 2.0; // This is a regular number

        System.out.println("Is result1 NaN? " + Double.isNaN(result1));
        System.out.println("Is result2 NaN? " + Double.isNaN(result2));
    }
}
```
Dans ce code :
- Nous déclarons deux variables de type double, result1 et result2.
- result1 est affecté du résultat de 0.0 / 0.0, qui est une forme indéterminée et produira NaN.
- result2 est affecté du résultat de 10.0 / 2.0, qui est un nombre standard (5.0).
- Nous utilisons ensuite Double.isNaN() pour vérifier si result1 et result2 sont des valeurs NaN et affichons les résultats.
Enregistrez le fichier (Ctrl+S ou Cmd+S).
Maintenant, nous devons compiler ce nouveau programme. Comme nous avons changé le nom de la classe en CheckNaN, nous devons compiler CheckNaN.java. Ouvrez le terminal et exécutez :
```
javac CheckNaN.java
```
Si la compilation est réussie, vous ne devriez voir aucun message de sortie.
Enfin, exécutez le programme compilé :
```
java CheckNaN
```
Vous devriez voir une sortie similaire à ceci :
```
Is result1 NaN? true
Is result2 NaN? false
```
Cette sortie confirme que Double.isNaN() a correctement identifié result1 comme une valeur NaN et result2 comme un nombre ordinaire.

L'utilisation de Double.isNaN() est la manière correcte et fiable de vérifier les valeurs NaN en Java. Il n'est pas recommandé de s'appuyer sur une comparaison directe (== Double.NaN) car, comme mentionné précédemment, NaN == NaN s'évalue à false.

Testez avec des opérations sur les nombres à virgule flottante

Dans cette étape, nous explorerons plus d'exemples d'opérations sur les nombres à virgule flottante qui peuvent entraîner un résultat "Not a Number" (NaN) et nous pratiquerons l'utilisation de Double.isNaN() pour les vérifier. Comprendre quelles opérations produisent des valeurs NaN est crucial pour écrire un code Java robuste capable de gérer les erreurs potentielles de manière élégante.

En plus de la division de zéro par zéro, d'autres opérations impliquant l'infini ou des fonctions mathématiques invalides peuvent également produire des valeurs NaN. Java a des représentations spéciales pour l'infini positif et négatif (Double.POSITIVE_INFINITY et Double.NEGATIVE_INFINITY).

Modifions notre programme CheckNaN.java pour tester certains de ces cas.

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

Remplacez le code existant par le suivant :

public class CheckNaN {
    public static void main(String[] args) {
        double result1 = 0.0 / 0.0; // NaN
        double result2 = Math.sqrt(-1.0); // NaN (square root of a negative number)
        double result3 = Double.POSITIVE_INFINITY - Double.POSITIVE_INFINITY; // NaN
        double result4 = 10.0 / 0.0; // Positive Infinity
        double result5 = -10.0 / 0.0; // Negative Infinity
        double result6 = 5.0; // Regular number

        System.out.println("Is result1 NaN? " + Double.isNaN(result1));
        System.out.println("Is result2 NaN? " + Double.isNaN(result2));
        System.out.println("Is result3 NaN? " + Double.isNaN(result3));
        System.out.println("Is result4 NaN? " + Double.isNaN(result4));
        System.out.println("Is result5 NaN? " + Double.isNaN(result5));
        System.out.println("Is result6 NaN? " + Double.isNaN(result6));
    }
}

Dans ce code mis à jour :

result1 est toujours égal à 0.0 / 0.0.
result2 utilise Math.sqrt(-1.0), qui est mathématiquement indéfini pour les nombres réels et produit un résultat NaN.
result3 soustrait l'infini positif de l'infini positif, une autre forme indéterminée qui produit un résultat NaN.
result4 et result5 illustrent la division par zéro, qui produit l'infini positif ou négatif, et non un résultat NaN.
result6 est un simple nombre à des fins de comparaison.

Enregistrez le fichier (Ctrl+S ou Cmd+S).
Compilez le programme modifié dans le terminal :
```
javac CheckNaN.java
```
Encore une fois, l'absence de message de sortie indique que la compilation s'est déroulée avec succès.
Exécutez le programme :
```
java CheckNaN
```
Vous devriez voir une sortie similaire à ceci :
```
Is result1 NaN? true
Is result2 NaN? true
Is result3 NaN? true
Is result4 NaN? false
Is result5 NaN? false
Is result6 NaN? false
```
Cette sortie montre que Double.isNaN() a correctement identifié les trois opérations qui produisent des résultats NaN, tout en identifiant correctement les valeurs d'infini et le nombre ordinaire comme n'étant pas des résultats NaN.

En testant avec ces différentes opérations sur les nombres à virgule flottante, vous acquérez une meilleure compréhension des cas où des résultats NaN peuvent apparaître et de la manière d'utiliser Double.isNaN() pour gérer ces situations dans vos programmes.

Gérez les entrées non à virgule flottante

Dans les étapes précédentes, nous avons concentré notre attention sur la manière dont les opérations sur les nombres à virgule flottante peuvent entraîner un résultat "Not a Number" (NaN). Cependant, parfois, vous pourriez recevoir une entrée qui n'est pas un nombre valide du tout, comme du texte. Lorsque vous essayez de convertir une telle entrée en un nombre à virgule flottante, cela peut également entraîner des problèmes.

Bien que Double.isNaN() soit spécifiquement conçu pour vérifier le résultat de calculs sur les nombres à virgule flottante, il est également important de gérer les cas où l'entrée initiale ne peut pas être interprétée comme un nombre. Java fournit des méthodes pour convertir des chaînes de caractères en nombres, et ces méthodes peuvent lever des exceptions si l'entrée est invalide.

Créons un nouveau programme qui tente de convertir une entrée utilisateur en un nombre à virgule flottante (double) puis vérifie si la valeur convertie est NaN.

Créez un nouveau fichier dans le répertoire ~/project nommé ParseAndCheck.java. Vous pouvez le faire en cliquant avec le bouton droit dans l'explorateur de fichiers et en sélectionnant "Nouveau fichier", puis en tapant ParseAndCheck.java.
Ouvrez le fichier ParseAndCheck.java dans l'éditeur WebIDE et ajoutez le code suivant :
```
import java.util.Scanner;

public class ParseAndCheck {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter a floating-point number or an expression (e.g., 0.0/0.0): ");
        String input = scanner.nextLine();

        try {
            double value = Double.parseDouble(input);

            if (Double.isNaN(value)) {
                System.out.println("The input resulted in NaN.");
            } else {
                System.out.println("The input is a valid number: " + value);
            }
        } catch (NumberFormatException e) {
            System.out.println("Invalid input: Could not parse as a number.");
        } finally {
            scanner.close();
        }
    }
}
```
Analysons ce code :
- Nous importons la classe Scanner pour lire l'entrée utilisateur.
- Nous invitons l'utilisateur à saisir une chaîne de caractères.
- Nous utilisons un bloc try-catch pour gérer les erreurs potentielles lors de la conversion.
- Double.parseDouble(input) tente de convertir la chaîne de caractères d'entrée en un nombre de type double. Si la chaîne n'est pas au format d'un nombre valide (par exemple, "hello"), cela lèvera une NumberFormatException.
- À l'intérieur du bloc try, si la conversion réussit, nous utilisons ensuite Double.isNaN(value) pour vérifier si le nombre double obtenu est NaN.
- Le bloc catch intercepte la NumberFormatException et affiche un message d'erreur si l'entrée n'a pas pu être convertie.
- Le bloc finally garantit que le scanner est fermé.
Enregistrez le fichier (Ctrl+S ou Cmd+S).
Compilez le programme dans le terminal :
```
javac ParseAndCheck.java
```

Exécutez le programme :

java ParseAndCheck

Le programme vous demandera d'entrer une valeur. Essayez d'entrer différentes valeurs :

Entrez 5.5 :

Enter a floating-point number or an expression (e.g., 0.0/0.0): 5.5
The input is a valid number: 5.5

Entrez 0.0/0.0 :
```
Enter a floating-point number or an expression (e.g., 0.0/0.0): 0.0/0.0
Invalid input: Could not parse as a number.
```
(Note : parseDouble ne peut pas évaluer directement des expressions mathématiques. Il ne convertit que les représentations sous forme de chaîne de caractères de nombres.)

Entrez NaN :

Enter a floating-point number or an expression (e.g., 0.0/0.0): NaN
The input resulted in NaN.

Entrez hello :

Enter a floating-point number or an expression (e.g., 0.0/0.0): hello
Invalid input: Could not parse as a number.

Cette étape montre comment combiner la conversion d'entrée avec la vérification Double.isNaN() pour gérer différents types d'entrées, y compris les nombres valides, la chaîne "NaN" et les formats de nombres invalides. C'est une approche plus complète pour gérer les problèmes potentiels lors de la manipulation de nombres à virgule flottante provenant de sources externes.

Résumé

Dans ce laboratoire (lab), nous avons appris à vérifier si un nombre à virgule flottante est un "Not a Number" (NaN) en Java. Nous avons découvert que NaN est une valeur spéciale résultant de calculs indéfinis ou non représentables, et que les opérateurs de comparaison standard ne fonctionnent pas de manière fiable avec NaN.

Nous nous sommes particulièrement concentrés sur l'utilisation de la méthode Double.isNaN(), qui est la méthode standard et recommandée pour détecter précisément les valeurs NaN en Java. Nous avons démontré son utilisation à l'aide d'exemples impliquant des opérations sur les nombres à virgule flottante qui produisent des valeurs NaN ainsi que des résultats numériques normaux.