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

JavaJavaBeginner
Pratiquer maintenant

💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici

Introduction

Dans ce laboratoire, vous apprendrez à déterminer si un nombre est un entier en Java. Nous explorerons différentes techniques, en commençant par la méthode Math.floor() pour vérifier les valeurs entières. Vous pratiquerez avec les types de données double et float pour comprendre le comportement de cette méthode avec différentes représentations de nombres à virgule flottante. Enfin, nous verrons comment gérer les entrées sous forme de chaînes de caractères et les convertir en types numériques avant d'effectuer la vérification d'entier. Ce laboratoire vous fournira des compétences pratiques pour valider les données numériques dans vos programmes Java.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL java(("Java")) -.-> java/ObjectOrientedandAdvancedConceptsGroup(["Object-Oriented and Advanced Concepts"]) java(("Java")) -.-> java/SystemandDataProcessingGroup(["System and Data Processing"]) java(("Java")) -.-> java/BasicSyntaxGroup(["Basic Syntax"]) java/BasicSyntaxGroup -.-> java/data_types("Data Types") java/BasicSyntaxGroup -.-> java/operators("Operators") java/BasicSyntaxGroup -.-> java/math("Math") java/ObjectOrientedandAdvancedConceptsGroup -.-> java/user_input("User Input") java/SystemandDataProcessingGroup -.-> java/math_methods("Math Methods") subgraph Lab Skills java/data_types -.-> lab-559960{{"Comment vérifier si un nombre est un entier en Java"}} java/operators -.-> lab-559960{{"Comment vérifier si un nombre est un entier en Java"}} java/math -.-> lab-559960{{"Comment vérifier si un nombre est un entier en Java"}} java/user_input -.-> lab-559960{{"Comment vérifier si un nombre est un entier en Java"}} java/math_methods -.-> lab-559960{{"Comment vérifier si un nombre est un entier en Java"}} end

Utiliser Math.floor() pour vérifier si un nombre est un entier

Dans cette étape, nous explorerons comment déterminer si un nombre est un entier en Java en utilisant la méthode Math.floor(). C'est une tâche courante en programmation, notamment lorsqu'il s'agit de gérer les entrées utilisateur ou les calculs.

Tout d'abord, comprenons ce que fait Math.floor(). La méthode Math.floor() en Java renvoie le plus grand entier inférieur ou égal à l'argument. Par exemple, Math.floor(5.9) renverrait 5.0, et Math.floor(5.0) renverrait 5.0.

Nous pouvons utiliser cette propriété pour vérifier si un nombre est un entier. Si un nombre est un entier, l'application de Math.floor() à ce nombre donnera le même nombre. Si le nombre a une partie fractionnaire, Math.floor() renverra un entier plus petit.

Créons un nouveau fichier Java pour pratiquer cela. Ouvrez le WebIDE et créez un nouveau fichier nommé IntegerCheck.java dans le répertoire ~/project.

Maintenant, copiez et collez le code suivant dans le fichier IntegerCheck.java :

public class IntegerCheck {

    public static void main(String[] args) {
        double number1 = 10.0;
        double number2 = 10.5;

        // Check if number1 is an integer
        if (number1 == Math.floor(number1)) {
            System.out.println(number1 + " is an integer.");
        } else {
            System.out.println(number1 + " is not an integer.");
        }

        // Check if number2 is an integer
        if (number2 == Math.floor(number2)) {
            System.out.println(number2 + " is an integer.");
        } else {
            System.out.println(number2 + " is not an integer.");
        }
    }
}

Décortiquons le code :

  • double number1 = 10.0; et double number2 = 10.5; : Nous déclarons deux variables de type double, l'une représentant une valeur entière et l'autre une valeur non entière.
  • if (number1 == Math.floor(number1)) : C'est la logique principale. Nous comparons le nombre original (number1) avec le résultat de Math.floor(number1). Si ils sont égaux, le nombre est un entier.
  • System.out.println(...) : Ces lignes affichent le résultat dans la console.

Enregistrez le fichier IntegerCheck.java.

