Java: Boucle infinie en utilisant in.hasNextInt Scanner ()

Question

Je suis en utilisant le code suivant:

while (invalidInput)
{
    // ask the user to specify a number to update the times by
    System.out.print("Specify an integer between 0 and 5: ");

    if (in.hasNextInt())
    {
        // get the update value
        updateValue = in.nextInt();

        // check to see if it was within range
        if (updateValue >= 0 && updateValue <= 5) 
        { 
            invalidInput = false; 
        } 
        else 
        {
            System.out.println("You have not entered a number between 0 and 5. Try again.");
        }
    } else
    {
        System.out.println("You have entered an invalid input. Try again.");
    }
}

Cependant, si j'entre un « w » il me dira: « Vous avez entré une entrée non valide. Essayez à nouveau. » puis il entrera dans une boucle infinie montrant le texte « Spécifiez un nombre entier compris entre 0 et 5:.. Vous avez entré une entrée invalide Réessayez »

Pourquoi est-ce qui se passe? Est-ce pas le programme censé attendre l'utilisateur d'entrer et appuyez sur Entrée à chaque fois qu'il atteint l'instruction:

if (in.hasNextInt())

Answer 1

Dans votre dernier bloc de else, vous devez effacer le « w » ou autre entrée non valide du scanner. Vous pouvez le faire en appelant next() sur le scanner et en ignorant sa valeur de retour de jeter cette entrée invalide, comme suit:

else
{
      System.out.println("You have entered an invalid input. Try again.");
      in.next();
}

Answer 2

Le problème est que vous n'avez pas avancer la Scanner passé l'entrée problématique. De hasNextInt() documentation :

  

Retours true si le prochain jeton dans l'entrée de ce scanner peut être interprété comme une valeur int dans les radix par défaut en utilisant la méthode nextInt(). Le scanner ne fait pas avancer passé toute entrée.

Ceci est vrai de toutes les méthodes de hasNextXXX(): ils reviennent true ou false, sans faire avancer le Scanner

.

Voici un extrait pour illustrer le problème:

    String input = "1 2 3 oops 4 5 6";
    Scanner sc = new Scanner(input);
    while (sc.hasNext()) {
        if (sc.hasNextInt()) {
            int num = sc.nextInt();
            System.out.println("Got " + num);
        } else {
            System.out.println("int, please!");
            //sc.next(); // uncomment to fix!
        }
    }

Vous constaterez que ce programme entrera dans une boucle infinie, demandant int, please! à plusieurs reprises.

Si vous supprimez l'instruction sc.next(), il fera le Scanner passer devant le jeton qui échoue hasNextInt(). Le programme imprimera alors:

Got 1
Got 2
Got 3
int, please!
Got 4
Got 5
Got 6

Le fait qu'une vérification de hasNextXXX() échoué ne saute pas l'entrée est intentionnel: il vous permet d'effectuer des contrôles supplémentaires sur ce jeton si nécessaire. Voici un exemple pour illustrer:

    String input = " 1 true foo 2 false bar 3 ";
    Scanner sc = new Scanner(input);
    while (sc.hasNext()) {
        if (sc.hasNextInt()) {
            System.out.println("(int) " + sc.nextInt());
        } else if (sc.hasNextBoolean()) {
            System.out.println("(boolean) " + sc.nextBoolean());
        } else {
            System.out.println(sc.next());
        }
    }

Si vous exécutez ce programme, il génèrerait les éléments suivants:

(int) 1
(boolean) true
foo
(int) 2
(boolean) false
bar
(int) 3

Answer 3

Cette déclaration de Ben S. à propos de l'appel non-blocage est faux:

  

En outre, hasNextInt () ne bloque pas. Il est le contrôle non bloquant pour voir si un avenir prochain appel pourrait obtenir l'entrée sans bloquer.

... même si je reconnais que la documentation rel="nofollow"> peut facilement être mauvaise lecture pour donner cet avis, et le nom lui-même implique qu'il doit être utilisé à cette fin. La citation pertinente, en mettant l'accent ajouté:

  

Le lendemain () et hasNext () et leurs méthodes d'accompagnement de type primitif (tels que nextInt () et hasNextInt ()) première ignorer toute entrée qui correspond à la configuration de délimiteur, puis tenter de retourner le jeton suivant. Les deux méthodes suivantes hasNext et peut bloquer attend d'autres. Que ce soit une méthode bloque de hasNext n'a aucun lien ou non la méthode suivante associée bloquera.

Il est un point subtil, pour être sûr. Soit dit « Les deux hasNext et les méthodes suivantes », ou « Les deux hasNext () et suivant () » aurait laissé entendre que les méthodes d'accompagnement agiraient différemment. Mais voyant qu'ils se conforment à la même convention de dénomination (et la documentation, bien sûr), il est raisonnable d'attendre qu'ils agissent de la même, et hasNext () dit clairement qu'il peut bloquer.

Note Meta: cela devrait probablement être un commentaire au poste incorrect, mais il semble que comme un nouvel utilisateur, je ne peux pas poster cette réponse (ou modifier le wiki qui semble préférer les changements sytlistic, et non ceux de la substance) .

Answer 4

Des variables indicatrices sont trop d'erreurs à utiliser. Utilisez le contrôle de la boucle explicite avec des commentaires au lieu. En outre, hasNextInt() -t pas bloquer. Il est le contrôle non-bloquant pour voir si un futur next appel pourrait obtenir entrée sans bloquer. Si vous voulez bloquer, utilisez le procédé nextInt() .

// Scanner that will read the integer
final Scanner in = new Scanner(System.in);
int inputInt;
do {  // Loop until we have correct input
    System.out.print("Specify an integer between 0 and 5: ");
    try {
        inputInt = in.nextInt(); // Blocks for user input
        if (inputInt >= 0 && inputInt <= 5)  { 
            break;    // Got valid input, stop looping
        } else {
            System.out.println("You have not entered a number between 0 and 5. Try again.");
            continue; // restart loop, wrong number
         }
    } catch (final InputMismatchException e) {
        System.out.println("You have entered an invalid input. Try again.");
        in.next();    // discard non-int input
        continue;     // restart loop, didn't get an integer input
    }
} while (true);