Re: How would you do this kind of validatioin checking
On 9/12/2011 9:12 PM, Thee Chicago Wolf (MVP) wrote:
Hi all,
So I was wondering what the simplest way to do this kind of validation
checking would be.
Let's say you're prompting the user for one or the other of the
following:
A) foo = keyboard.nextInt();
B) bar = keyboard.nextLine();
If the user decides to be a stinker and, for item A), enter a
character, it'll bomb out because the input type is expecting an Int.
So you'd have a while loop of some sort (i.e., while (foo.equals("a"
|| "b" || "c"......)) but that would be a LOT of chacaters to check
against and seems like bad coding.
What has the user's input got to do with java.util.Random's
nextInt() method?
Oh, wait: Maybe `keyboard' is an instance of some other class
that has a nextInt() method? Like java.util.Scanner, perhaps?
And maybe it's using default settings (more or less) and hasn't
been set up to use some complicated regex as the delimiter? Gosh,
it's hard to tell just what you mean here, since you've left out so
many rather crucial details. (Hint, hint.) Okay, I'm going to
assume, although you've offered no evidence to support my assumption,
that `keyboard' refers to a "vanilla" instance of java.util.Scanner.
If the user enters something that's not an integer, the offending
input remains "pending" in the Scanner and nextInt() throws an
exception. You can catch that exception and react to the problem.
One possibility would be to use the next() method to retrieve the
bogus token and shout at the user "You moron! *&&^%$TI is not an
integer!" and loop back to try again. Since next() consumes the token,
the next nextInt() call will look at whatever comes after the one you
couldn't swallow.
If you want to swallow the offending token with next() and then
check for "XLII" or "zwei und vierzig", that's a bigger project.
If I wanted to do validation checking to counter someone purposely
entering character input where Int is being expected, is there a
blanket statement that will check through a-z / A-Z or would using
something like (!foo.equals() to basically say "if the input is
anything other than Int, keep looping until the user inputs an Int."
One really simple approach would be to put the whole thing in
a method that loops forever until nextInt() succeeds, something like
private static int getNextInt(Scanner scanner) {
for (;;) {
try {
return scanner.nextInt();
} catch (InputMismatchException ex) {
System.out.println("You moron! "
+ scanner.next() + " is not an integer!");
}
}
}
(Extra credit: Do something sensible with NoSuchElementException.)
And in the case of B), "if the input is anything other than
characters, keep looping until the user inputs an character." I'm
guessing something like: while (bar>= 0 || bar<= 0).
Having read the entire line, the obvious thing is to try to
convert it to an integer. You could do a little string-bashing and
then call Integer.parseInt(), or you could use a NumberFormat. Either
will fail if the user enters "forty-two" (and they differ in exactly
how they report failure), but you can detect it, object, and try again
as above.
Note that with getInt()/next() you will consume only one token
at a time, while with getLine()/parseInt() you will consume an entire
line. This makes a difference if the user enters "XLII 97" on a single
line; decide what you want to do and choose accordingly. For
interactive use, it is probably better to deal in complete lines than
in individual tokens; it just helps keeps things synchronized with the
user.
--
Eric Sosman
esosman@ieee-dot-org.invalid