Comment vérifier si un nombre est un double en Java

Introduction

Dans ce laboratoire (lab), vous apprendrez à déterminer si un nombre est un nombre à virgule flottante double (double) en Java. Nous explorerons différentes techniques, en commençant par vérifier si un objet est une instance de la classe wrapper Double à l'aide de l'opérateur instanceof.

Ensuite, vous apprendrez à convertir (parser) une chaîne de caractères en nombre à virgule flottante double et à gérer les erreurs potentielles. Enfin, nous aborderons la façon de différencier les types Double et Integer pour vous assurer que vous travaillez avec la bonne représentation numérique.

Skills Graph

Vérifier l'instance de la classe Double

Dans cette étape, nous allons explorer la classe Double en Java et apprendre à vérifier si un objet est une instance de cette classe. En Java, les types de données primitifs comme double ont des classes wrapper correspondantes, telles que Double. La classe Double fournit des méthodes utiles pour travailler avec des nombres à virgule flottante en double précision.

Tout d'abord, créons un nouveau fichier Java nommé DoubleCheck.java dans votre répertoire ~/project. Vous pouvez le faire en utilisant l'explorateur de fichiers de l'IDE Web à gauche. Cliquez avec le bouton droit dans le répertoire ~/project, sélectionnez "Nouveau fichier" et tapez DoubleCheck.java.

Maintenant, ouvrez le fichier DoubleCheck.java dans l'éditeur et ajoutez le code suivant :

public class DoubleCheck {
    public static void main(String[] args) {
        // Declare a primitive double variable
        double primitiveDouble = 123.45;

        // Declare a Double object
        Double doubleObject = 67.89;

        // Declare an Integer object
        Integer integerObject = 100;

        // Check if primitiveDouble is an instance of Double (This will not work directly)
        // System.out.println("Is primitiveDouble an instance of Double? " + (primitiveDouble instanceof Double)); // This line would cause a compile error

        // Check if doubleObject is an instance of Double
        System.out.println("Is doubleObject an instance of Double? " + (doubleObject instanceof Double));

        // Check if integerObject is an instance of Double
        System.out.println("Is integerObject an instance of Double? " + (integerObject instanceof Double));
    }
}

Dans ce code :

• Nous déclarons une variable primitive double nommée primitiveDouble.
• Nous déclarons un objet Double nommé doubleObject.
• Nous déclarons un objet Integer nommé integerObject pour comparaison.
• Nous utilisons l'opérateur instanceof pour vérifier si doubleObject et integerObject sont des instances de la classe Double.
• Notez que l'opérateur instanceof ne peut pas être utilisé directement avec des types primitifs comme double.

Enregistrez le fichier DoubleCheck.java.

Maintenant, compilons et exécutons le programme. Ouvrez le terminal en bas de l'IDE Web. Assurez-vous que vous êtes dans le répertoire ~/project.

Compilez le code en utilisant javac :

javac DoubleCheck.java

S'il n'y a pas d'erreurs de compilation, exécutez le code compilé en utilisant java :

java DoubleCheck

Vous devriez voir une sortie similaire à celle-ci :

Is doubleObject an instance of Double? true
Is integerObject an instance of Double? false

Cette sortie confirme que doubleObject est une instance de la classe Double, tandis que integerObject ne l'est pas. Cela démontre comment utiliser l'opérateur instanceof pour vérifier le type d'un objet en Java.

Convertir une chaîne de caractères en nombre à virgule flottante double

Dans cette étape, nous allons apprendre à convertir une chaîne de caractères (String) représentant un nombre en une valeur de type double en Java. C'est une tâche courante lorsque vous recevez des entrées numériques sous forme de texte, par exemple, à partir d'une saisie utilisateur ou en lisant depuis un fichier. La classe Double fournit une méthode statique appelée parseDouble() spécialement à cette fin.

Créons un nouveau fichier Java nommé StringtoDouble.java dans votre répertoire ~/project. Utilisez l'explorateur de fichiers de l'IDE Web pour créer ce fichier.

Ouvrez le fichier StringtoDouble.java et ajoutez le code suivant :

public class StringtoDouble {
    public static void main(String[] args) {
        // A string representing a double value
        String doubleString = "987.65";

        // Another string representing a double value
        String anotherDoubleString = "3.14159";

        // A string that is not a valid double
        String invalidDoubleString = "hello";

        // Parse the strings to double values
        try {
            double parsedDouble1 = Double.parseDouble(doubleString);
            double parsedDouble2 = Double.parseDouble(anotherDoubleString);

            System.out.println("Parsed double from \"" + doubleString + "\": " + parsedDouble1);
            System.out.println("Parsed double from \"" + anotherDoubleString + "\": " + parsedDouble2);

            // Attempt to parse an invalid string (This will cause an error)
            // double parsedDouble3 = Double.parseDouble(invalidDoubleString);
            // System.out.println("Parsed double from \"" + invalidDoubleString + "\": " + parsedDouble3);

        } catch (NumberFormatException e) {
            System.out.println("Error parsing string: " + e.getMessage());
        }
    }
}

Dans ce code :

