Vérifier si une entrée est un entier

Introduction

Lors du développement d'applications Java, la validation des entrées utilisateur est une tâche cruciale. Ce lab démontre trois méthodes courantes pour vérifier si une entrée donnée est un entier valide :

1. En utilisant la méthode Integer.parseInt()
2. En utilisant la méthode Scanner.hasNextInt()
3. En utilisant la méthode Character.isDigit()

Nous allons implémenter chaque méthode étape par étape et comprendre leurs différences et leurs cas d'utilisation.

Configuration du projet Java

Créons un nouveau fichier Java pour implémenter nos méthodes de validation d'entiers.

1. Ouvrez votre terminal et assurez-vous que vous êtes dans le répertoire /home/labex/project :

pwd

2. Créez un nouveau fichier Java nommé CheckInputInteger.java :

touch CheckInputInteger.java

3. Ouvrez le fichier dans votre éditeur de texte préféré et ajoutez la structure de classe de base :

import java.util.Scanner;

public class CheckInputInteger {
    public static void main(String[] args) {
        // Nous ajouterons nos appels de méthodes ici
    }
}

Implémentation de la validation d'entier avec Integer.parseInt()

La méthode Integer.parseInt() tente de convertir une chaîne de caractères en un entier. Si la conversion échoue, elle lève une NumberFormatException. Nous pouvons utiliser ce comportement pour valider les entiers.

1. Ajoutez la méthode suivante à votre fichier CheckInputInteger.java :

// Ajoutez cette méthode à l'intérieur de la classe CheckInputInteger
public static void checkUsingParseInt(String input) {
    try {
        // Tente de convertir la chaîne d'entrée en un entier
        Integer.parseInt(input);
        System.out.println(input + " est un entier valide");
    } catch (NumberFormatException e) {
        // Si la conversion échoue, l'entrée n'est pas un entier valide
        System.out.println(input + " n'est pas un entier valide");
    }
}

2. Mettez à jour la méthode main pour tester cette implémentation :

// Modifiez la méthode main pour tester cette implémentation
public static void main(String[] args) {
    // Cas de test
    checkUsingParseInt("123");    // Entier valide
    checkUsingParseInt("12.34");  // Pas un entier
    checkUsingParseInt("abc");    // Pas un entier
}

3. Le fichier devrait ressembler à ceci :

import java.util.Scanner;

public class CheckInputInteger {
    // Définir la méthode à l'intérieur de la classe
    public static void checkUsingParseInt(String input) {
        try {
            // Tente de convertir la chaîne d'entrée en un entier
            Integer.parseInt(input);
            System.out.println(input + " est un entier valide");
        } catch (NumberFormatException e) {
            // Si la conversion échoue, l'entrée n'est pas un entier valide
            System.out.println(input + " n'est pas un entier valide");
        }
    }

    public static void main(String[] args) {
        // Cas de test
        checkUsingParseInt("123");    // Entier valide
        checkUsingParseInt("12.34");  // Pas un entier
        checkUsingParseInt("abc");    // Pas un entier
    }
}

4. Compilez et exécutez votre programme :

javac CheckInputInteger.java
java CheckInputInteger

Vous devriez voir la sortie suivante :

123 est un entier valide
12.34 n'est pas un entier valide
abc n'est pas un entier valide

Implémentation de la validation d'entier avec Scanner.hasNextInt()

La classe Scanner fournit la méthode hasNextInt() pour vérifier si le prochain jeton (token) dans l'entrée peut être interprété comme un entier. Cette méthode est particulièrement utile lors de la lecture des entrées utilisateur depuis la console.

1. Ajoutez la méthode suivante à votre fichier CheckInputInteger.java, à l'intérieur de la classe CheckInputInteger :

public static void checkUsingScanner(String input) {
    Scanner scanner = new Scanner(input);
    if (scanner.hasNextInt()) {
        System.out.println(input + " est un entier valide");
    } else {
        System.out.println(input + " n'est pas un entier valide");
    }
    scanner.close();
}

2. Mettez à jour la méthode main pour inclure des tests pour cette implémentation :

public static void main(String[] args) {
    // Cas de test précédents
    checkUsingParseInt("123");
    checkUsingParseInt("12.34");
    checkUsingParseInt("abc");

    // Nouveaux cas de test
    checkUsingScanner("456");     // Entier valide
    checkUsingScanner("-789");    // Entier valide
    checkUsingScanner("12.34");   // Pas un entier
}

3. Compilez et exécutez votre programme :

javac CheckInputInteger.java
java CheckInputInteger

Vous devriez voir la sortie suivante :

456 est un entier valide
-789 est un entier valide
12.34 n'est pas un entier valide

Ceci démontre que la méthode Scanner.hasNextInt() identifie correctement les entiers valides et invalides.

Implémentation de la validation d'entier avec Character.isDigit()

La méthode Character.isDigit() vérifie si un caractère est un chiffre numérique. Nous pouvons l'utiliser pour valider les entiers en vérifiant chaque caractère dans la chaîne d'entrée.

1. Ajoutez la méthode suivante à votre fichier CheckInputInteger.java :

public static void checkUsingIsDigit(String input) {
    boolean isValid = true;

    // Gérer les nombres négatifs en vérifiant le premier caractère
    int startIndex = (input.charAt(0) == '-') ? 1 : 0;

    // Vérifier chaque caractère
    for (int i = startIndex; i < input.length(); i++) {
        if (!Character.isDigit(input.charAt(i))) {
            isValid = false;
            break;
        }
    }

    if (isValid) {
        System.out.println(input + " est un entier valide");
    } else {
        System.out.println(input + " n'est pas un entier valide");
    }
}

2. Mettez à jour la méthode main avec les derniers cas de test :

public static void main(String[] args) {
    // Cas de test précédents
    checkUsingParseInt("123");
    checkUsingParseInt("12.34");
    checkUsingParseInt("abc");

    checkUsingScanner("456");
    checkUsingScanner("-789");
    checkUsingScanner("12.34");

    // Nouveaux cas de test
    checkUsingIsDigit("789");     // Entier valide
    checkUsingIsDigit("-123");    // Entier valide
    checkUsingIsDigit("12.34");   // Pas un entier
}

3. Compilez et exécutez la version finale de votre programme :

javac CheckInputInteger.java
java CheckInputInteger

Vous devriez voir la sortie suivante :

789 est un entier valide
-123 est un entier valide
12.34 n'est pas un entier valide

Résumé

Dans ce lab, nous avons exploré trois méthodes différentes pour valider les entrées d'entiers en Java :

1. La méthode Integer.parseInt(), qui est simple mais nécessite une gestion des exceptions (exception handling)
2. La méthode Scanner.hasNextInt(), qui est excellente pour la lecture des entrées utilisateur
3. La méthode Character.isDigit(), qui fournit une validation caractère par caractère

Chaque méthode a ses avantages et ses cas d'utilisation. La méthode parseInt() est bonne pour une conversion simple de chaîne de caractères en entier, Scanner.hasNextInt() est excellente pour la lecture des entrées utilisateur, et Character.isDigit() offre le plus de contrôle sur le processus de validation.

Ces techniques de validation sont essentielles pour développer des applications Java robustes qui peuvent gérer les entrées utilisateur de manière sûre et efficace.