Maintenant, compilons et exécutons le programme. Ouvrez le terminal dans le WebIDE et assurez-vous d'être dans le répertoire ~/project.

Compilez le code en utilisant javac :

javac IntegerCheck.java

Si la compilation réussit, vous devriez voir un nouveau fichier nommé IntegerCheck.class dans le répertoire ~/project.

Maintenant, exécutez le code compilé en utilisant java :

java IntegerCheck

Vous devriez voir la sortie suivante :

10.0 is an integer.
10.5 is not an integer.

Cette sortie confirme que notre logique utilisant Math.floor() identifie correctement si une valeur de type double représente un entier.

Tester avec les types Double et Float

Dans l'étape précédente, nous avons utilisé Math.floor() avec des valeurs de type double. Java dispose de différents types de données pour représenter les nombres, notamment double et float. Les deux sont utilisés pour les nombres à virgule flottante (nombres avec des décimales), mais double offre une plus grande précision que float.

Modifions notre programme IntegerCheck.java pour tester avec les types double et float afin de voir comment Math.floor() fonctionne avec chacun d'eux.

Ouvrez le fichier IntegerCheck.java dans l'éditeur du WebIDE.

Remplacez le code existant par le suivant :

public class IntegerCheck {

    public static void main(String[] args) {
        double doubleNumber1 = 20.0;
        double doubleNumber2 = 20.75;

        float floatNumber1 = 30.0f; // Note the 'f' suffix for float literals
        float floatNumber2 = 30.25f;

        // Check if doubleNumber1 is an integer
        if (doubleNumber1 == Math.floor(doubleNumber1)) {
            System.out.println(doubleNumber1 + " (double) is an integer.");
        } else {
            System.out.println(doubleNumber1 + " (double) is not an integer.");
        }

        // Check if doubleNumber2 is an integer
        if (doubleNumber2 == Math.floor(doubleNumber2)) {
            System.out.println(doubleNumber2 + " (double) is an integer.");
        } else {
            System.out.println(doubleNumber2 + " (double) is not an integer.");
        }

        // Check if floatNumber1 is an integer
        // Math.floor() takes a double, so the float is promoted to double
        if (floatNumber1 == Math.floor(floatNumber1)) {
            System.out.println(floatNumber1 + " (float) is an integer.");
        } else {
            System.out.println(floatNumber1 + " (float) is not an integer.");
        }

        // Check if floatNumber2 is an integer
        if (floatNumber2 == Math.floor(floatNumber2)) {
            System.out.println(floatNumber2 + " (float) is an integer.");
        } else {
            System.out.println(floatNumber2 + " (float) is not an integer.");
        }
    }
}

Remarquez le suffixe f après les valeurs littérales de type float (30.0f, 30.25f). En Java, cela est nécessaire pour indiquer que le nombre est de type float plutôt que double (qui est le type par défaut pour les littéraux de nombres à virgule flottante).

Notez également que Math.floor() est définie pour prendre un argument de type double. Lorsque vous passez un float à Math.floor(), Java convertit automatiquement le float en double avant l'exécution de la méthode. La comparaison floatNumber1 == Math.floor(floatNumber1) fonctionne toujours car le résultat de Math.floor() (un double) est comparé avec floatNumber1 (qui est également converti en double pour la comparaison).

Enregistrez le fichier IntegerCheck.java.

Maintenant, compilez et exécutez le programme modifié depuis le terminal dans le répertoire ~/project :

javac IntegerCheck.java
java IntegerCheck

Vous devriez voir une sortie similaire à celle-ci :

20.0 (double) is an integer.
20.75 (double) is not an integer.
30.0 (float) is an integer.
30.25 (float) is not an integer.

Cela démontre que notre méthode de comparaison utilisant Math.floor() fonctionne correctement pour les types double et float.

Gérer la conversion d'entrées de type chaîne de caractères

Dans les applications du monde réel, vous avez souvent besoin de récupérer des entrées de l'utilisateur, et ces entrées sont généralement lues sous forme de String. Pour effectuer des vérifications numériques telles que déterminer si l'entrée représente un entier, vous devez d'abord convertir la String en un type numérique, comme double.

