We Keep Coding

More succinct way to get Scanner input with error checking?

Just want to know if there was any better way of doing this since it's a lot of writing.
boolean isInputValid = false;
do {
System.out.print("Input: ");
final String input = sc.nextLine();
try {
age = Integer.parseInt(input);
} catch (NumberFormatException e) {
System.out.println("Invalid input. Try again");
continue;
}
if (input < 0 || 10 < input) {
System.out.println("Number outside of range.");
} else {
isInputValid = true;
}
} while (!isInputValid);

Well there are some things that can be ommited on a first look, but there is not much to remove.
Reduced integer parsing in a single line and removed input variable.
Change isInputValid to its negation isInputInvalid to remove else , Boolean assignment and negation in the while clause.
Moved if into the try clause to make redundant and remove the continue statement.
boolean isInputInvalid = true;
do {
System.out.print("Input: ");
try {
age = Integer.parseInt( sc.nextLine());
isInputInvalid = input < 0 || 10 < input;
if (isInputInvalid) {
System.out.println("Number outside of range.");
}
} catch (NumberFormatException e) {
System.out.println("Invalid input. Try again");
}
} while (isInputInvalid);

Well by first glance, I can see that you're comparing an incorrect variable type of string with an integer (your input variable), I'm just going to assume that you meant to compare the age. You should also put the if statements within your try/catch to ensure that its handled as intended (there's also no point in having it outside the try/catch if a NFE is thrown, it won't get ran anyways).
boolean isInputValid = true;
do {
System.out.print("Input: ");
final String input = sc.nextLine();
try {
age = Integer.parseInt(input);
if (age < 0 || 10 < age) {
System.out.println("Number outside of range.");
isInputValid = false;
}
} catch (NumberFormatException e) {
System.out.println("Invalid input. Try again");
continue;
}
} while (isInputValid);

Verify that a given string can be converted into a positive integer

I wrote method that checks if a given String input can be parsed as positive integer or not.
Is there a cleaner way to write this so I'm not repeating the code that rejects the value?
try {
int num = Integer.parseInt(value);
if (num <= 0) {
errors.rejectValue(FIELD_FILE, INVALID_MESSAGE_KEY, new Object[]{lineNumber, fieldName}, "Line {0}: {1} must be a positive integer");
}
} catch (NumberFormatException e) {
errors.rejectValue(FIELD_FILE, INVALID_MESSAGE_KEY, new Object[]{lineNumber, fieldName}, "Line {0}: {1} must be a positive integer");
}

I belive this is the cleaner you can get.
Even if it passes on the try if it is not in the range of results that you expect you force it into the catch.
try {
int num = Integer.parseInt(value);
if (num <= 0) {
throw new NumberFormatException();
}
} catch (NumberFormatException e) {
errors.rejectValue(FIELD_FILE, INVALID_MESSAGE_KEY, new Object[]{lineNumber, fieldName}, "Line {0}: {1} must be a positive integer");
}

One simple way:
int num = 0;
try {
num = Integer.parseInt(value);
} catch (NumberFormatException e) {
num = -1;
}
if (num <= 0) {
errors.rejectValue(FIELD_FILE, INVALID_MESSAGE_KEY, new Object[]{lineNumber, fieldName}, "Line {0}: {1} must be a positive integer");
}

In attempting to handle an int that has input that is not a number, I have come across an error [duplicate]

This question already has answers here:
What is a NumberFormatException and how can I fix it?
(9 answers)
Closed 6 years ago.
I'm not sure how to set it up, but my method has a user input a number between a minimum and maximum, although I have no idea how to handle the NumberFormatException with a try-catch block. Are there any suggestions in regards to how this can be fixed?
static int promptForInt(String prompt, int min, int max){
System.out.println(prompt);
String input = in.readLine();
int parsedInt = Integer.parseInt(input);
while(!(parsedInt > min && parsedInt < max)){
System.out.println("Your input is invalid. " + prompt);
input = in.readLine();
parsedInt = Integer.parseInt(input);
}
return parsedInt;
}

