Vérifier si l'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 laboratoire (LabEx) montre trois méthodes courantes pour vérifier si une entrée donnée est un entier valide :

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

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

Skills Graph

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 d'être 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 base de la classe :

import java.util.Scanner;

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

Implémentation de la validation d'entiers 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 lance 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 + " is a valid integer");
    } catch (NumberFormatException e) {
        // Si la conversion échoue, l'entrée n'est pas un entier valide
        System.out.println(input + " is not a valid integer");
    }
}

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éfinissez 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 + " is a valid integer");
        } catch (NumberFormatException e) {
            // Si la conversion échoue, l'entrée n'est pas un entier valide
            System.out.println(input + " is not a valid integer");
        }
    }

    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 is a valid integer
12.34 is not a valid integer
abc is not a valid integer

Implémentation de la validation d'entiers 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 lorsqu'on lit les 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 + " is a valid integer");
    } else {
        System.out.println(input + " is not a valid integer");
    }
    scanner.close();
}

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

public static void main(String[] args) {
    // Anciens cas de test
    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 is a valid integer
-789 is a valid integer
12.34 is not a valid integer

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

Implémentation de la validation d'entiers 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 de 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 + " is a valid integer");
    } else {
        System.out.println(input + " is not a valid integer");
    }
}

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

public static void main(String[] args) {
    // Anciens cas de test
    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 is a valid integer
-123 is a valid integer
12.34 is not a valid integer

Résumé

Dans ce laboratoire (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 la gestion des exceptions
2. La méthode Scanner.hasNextInt(), qui est excellente pour lire les entrées utilisateur
3. La méthode Character.isDigit(), qui offre 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 la conversion simple de chaîne en entier, Scanner.hasNextInt() est excellente pour lire les 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 capables de gérer les entrées utilisateur de manière sûre et efficace.