Dans cette étape, nous allons modifier notre programme pour prendre l'entrée de l'utilisateur sous forme de String, la convertir en double, puis utiliser Math.floor() pour vérifier si l'entrée originale représentait un entier.

Ouvrez le fichier IntegerCheck.java dans l'éditeur du WebIDE.

Remplacez le code existant par le suivant :

import java.util.Scanner; // Import the Scanner class

public class IntegerCheck {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in); // Create a Scanner object

        System.out.print("Enter a number: "); // Prompt the user for input
        String input = scanner.nextLine(); // Read user input as a String

        try {
            // Convert the String input to a double
            double number = Double.parseDouble(input);

            // Check if the number is an integer using Math.floor()
            if (number == Math.floor(number)) {
                System.out.println("The input '" + input + "' represents an integer.");
            } else {
                System.out.println("The input '" + input + "' does not represent an integer.");
            }

        } catch (NumberFormatException e) {
            // Handle cases where the input is not a valid number
            System.out.println("Invalid input: '" + input + "' is not a valid number.");
        } finally {
            scanner.close(); // Close the scanner
        }
    }
}

Examinons les nouvelles parties du code :

  • import java.util.Scanner; : Cette ligne importe la classe Scanner, qui est utilisée pour lire les entrées depuis la console.
  • Scanner scanner = new Scanner(System.in); : Cela crée un objet Scanner qui lit les entrées depuis le flux d'entrée standard (System.in), qui est généralement le clavier.
  • System.out.print("Enter a number: "); : Cette ligne invite l'utilisateur à entrer un nombre.
  • String input = scanner.nextLine(); : Cela lit la ligne entière d'entrée saisie par l'utilisateur sous forme de String et la stocke dans la variable input.
  • try { ... } catch (NumberFormatException e) { ... } : Il s'agit d'un bloc try-catch. Il est utilisé pour gérer les erreurs potentielles. Dans ce cas, nous essayons de convertir l'entrée String en double. Si l'entrée n'est pas un nombre valide (par exemple, "hello"), une NumberFormatException se produira, et le code à l'intérieur du bloc catch sera exécuté.
  • double number = Double.parseDouble(input); : C'est la partie cruciale de la conversion. Double.parseDouble() est une méthode statique de la classe Double qui tente de convertir une String en une valeur double.
  • finally { scanner.close(); } : Le bloc finally garantit que la méthode scanner.close() est appelée, libérant les ressources système utilisées par le Scanner, que l'exception se soit produite ou non.

Enregistrez le fichier IntegerCheck.java.

Maintenant, compilez et exécutez le programme depuis le terminal dans le répertoire ~/project :

javac IntegerCheck.java
java IntegerCheck

Le programme attendra maintenant que vous entriez une saisie.

Essayez d'entrer un entier, comme 42, puis appuyez sur Entrée. La sortie devrait être :

Enter a number: 42
The input '42' represents an integer.

Exécutez le programme à nouveau et entrez un nombre non entier, comme 3.14, puis appuyez sur Entrée. La sortie devrait être :

Enter a number: 3.14
The input '3.14' does not represent an integer.

Exécutez le programme une dernière fois et entrez quelque chose qui n'est pas un nombre, comme test, puis appuyez sur Entrée. La sortie devrait être :

Enter a number: test
Invalid input: 'test' is not a valid number.

Cela démontre comment gérer l'entrée de l'utilisateur sous forme de String, la convertir en un type numérique, puis appliquer notre vérification Math.floor() tout en gérant les erreurs potentielles dues à des entrées invalides.

Résumé

Dans ce laboratoire (lab), nous avons appris à vérifier si un nombre est un entier en Java en utilisant la méthode Math.floor(). Nous avons exploré le concept selon lequel, pour un entier, Math.floor() renvoie la même valeur, tandis que pour un nombre non entier, il renvoie un entier plus petit. Nous avons implémenté cette logique dans un programme Java, en comparant le nombre original avec le résultat de Math.floor() pour déterminer s'il s'agit d'un entier.