• Nous avons deux chaînes de caractères, doubleString et anotherDoubleString, qui contiennent des représentations valides de nombres à virgule flottante double.
• Nous avons également invalidDoubleString qui ne représente pas un nombre valide.
• Nous utilisons Double.parseDouble() pour convertir les chaînes valides en valeurs primitives de type double.
• Nous enveloppons le code de conversion dans un bloc try-catch. Cela est important car si la chaîne de caractères ne peut pas être convertie en un nombre à virgule flottante double valide (comme invalidDoubleString), parseDouble() lancera une NumberFormatException. Le bloc catch gère cette erreur de manière élégante.

Enregistrez le fichier StringtoDouble.java.

Maintenant, compilons et exécutons le programme. Ouvrez le terminal et assurez-vous que vous êtes dans le répertoire ~/project.

Compilez le code :

javac StringtoDouble.java

Exécutez le code compilé :

java StringtoDouble

Vous devriez voir une sortie similaire à celle-ci :

Parsed double from "987.65": 987.65
Parsed double from "3.14159": 3.14159

Si vous décommentez les lignes qui tentent de convertir invalidDoubleString et que vous exécutez le code à nouveau, vous verrez le message d'erreur du bloc catch, ce qui démontre comment le programme gère les entrées invalides.

Cette étape vous montre comment convertir des représentations textuelles de nombres en valeurs réelles de type double, ce qui est une compétence essentielle pour gérer les entrées dans vos programmes Java.

Différencier les nombres à virgule flottante double des entiers

Dans cette étape, nous allons explorer comment différencier les valeurs de type double et int (entier) en Java, notamment lorsqu'il s'agit de nombres qui peuvent sembler similaires. Alors que le type double peut représenter des nombres avec des décimales ainsi que des nombres entiers, le type int ne peut représenter que des nombres entiers. Comprendre cette différence est essentiel pour choisir le bon type de données et effectuer des calculs précis.

Créons un nouveau fichier Java nommé NumberTypes.java dans votre répertoire ~/project en utilisant l'explorateur de fichiers de l'IDE Web.

Ouvrez le fichier NumberTypes.java et ajoutez le code suivant :

public class NumberTypes {
    public static void main(String[] args) {
        // An integer variable
        int integerValue = 10;

        // A double variable representing a whole number
        double doubleValueWhole = 20.0;

        // A double variable representing a number with a decimal part
        double doubleValueDecimal = 30.5;

        // Print the values and their types (implicitly)
        System.out.println("Integer value: " + integerValue);
        System.out.println("Double value (whole): " + doubleValueWhole);
        System.out.println("Double value (decimal): " + doubleValueDecimal);

        // Check the type using instanceof (for wrapper classes)
        Integer integerObject = 100;
        Double doubleObject = 200.0;

        System.out.println("Is integerObject an instance of Integer? " + (integerObject instanceof Integer));
        System.out.println("Is doubleObject an instance of Double? " + (doubleObject instanceof Double));
        System.out.println("Is integerObject an instance of Double? " + (integerObject instanceof Double));
        System.out.println("Is doubleObject an instance of Integer? " + (doubleObject instanceof Integer));

        // Demonstrate potential issues with comparing double and int
        System.out.println("Is integerValue equal to doubleValueWhole? " + (integerValue == doubleValueWhole)); // This comparison works due to type promotion
        // System.out.println("Is integerValue equal to doubleValueDecimal? " + (integerValue == doubleValueDecimal)); // This would be false
    }
}

Dans ce code :

• Nous déclarons une variable de type int nommée integerValue.
• Nous déclarons deux variables de type double, l'une représentant un nombre entier (doubleValueWhole) et l'autre un nombre avec une partie décimale (doubleValueDecimal).
• Nous affichons ces valeurs pour observer leur représentation.
• Nous utilisons l'opérateur instanceof avec les classes wrapper Integer et Double pour vérifier explicitement les types d'objets, de manière similaire à ce que nous avons fait dans la première étape.
• Nous montrons également une comparaison entre un int et un double. Java effectue une promotion de type, convertissant le int en double avant la comparaison, donc integerValue == doubleValueWhole s'évalue à true.

Enregistrez le fichier NumberTypes.java.

Maintenant, compilons et exécutons le programme. Ouvrez le terminal et assurez-vous que vous êtes dans le répertoire ~/project.

Compilez le code :

javac NumberTypes.java

Exécutez le code compilé :

java NumberTypes

Vous devriez voir une sortie similaire à celle-ci :

Integer value: 10
Double value (whole): 20.0
Double value (decimal): 30.5
Is integerObject an instance of Integer? true
Is doubleObject an instance of Double? true
Is integerObject an instance of Double? false
Is doubleObject an instance of Integer? false
Is integerValue equal to doubleValueWhole? true

Cette sortie permet d'illustrer la différence entre la manière dont les valeurs de type int et double sont stockées et représentées, et comment vous pouvez utiliser instanceof avec leurs classes wrapper pour vérifier leurs types. Bien qu'un double puisse contenir une valeur entière, il s'agit fondamentalement d'un type à virgule flottante, distinct d'un type entier.

Résumé

Dans ce laboratoire (lab), nous avons appris à vérifier si un nombre est de type Double en Java. Nous avons commencé par explorer la classe wrapper Double et utilisé l'opérateur instanceof pour déterminer si un objet est une instance de Double. Nous avons observé que instanceof fonctionne avec les objets Double, mais pas directement avec les types primitifs double.