static int promptForInt(String prompt, int min, int max){
System.out.println(prompt);
String input = in.readLine();
int parsedInt;
boolean exceptionThrown = false;
do {
try {
parsedInt = Integer.parseInt(input);
} catch(NumberFormatException e) {
exceptionThrown = true;
}
if (exceptionThrown || (!(parsedInt > min && parsedInt < max)) {
System.out.println("Your input is invalid. " + prompt);
input = in.readLine();
parsedInt = Integer.parseInt(input);
} else {
return parsedInt;
}
} while(true)
}
From my post about NumberFormatException:
Ad. 4.
Finally we come to the place in which we agree, that we can't avoid situations when it's user typing "abc" as a numeric string. Why? Because he can. In a lucky case, it's because he's a tester or simply a geek. In a bad case it's the attacker.
What can I do now? Well, Java gives us try-catch you can do the following:
try {
i = Integer.parseInt(myString);
} catch (NumberFormatException e) {
e.printStackTrace();
//somehow workout the issue with an improper input. It's up to your business logic.
}
Exceptions
In Java Exceptions are used for marking unexpected situations. For example parsing non-numeric String to a number (NumberFormatException) or calling a method on a null reference (NullPointerException). You can catch them in many ways.
try{
//some code
} catch (NumberFormatException e1) {
e.printStackTrace() //very important - handles the Exception but prints the information!
} catch (NullPointerException e2) {
e.printStackTrace();
}
or using the fact, that they all extend Exception:
try {
//somecode
} catch (Exception e) {
e.printStackTrace;
};
or since Java 7:
try {
//somecode
} catch (NullPointerException | NumberFormatException e) {
e.printStackTrace;
};

Exceptions can be easier to deal with if you think of them as the method "Trying to do something, but it couldn't because of X". X is the exception.
The below code could be one way you modify your code to handle the exception:
static int promptForInt(String prompt, int min, int max) {
Integer parsedInt = null; // use an Integer so null can be used to mean an invalid value
while (parsedInt == null) {
System.out.println(prompt);
String input = in.readLine();
int temp;
try {
temp = Integer.parseInt(input);
} catch(NumberFormatException e) {
System.out.print(input+" is not a number. ");
continue;
}
if (temp < min || temp > max) {
System.out.print("Your number must be between "+min+" and "+max+" (inclusive). ");
} else {
parsedInt = temp;
}
}
return parsedInt;
}
Some things you should notice: Firstly, you have not defined in. You could do that like so:
BufferedReader in = new BufferedReader(new InputStreamReader(System.in, "UTF-8"));
If you do that, you'll soon see that you have another Exception to deal with: this can throw UnsupportedEncodingException, and also readLine can throw IOException.
Your method must return a valid integer or it will not exit (you really should supply the user some means of exiting the loop without entering a valid number). Since that's not going to be possible if, for instance, you couldn't read anything from System.in your method needs a reasonable way of telling the caller: "I tried to get an int from the user, except I was stopped by X".
You may actually end up doing something more like:
static int promptForInt(String prompt, int min, int max) throws UserInputException {
BufferedReader in;
try {
in = new BufferedReader(new InputStreamReader(System.in, "UTF-8"));
} catch(UnsupportedEncodingException unsupported) {
// create a new exception and supply the cause as an inner exception
throw new UserInputException("Could not open a reader for System.in", unsupported);
}
Integer parsedInt = null; // use an Integer so null can be used to mean an invalid value
while (parsedInt == null) {
System.out.println(prompt);
String input;
try {
input = in.readLine();
} catch (IOException ioException) {
throw new UserInputException("Could not read a line", ioException);
}
if (input.length() == 0) {
throw new UserInputException("User aborted input");
}
int temp;
try {
temp = Integer.parseInt(input);
} catch(NumberFormatException e) {
System.out.print(input+" is not a number. ");
continue;
}
if (temp < min || temp > max) {
System.out.print("Your number must be between "+min+" and "+max+" (inclusive). ");
} else {
parsedInt = temp;
}
}
return parsedInt;
}

Understanding try & catch and error handling

import java.util.Scanner;
public class Lab4_5 {
public static void main(String[]args) {
Scanner scan= new Scanner(System.in);
int rows=0;
int rowIndex=0, colIndex=0;
boolean choice1= true;
String y="y";
String n="n";
boolean first = true;
while (choice1==true) {
if (first==true) {
first=false;
System.out.println("Do you want to start(Y/N): ");
} else if (first==false) {
System.out.println("Do you want to continue(Y/N): ");
}
String choice2=scan.next();
if (choice2.equals(y)) {
System.out.println("How many rows/columns(5-21)?");
rows=scan.nextInt();
while (rows<5 || rows>21) {
System.out.println("That is either out of range or not an integer, try again! ");
rows=scan.nextInt();
}
System.out.println("What character?");
String choice3=scan.next();
System.out.println(" ");
for (rowIndex=1; rowIndex<=rows; rowIndex++) {
for (colIndex=1; colIndex<=rows; colIndex++) {
if (rowIndex==1 || rowIndex==rows || colIndex==1 || colIndex==rows) {
System.out.print(choice3);
} else {
System.out.print(" ");
}
}
System.out.println();
}
} else if(choice2.equals(n)) {
choice1 = false;
System.out.println("Thank you. Goodbye.");
} else {
System.out.println("Please either enter Y or N.");
}
}
}//end of main
}
The code prints what I need it to print, but I also have to have something in the code when it asks how many rows/columns to catch whether or not i input something other than an integer(in the part below). need some help, we haven't done anything yet with how to catch exceptions and i don't know how to start.
String choice2=scan.next();
if (choice2.equals(y)) {
System.out.println("How many rows/columns(5-21)?");
rows=scan.nextInt();
while (rows<5 || rows>21) {
System.out.println("That is either out of range or not an integer, try again! ");
rows=scan.nextInt();
}
}

You need to understand this please look into it.
Basic understanding is
try {
//Something that can throw an exception.
} catch (Exception e) {
// To do whatever when the exception is caught.
}
There is also an finally block which will always be execute even if there is an error. it is used like this
try {
//Something that can throw an exception.
} catch (Exception e) {
// To do whatever when the exception is caught & the returned.
} finally {
// This will always execute if there is an exception or no exception.
}
In your particular case you can have the following exceptions (link).
InputMismatchException - if the next token does not match the Integer regular expression, or is out of range
NoSuchElementException - if input is exhausted
IllegalStateException - if this scanner is closed
So you would need to catch exceptions like
try {
rows=scan.nextInt();
} catch (InputMismatchException e) {
// When the InputMismatchException is caught.
System.out.println("The next token does not match the Integer regular expression, or is out of range");
} catch (NoSuchElementException e) {
// When the NoSuchElementException is caught.
System.out.println("Input is exhausted");
} catch (IllegalStateException e) {
// When the IllegalStateException is caught.
System.out.println("Scanner is close");
}

You can create a try-catch block like so:
try {
int num = scan.nextInt();
} catch (InputMismatchException ex) {
// Exception handling here
}
If you want to implement this in your code, I suggest doing this:
while (true) {
try {
rows = scan.nextInt();
if (rows<5||rows>21) {
break;
}
else {
System.out.println("That is either out of range or not an integer, try again! ");
}
} catch (InputMismatchException ex) {
System.out.println("That is either out of range or not an integer, try again! ");
}
}
See here for more details.

String choice2=scan.next();
if(choice2.equals(y)){
System.out.println("How many rows/columns(5-21)?");
try
{
rows=scan.nextInt();
}catch(Exception e)
{
rows = -1;
}
while(rows<5||rows>21){
System.out.println("That is either out of range or not an integer, try again! ");
try
{
rows=scan.nextInt();
}catch(Exception e)
{
rows = -1;
}
}

Three exceptions for int

I am trying to create a code where an int is supposed to be entered and then have exceptions for if the int is not between 9 and 99, another exception if a double is entered instead of int and then a third exception if a string is entered. How do i do this? i have below what i have so far but am not sure how to correct it. thanks
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
boolean correct = true;
do {
try {
System.out.println("Enter an Integer between 9 and 99");
int number = input.nextInt();
if (number >= 9 && number <= 99) {
System.out.println("Thank you, Initialization completed");
correct = false;
} else if (number < 9 || number > 99) {
throw new Exception("Integer is not within the range");
}
if (input.hasNextDouble()) {
throw new Exception("Integer not entered");
} else {
correct = false;
}
if (input.hasNext("")) {
throw new NumberFormatException("Integer not entered");
} else {
correct = false;
}
} // check for range
catch (Exception e1) {
System.out.println("Number is not within 9 and 99");
System.out.println();
input.nextLine();
} catch (Exception e2) {
System.out.println("An integer was not entered");
System.out.println();
input.nextLine();
} catch (NumberFormatException e3) {
System.out.println("An integer was not entered");
System.out.println();
input.nextLine();
}
} while (correct);
}

Method .getMessage() returns the string given in constructor:
throw new Exception("HERE");
When you catch Exception, you catch also NumberFormatException, InputMismatchException, etc.
so you must catch broader ones last.
catch (NumberFormatException e3) { // Precisier goes first
System.out.println("An integer was not entered");
System.out.println();
input.nextLine();
}
catch (Exception e1) {
System.out.println(e1.getMessage());
System.out.println();
input.nextLine();
}