Validating input using java.util.Scanner [duplicate]

Asked 17/6, 2010 at 6:20 Answered 4/4, 2017 at 11:7

I'm taking user input from System.in using a java.util.Scanner. I need to validate the input for things like:

It must be a non-negative number
It must be an alphabetical letter
... etc

What's the best way to do this?

Cassette answered 17/6, 2010 at 6:20 Comment(5)

Many of your questions are in a form like this: badly worded pleas for someone else to post code without you showing what your have done (or tried) yourself. This is not the way to learn new things. Get your hand dirty! Try a couple of things yourself and, when getting stuck somewhere, post a specific question here (and post the code that didn't work). I assure you that by doing so, you will receive better responses than these close-votes. – Territoriality 17/6, 2010 at 6:33

@Bart K: would it be fair to other answerers if, in an effort to improve the question to make it worthy of reopening, I edit it to ask how to validate inputs using Scanner? Based on OP's previous Q, it seems that Scanner is what OP is working with. – Tashinatashkent 17/6, 2010 at 6:55

@polygenelubricants, yes, I'd vote to re-open if the question would be rephrased so that it made more sense. It would be a shame if this question would get deleted in the long run (and all good answer with it (mainly yours)). Of course, I had hoped @bhavna would have tried to improve it him- or herself... – Territoriality 17/6, 2010 at 7:19

@Bart K: edit done. Will also improve my answer even further. Apologies to the other answerers if they feel that this was unfair. – Tashinatashkent 17/6, 2010 at 7:25

It's unbelievable that this question had already collected 2 delete votes. Reopened. – Statuary 21/6, 2010 at 5:20

167

Overview of `Scanner.hasNextXXX` methods

java.util.Scanner has many hasNextXXX methods that can be used to validate input. Here's a brief overview of all of them:

hasNext() - does it have any token at all?
hasNextLine() - does it have another line of input?
For Java primitives
- hasNextInt() - does it have a token that can be parsed into an int?
- Also available are hasNextDouble(), hasNextFloat(), hasNextByte(), hasNextShort(), hasNextLong(), and hasNextBoolean()
- As bonus, there's also hasNextBigInteger() and hasNextBigDecimal()
- The integral types also has overloads to specify radix (for e.g. hexadecimal)
Regular expression-based
- hasNext(String pattern)
- hasNext(Pattern pattern) is the Pattern.compile overload

Scanner is capable of more, enabled by the fact that it's regex-based. One important feature is useDelimiter(String pattern), which lets you define what pattern separates your tokens. There are also find and skip methods that ignores delimiters.

The following discussion will keep the regex as simple as possible, so the focus remains on Scanner.

Example 1: Validating positive ints

Here's a simple example of using hasNextInt() to validate positive int from the input.

Scanner sc = new Scanner(System.in);
int number;
do {
    System.out.println("Please enter a positive number!");
    while (!sc.hasNextInt()) {
        System.out.println("That's not a number!");
        sc.next(); // this is important!
    }
    number = sc.nextInt();
} while (number <= 0);
System.out.println("Thank you! Got " + number);

Here's an example session:

Please enter a positive number!
five
That's not a number!
-3
Please enter a positive number!
5
Thank you! Got 5

Note how much easier Scanner.hasNextInt() is to use compared to the more verbose try/catch Integer.parseInt/NumberFormatException combo. By contract, a Scanner guarantees that if it hasNextInt(), then nextInt() will peacefully give you that int, and will not throw any NumberFormatException/InputMismatchException/NoSuchElementException.

Example 2: Multiple `hasNextXXX` on the same token

Note that the snippet above contains a sc.next() statement to advance the Scanner until it hasNextInt(). It's important to realize that none of the hasNextXXX methods advance the Scanner past any input! You will find that if you omit this line from the snippet, then it'd go into an infinite loop on an invalid input!

This has two consequences:

If you need to skip the "garbage" input that fails your hasNextXXX test, then you need to advance the Scanner one way or another (e.g. next(), nextLine(), skip, etc).
If one hasNextXXX test fails, you can still test if it perhaps hasNextYYY!

Here's an example of performing multiple hasNextXXX tests.

Scanner sc = new Scanner(System.in);
while (!sc.hasNext("exit")) {
    System.out.println(
        sc.hasNextInt() ? "(int) " + sc.nextInt() :
        sc.hasNextLong() ? "(long) " + sc.nextLong() :  
        sc.hasNextDouble() ? "(double) " + sc.nextDouble() :
        sc.hasNextBoolean() ? "(boolean) " + sc.nextBoolean() :
        "(String) " + sc.next()
    );
}

Here's an example session:

5
(int) 5
false
(boolean) false
blah
(String) blah
1.1
(double) 1.1
100000000000
(long) 100000000000
exit

Note that the order of the tests matters. If a Scanner hasNextInt(), then it also hasNextLong(), but it's not necessarily true the other way around. More often than not you'd want to do the more specific test before the more general test.

Example 3 : Validating vowels

Scanner has many advanced features supported by regular expressions. Here's an example of using it to validate vowels.

Scanner sc = new Scanner(System.in);
System.out.println("Please enter a vowel, lowercase!");
while (!sc.hasNext("[aeiou]")) {
    System.out.println("That's not a vowel!");
    sc.next();
}
String vowel = sc.next();
System.out.println("Thank you! Got " + vowel);

Here's an example session:

Please enter a vowel, lowercase!
5
That's not a vowel!
z
That's not a vowel!
e
Thank you! Got e

In regex, as a Java string literal, the pattern "[aeiou]" is what is called a "character class"; it matches any of the letters a, e, i, o, u. Note that it's trivial to make the above test case-insensitive: just provide such regex pattern to the Scanner.

API links

hasNext(String pattern) - Returns true if the next token matches the pattern constructed from the specified string.
java.util.regex.Pattern

References

Example 4: Using two `Scanner` at once

Sometimes you need to scan line-by-line, with multiple tokens on a line. The easiest way to accomplish this is to use two Scanner, where the second Scanner takes the nextLine() from the first Scanner as input. Here's an example:

Scanner sc = new Scanner(System.in);
System.out.println("Give me a bunch of numbers in a line (or 'exit')");
while (!sc.hasNext("exit")) {
    Scanner lineSc = new Scanner(sc.nextLine());
    int sum = 0;
    while (lineSc.hasNextInt()) {
        sum += lineSc.nextInt();
    }
    System.out.println("Sum is " + sum);
}

Here's an example session:

Give me a bunch of numbers in a line (or 'exit')
3 4 5
Sum is 12
10 100 a million dollar
Sum is 110
wait what?
Sum is 0
exit

In addition to Scanner(String) constructor, there's also Scanner(java.io.File) among others.

Summary

Scanner provides a rich set of features, such as hasNextXXX methods for validation.
Proper usage of hasNextXXX/nextXXX in combination means that a Scanner will NEVER throw an InputMismatchException/NoSuchElementException.
Always remember that hasNextXXX does not advance the Scanner past any input.
Don't be shy to create multiple Scanner if necessary. Two simple Scanner is often better than one overly complex Scanner.
Finally, even if you don't have any plans to use the advanced regex features, do keep in mind which methods are regex-based and which aren't. Any Scanner method that takes a String pattern argument is regex-based.
- Tip: an easy way to turn any String into a literal pattern is to Pattern.quote it.

Tashinatashkent answered 17/6, 2010 at 6:27 Comment(6)

this code is working for negative numbers but not for alphabet – Cassette 17/6, 2010 at 6:30

That's probably the best way yo go about it, depending on the input method, of course. – Bolshevik 17/6, 2010 at 6:30

@bhavna: learn from the code and do the rest yourself. – Tashinatashkent 17/6, 2010 at 6:31

@bhavna, please stop expecting others to do all your work. Also, thanking someone from time to time wouldn't hurt either. – Territoriality 17/6, 2010 at 6:38

I love hasNextInt(). Ive been dealing with NumberFormatException cuz i didn't read doc enough. ouch. thanks for the information. very nice example too. – Cismontane 5/2, 2013 at 23:5

what is the importance of sc.next() in the first example that you gave? – Legwork 30/4, 2017 at 14:34

Here's a minimalist way to do it.

System.out.print("Please enter an integer: ");
while(!scan.hasNextInt()) scan.next();
int demoInt = scan.nextInt();

Popham answered 23/5, 2014 at 23:46 Comment(0)

For checking Strings for letters you can use regular expressions for example:

someString.matches("[A-F]");

For checking numbers and stopping the program crashing, I have a quite simple class you can find below where you can define the range of values you want. Here

    public int readInt(String prompt, int min, int max)
    {
    Scanner scan = new Scanner(System.in);

    int number = 0;

    //Run once and loop until the input is within the specified range.
    do 
    {
        //Print users message.
        System.out.printf("\n%s > ", prompt);

        //Prevent string input crashing the program.
        while (!scan.hasNextInt()) 
        {
            System.out.printf("Input doesn't match specifications. Try again.");
            System.out.printf("\n%s > ", prompt);
            scan.next(); 
        }

        //Set the number.
        number = scan.nextInt();

        //If the number is outside range print an error message.
        if (number < min || number > max)
            System.out.printf("Input doesn't match specifications. Try again.");

    } while (number < min || number > max);

    return number;
}

Bangle answered 2/12, 2012 at 13:48 Comment(0)

One idea:

try {
    int i = Integer.parseInt(myString);
    if (i < 0) {
        // Error, negative input
    }
} catch (NumberFormatException e) {
    // Error, not a number.
}

There is also, in commons-lang library the CharUtils class that provides the methods isAsciiNumeric() to check that a character is a number, and isAsciiAlpha() to check that the character is a letter...

Channa answered 17/6, 2010 at 6:30 Comment(0)

If you are parsing string data from the console or similar, the best way is to use regular expressions. Read more on that here: http://java.sun.com/developer/technicalArticles/releases/1.4regex/

Otherwise, to parse an int from a string, try Integer.parseInt(string). If the string is not a number, you will get an exception. Otherise you can then perform your checks on that value to make sure it is not negative.

String input;
int number;
try
{
    number = Integer.parseInt(input);
    if(number > 0)
    {
        System.out.println("You positive number is " + number);
    }
} catch (NumberFormatException ex)
{
     System.out.println("That is not a positive number!");
}

To get a character-only string, you would probably be better of looping over each character checking for digits, using for instance Character.isLetter(char).

String input
for(int i = 0; i<input.length(); i++)
{
   if(!Character.isLetter(input.charAt(i)))
   {
      System.out.println("This string does not contain only letters!");
      break;
   }
}

Good luck!

Bolshevik answered 17/6, 2010 at 6:28 Comment(0)

what i have tried is that first i took the integer input and checked that whether its is negative or not if its negative then again take the input

Scanner s=new Scanner(System.in);

    int a=s.nextInt();
    while(a<0)
    {
    System.out.println("please provide non negative integer input ");
    a=s.nextInt();
    }
    System.out.println("the non negative integer input is "+a);

Here, you need to take the character input first and check whether user gave character or not if not than again take the character input

    char ch = s.findInLine(".").charAt(0);
    while(!Charcter.isLetter(ch))
    {
    System.out.println("please provide a character input ");
    ch=s.findInLine(".").charAt(0);
    }
    System.out.println("the character  input is "+ch);

Defloration answered 4/4, 2017 at 11:7 Comment(2)

do more than posting some code. Explain WHY that code is the answer to the question. Especially 7 years after the initial question. – Bonitabonito 4/4, 2017 at 11:48

i just want to add my observation ..if any people will come here he will see for solutions...he will not see the timings...just like that i came here...you need to understand my code ...that what i have tried is that first i took the integer input and checked that whether its is negative or not if its negative than again take the input thats it and the second part is you need to take the character input first and check whether user gave character or not if not than again take the character input – Defloration 4/4, 2017 at 14:13

Hot tags

Godot Unity Godot Help Programming Godot 4.X GUI GDScript 3D 2D Physics CSharp Godot 3.X VR XR Projects C++

Overview of `Scanner.hasNextXXX` methods

Example 1: Validating positive ints

Related questions

Example 2: Multiple `hasNextXXX` on the same token

Example 3 : Validating vowels

API links

Related questions

References

Example 4: Using two `Scanner` at once

Summary

Recommended topics

Hot tags

Overview of Scanner.hasNextXXX methods

Example 1: Validating positive ints

Related questions

Example 2: Multiple hasNextXXX on the same token

Example 3 : Validating vowels

API links

Related questions

References

Example 4: Using two Scanner at once

Summary

Recommended topics

Hot tags

Overview of `Scanner.hasNextXXX` methods

Example 2: Multiple `hasNextXXX` on the same token

Example 4: Using two `Scanner` at once