import java.io.*;
import java.util.*;
/****************************************************************
*Class for simple console input.
*A class designed primarily for simple keyboard input of the form
*one input value per line. If the user enters an improper input,
*i.e., an input of the wrong type or a blank line, then the user
*is prompted to reenter the input and given a brief explanation
*of what is required. Also includes some additional methods to
*input single numbers, words, and characters, without going to
*the next line.
***************************************************************/
public class SavitchIn
{
/***********************************************************
*Reads a line of text and returns that line as a String value.
*The end of a line must be indicated either by a new line
*character '\n' or by a carriage return '\r' followed by a
*new line character '\n'. (Almost all systems do this
*automatically. So, you need not worry about this detail.)
*Neither the '\n', nor the '\r' if present, are part of the
*string returned. This will read the rest of a line if the
*line is already partially read.
**********************************************************/
public static String readLine()
{
char nextChar;
String result = "";
boolean done = false;
while (!done)
{
nextChar = readChar();
if (nextChar == '\n')
done = true;
else if (nextChar == '\r')
{
//Do nothing.
//Next loop iteration will detect '\n'
}
else
result = result + nextChar;
}
return result;
}
/************************************************************
*Reads the first string of nonwhite characters on a line and
*returns that string. The rest of the line is discarded. If
*the line contains only white space, then the user is asked
*to reenter the line.
************************************************************/
public static String readLineWord()
{
String inputString = null,
result = null;
boolean done = false;
while(!done)
{
inputString = readLine();
StringTokenizer wordSource =
new StringTokenizer(inputString);
if (wordSource.hasMoreTokens())
{
result = wordSource.nextToken();
done = true;
}
else
{
System.out.println(
"Your input is not correct. Your input must");
System.out.println(
"contain at least one nonwhitespace character.");
System.out.println(
"Please, try again. Enter input:");
}
}
return result;
}
/************************************************************
*Precondition: The user has entered a number of type int on
*a line by itself, except that there may be white space before
*and/or after the number.
*Action: Reads and returns the number as a value of type int.
*The rest of the line is discarded. If the input is not
*entered correctly, then in most cases, the user will be
*asked to reenter the input. In particular, this applies to
*incorrect number formats and blank lines.
************************************************************/
public static int readLineInt()
{
String inputString = null;
int number = -9999;//To keep the compiler happy.
//Designed to look like a garbage value.
boolean done = false;
while (! done)
{
try
{
inputString = readLine();
inputString = inputString.trim();
number = (Integer.valueOf(inputString).intValue());
done = true;
}
catch (NumberFormatException e)
{
System.out.println(
"Your input number is not correct.");
System.out.println("Your input number must be");
System.out.println("a whole number written as an");
System.out.println("ordinary numeral, such as 42");
System.out.println("Please, try again.");
System.out.println("Enter a whole number:");
}
}
return number;
}
/************************************************************
*Precondition: The user has entered a number of type long on
*a line by itself, except that there may be white space
*before and/or after the number.
*Action: Reads and returns the number as a value of type
*long. The rest of the line is discarded. If the input is not
*entered correctly, then in most cases, the user will be asked
*to reenter the input. In particular, this applies to
*incorrect number formats and blank lines.
***********************************************************/
public static long readLineLong()
{
String inputString = null;
long number = -9999;//To keep the compiler happy.
//Designed to look like a garbage value.
boolean done = false;
while (! done)
{
try
{
inputString = readLine();
inputString = inputString.trim();
number = (Long.valueOf(inputString).longValue());
done = true;
}
catch (NumberFormatException e)
{
System.out.println(
"Your input number is not correct.");
System.out.println("Your input number must be");
System.out.println("a whole number written as an");
System.out.println("ordinary numeral, such as 42");
System.out.println("Please, try again.");
System.out.println("Enter a whole number:");
}
}
return number;
}
/**********************************************************
*Precondition: The user has entered a number of type double
*on a line by itself, except that there may be white space
*before and/or after the number.
*Action: Reads and returns the number as a value of type
*double. The rest of the line is discarded. If the input is
*not entered correctly, then in most cases, the user will be
*asked to reenter the input. In particular, this applies to
*incorrect number formats and blank lines.
***********************************************************/
public static double readLineDouble()
{
String inputString = null;
double number = -9999;//To keep the compiler happy.
//Designed to look like a garbage value.
boolean done = false;
while (! done)
{
try
{
inputString = readLine();
inputString = inputString.trim();
number = (Double.valueOf(inputString).doubleValue());
done = true;
}
catch (NumberFormatException e)
{
System.out.println(
"Your input number is not correct.");
System.out.println("Your input number must be");
System.out.println("an ordinary number either with");
System.out.println("or without a decimal point,");
System.out.println("such as 42 or 9.99");
System.out.println("Please, try again.");
System.out.println("Enter a whole number:");
}
}
return number;
}
/************************************************************
*Precondition: The user has entered a number of type float
*on a line by itself, except that there may be white space
*before and/or after the number.
*Action: Reads and returns the number as a value of type
*float. The rest of the line is discarded. If the input is
*not entered correctly, then in most cases, the user will
*be asked to reenter the input. In particular,
*this applies to incorrect number formats and blank lines.
************************************************************/
public static float readLineFloat()
{
String inputString = null;
float number = -9999;//To keep the compiler happy.
//Designed to look like a garbage value.
boolean done = false;
while (! done)
{
try
{
inputString = readLine();
inputString = inputString.trim();
number = (Float.valueOf(inputString).floatValue());
done = true;
}
catch (NumberFormatException e)
{
System.out.println(
"Your input number is not correct.");
System.out.println("Your input number must be");
System.out.println("an ordinary number either with");
System.out.println("or without a decimal point,");
System.out.println("such as 42 or 9.99");
System.out.println("Please, try again.");
System.out.println("Enter a whole number:");
}
}
return number;
}
/************************************************************
*Reads the first Nonwhite character on a line and returns
*that character. The rest of the line is discarded. If the
*line contains only white space, then the user is asked to
*reenter the line.
************************************************************/
public static char readLineNonwhiteChar()
{
boolean done = false;
String inputString = null;
char nonWhite = ' ';//To keep the compiler happy.
while (! done)
{
inputString = readLine();
inputString = inputString.trim();
if (inputString.length() == 0)
{
System.out.println(
"Your input is not correct.");
System.out.println("Your input must contain at");
System.out.println(
"least one nonwhitespace character.");
System.out.println("Please, try again.");
System.out.println("Enter input:");
}
else
{
nonWhite = (inputString.charAt(0));
done = true;
}
}
return nonWhite;
}
/***********************************************************
*Input should consists of a single word on a line, possibly
*surrounded by white space. The line is read and discarded.
*If the input word is "true" or "t", then true is returned.
*If the input word is "false" or "f", then false is returned.
*Uppercase and lowercase letters are considered equal. If the
*user enters anything else (e.g. multiple words or different
*words), then, the user is asked to reenter the input.
***********************************************************/
public static boolean readLineBoolean()
{
boolean done = false;
String inputString = null;
boolean result = false;//To keep the compiler happy.
while (! done)
{
inputString = readLine();
inputString = inputString.trim();
if (inputString.equalsIgnoreCase("true")
|| inputString.equalsIgnoreCase("t"))
{
result = true;
done = true;
}
else if (inputString.equalsIgnoreCase("false")
|| inputString.equalsIgnoreCase("f"))
{
result = false;
done = true;
}
else
{
System.out.println(
"Your input number is not correct.");
System.out.println("Your input number must be");
System.out.println("one of the following:");
System.out.println("the word true,");
System.out.println("the word false,");
System.out.println("the letter T,");
System.out.println("or the letter F.");
System.out.println("You may use either uppercase");
System.out.println("or lowercase letters.");
System.out.println("Please, try again.");
System.out.println("Enter input:");
}
}
return result;
}
/************************************************************
*Reads the next input character and returns that character. The
*next read takes place on the same line where this one left off.
***********************************************************/
public static char readChar()
{
int charAsInt = -1; //To keep the compiler happy
try
{
charAsInt = System.in.read();
}
catch(IOException e)
{
System.out.println(e.getMessage());
System.out.println("Fatal error. Ending Program.");
System.exit(0);
}
return (char)charAsInt;
}
/***********************************************************
*Reads the next nonwhite input character and returns that
*character. The next read takes place immediately after
*the character read.
**********************************************************/
public static char readNonwhiteChar()
{
char next;
next = readChar();
while (isWhitespace(next))
next = readChar();
return next;
}
/***********************************************************
*The following methods are not used in the text, except for
*a brief reference in Chapter 2. No program code uses them.
*However, some programmers may want to use them.
**********************************************************/
/************************************************************
*Precondition: The next input in the stream consists of an
*int value, possibly preceded by white space, but definitely
*followed by white space.
*Action: Reads the first string of nonwhite characters
*and returns the int value it represents. Discards the first
*whitespace character after the word. The next read takes
*place immediately after the discarded whitespace.
*In particular, if the word is at the end of a line, the
*next reading will take place starting on the next line.
*If the next word does not represent an int value,
*a NumberFormatException is thrown.
***********************************************************/
public static int readInt() throws NumberFormatException
{
String inputString = null;
inputString = readWord();
return (Integer.valueOf(inputString).intValue());
}
/************************************************************
*Precondition: The next input consists of a long value,
*possibly preceded by white space, but definitely
*followed by white space.
*Action: Reads the first string of nonwhite characters and
*returns the long value it represents. Discards the first
*whitespace character after the string read. The next read
*takes place immediately after the discarded whitespace.
*In particular, if the string read is at the end of a line,
*the next reading will take place starting on the next line.
*If the next word does not represent a long value,
*a NumberFormatException is thrown.
************************************************************/
public static long readLong()
throws NumberFormatException
{
String inputString = null;
inputString = readWord();
return (Long.valueOf(inputString).longValue());
}
/***********************************************************
*Precondition: The next input consists of a double value,
*possibly preceded by white space, but definitely
*followed by white space.
*Action: Reads the first string of nonwhitespace characters
*and returns the double value it represents. Discards the
*first whitespace character after the string read. The next
*read takes place immediately after the discarded whitespace.
*In particular, if the string read is at the end of a line,
*the next reading will take place starting on the next line.
*If the next word does not represent a double value,
*a NumberFormatException is thrown.
************************************************************/
public static double readDouble()
throws NumberFormatException
{
String inputString = null;
inputString = readWord();
return (Double.valueOf(inputString).doubleValue());
}
/***********************************************************
*Precondition: The next input consists of a float value,
*possibly preceded by white space, but definitely
*followed by white space.
*Action: Reads the first string of nonwhite characters and
*returns the float value it represents. Discards the first
*whitespace character after the string read. The next read
*takes place immediately after the discarded whitespace.
*In particular, if the string read is at the end of a line,
*the next reading will take place starting on the next line.
*If the next word does not represent a float value,
*a NumberFormatException is thrown.
************************************************************/
public static float readFloat()
throws NumberFormatException
{
String inputString = null;
inputString = readWord();
return (Float.valueOf(inputString).floatValue());
}
/***********************************************************
*Reads the first string of nonwhite characters and returns
*that string. Discards the first whitespace character after
*the string read. The next read takes place immediately after
*the discarded whitespace. In particular, if the string
*read is at the end of a line, the next reading will take
*place starting on the next line. Note, that if it receives
*blank lines, it will wait until it gets a nonwhitespace
*character.
************************************************************/
public static String readWord()
{
String result = "";
char next;
next = readChar();
while (isWhitespace(next))
next = readChar();
while (!(isWhitespace(next)))
{
result = result + next;
next = readChar();
}
if (next == '\r')
{
next = readChar();
if (next != '\n')
{
System.out.println("Fatal Error in method readWord of class SavitchIn.");
System.exit(1);
}
}
return result;
}
//The following was intentionally not used in the code for
//other methods so that somebody reading the code could more
//quickly see what was being used.
/************************************************************
*Reads the first byte in the input stream and returns that
* byte as an int. The next read takes place where this one
*left off. This read is the same as System.in.read(),
*except that it catches IOExceptions.
************************************************************/
public static int read()
{
int result = -1; //To keep the compiler happy
try
{
result = System.in.read();
}
catch(IOException e)
{
System.out.println(e.getMessage());
System.out.println("Fatal error. Ending Program.");
System.exit(0);
}
return result;
}
//The following was designed for use with J++. This method replaces
//Character.isWhitespace which J++ appears to not have.
private static boolean isWhitespace(char c)
{
return (c == ' ' || c == '\n' || c == '\t' || c == '\r');
}
}
import java.util.*;
/****************************************************************
*Class for simple console input.
*A class designed primarily for simple keyboard input of the form
*one input value per line. If the user enters an improper input,
*i.e., an input of the wrong type or a blank line, then the user
*is prompted to reenter the input and given a brief explanation
*of what is required. Also includes some additional methods to
*input single numbers, words, and characters, without going to
*the next line.
***************************************************************/
public class SavitchIn
{
/***********************************************************
*Reads a line of text and returns that line as a String value.
*The end of a line must be indicated either by a new line
*character '\n' or by a carriage return '\r' followed by a
*new line character '\n'. (Almost all systems do this
*automatically. So, you need not worry about this detail.)
*Neither the '\n', nor the '\r' if present, are part of the
*string returned. This will read the rest of a line if the
*line is already partially read.
**********************************************************/
public static String readLine()
{
char nextChar;
String result = "";
boolean done = false;
while (!done)
{
nextChar = readChar();
if (nextChar == '\n')
done = true;
else if (nextChar == '\r')
{
//Do nothing.
//Next loop iteration will detect '\n'
}
else
result = result + nextChar;
}
return result;
}
/************************************************************
*Reads the first string of nonwhite characters on a line and
*returns that string. The rest of the line is discarded. If
*the line contains only white space, then the user is asked
*to reenter the line.
************************************************************/
public static String readLineWord()
{
String inputString = null,
result = null;
boolean done = false;
while(!done)
{
inputString = readLine();
StringTokenizer wordSource =
new StringTokenizer(inputString);
if (wordSource.hasMoreTokens())
{
result = wordSource.nextToken();
done = true;
}
else
{
System.out.println(
"Your input is not correct. Your input must");
System.out.println(
"contain at least one nonwhitespace character.");
System.out.println(
"Please, try again. Enter input:");
}
}
return result;
}
/************************************************************
*Precondition: The user has entered a number of type int on
*a line by itself, except that there may be white space before
*and/or after the number.
*Action: Reads and returns the number as a value of type int.
*The rest of the line is discarded. If the input is not
*entered correctly, then in most cases, the user will be
*asked to reenter the input. In particular, this applies to
*incorrect number formats and blank lines.
************************************************************/
public static int readLineInt()
{
String inputString = null;
int number = -9999;//To keep the compiler happy.
//Designed to look like a garbage value.
boolean done = false;
while (! done)
{
try
{
inputString = readLine();
inputString = inputString.trim();
number = (Integer.valueOf(inputString).intValue());
done = true;
}
catch (NumberFormatException e)
{
System.out.println(
"Your input number is not correct.");
System.out.println("Your input number must be");
System.out.println("a whole number written as an");
System.out.println("ordinary numeral, such as 42");
System.out.println("Please, try again.");
System.out.println("Enter a whole number:");
}
}
return number;
}
/************************************************************
*Precondition: The user has entered a number of type long on
*a line by itself, except that there may be white space
*before and/or after the number.
*Action: Reads and returns the number as a value of type
*long. The rest of the line is discarded. If the input is not
*entered correctly, then in most cases, the user will be asked
*to reenter the input. In particular, this applies to
*incorrect number formats and blank lines.
***********************************************************/
public static long readLineLong()
{
String inputString = null;
long number = -9999;//To keep the compiler happy.
//Designed to look like a garbage value.
boolean done = false;
while (! done)
{
try
{
inputString = readLine();
inputString = inputString.trim();
number = (Long.valueOf(inputString).longValue());
done = true;
}
catch (NumberFormatException e)
{
System.out.println(
"Your input number is not correct.");
System.out.println("Your input number must be");
System.out.println("a whole number written as an");
System.out.println("ordinary numeral, such as 42");
System.out.println("Please, try again.");
System.out.println("Enter a whole number:");
}
}
return number;
}
/**********************************************************
*Precondition: The user has entered a number of type double
*on a line by itself, except that there may be white space
*before and/or after the number.
*Action: Reads and returns the number as a value of type
*double. The rest of the line is discarded. If the input is
*not entered correctly, then in most cases, the user will be
*asked to reenter the input. In particular, this applies to
*incorrect number formats and blank lines.
***********************************************************/
public static double readLineDouble()
{
String inputString = null;
double number = -9999;//To keep the compiler happy.
//Designed to look like a garbage value.
boolean done = false;
while (! done)
{
try
{
inputString = readLine();
inputString = inputString.trim();
number = (Double.valueOf(inputString).doubleValue());
done = true;
}
catch (NumberFormatException e)
{
System.out.println(
"Your input number is not correct.");
System.out.println("Your input number must be");
System.out.println("an ordinary number either with");
System.out.println("or without a decimal point,");
System.out.println("such as 42 or 9.99");
System.out.println("Please, try again.");
System.out.println("Enter a whole number:");
}
}
return number;
}
/************************************************************
*Precondition: The user has entered a number of type float
*on a line by itself, except that there may be white space
*before and/or after the number.
*Action: Reads and returns the number as a value of type
*float. The rest of the line is discarded. If the input is
*not entered correctly, then in most cases, the user will
*be asked to reenter the input. In particular,
*this applies to incorrect number formats and blank lines.
************************************************************/
public static float readLineFloat()
{
String inputString = null;
float number = -9999;//To keep the compiler happy.
//Designed to look like a garbage value.
boolean done = false;
while (! done)
{
try
{
inputString = readLine();
inputString = inputString.trim();
number = (Float.valueOf(inputString).floatValue());
done = true;
}
catch (NumberFormatException e)
{
System.out.println(
"Your input number is not correct.");
System.out.println("Your input number must be");
System.out.println("an ordinary number either with");
System.out.println("or without a decimal point,");
System.out.println("such as 42 or 9.99");
System.out.println("Please, try again.");
System.out.println("Enter a whole number:");
}
}
return number;
}
/************************************************************
*Reads the first Nonwhite character on a line and returns
*that character. The rest of the line is discarded. If the
*line contains only white space, then the user is asked to
*reenter the line.
************************************************************/
public static char readLineNonwhiteChar()
{
boolean done = false;
String inputString = null;
char nonWhite = ' ';//To keep the compiler happy.
while (! done)
{
inputString = readLine();
inputString = inputString.trim();
if (inputString.length() == 0)
{
System.out.println(
"Your input is not correct.");
System.out.println("Your input must contain at");
System.out.println(
"least one nonwhitespace character.");
System.out.println("Please, try again.");
System.out.println("Enter input:");
}
else
{
nonWhite = (inputString.charAt(0));
done = true;
}
}
return nonWhite;
}
/***********************************************************
*Input should consists of a single word on a line, possibly
*surrounded by white space. The line is read and discarded.
*If the input word is "true" or "t", then true is returned.
*If the input word is "false" or "f", then false is returned.
*Uppercase and lowercase letters are considered equal. If the
*user enters anything else (e.g. multiple words or different
*words), then, the user is asked to reenter the input.
***********************************************************/
public static boolean readLineBoolean()
{
boolean done = false;
String inputString = null;
boolean result = false;//To keep the compiler happy.
while (! done)
{
inputString = readLine();
inputString = inputString.trim();
if (inputString.equalsIgnoreCase("true")
|| inputString.equalsIgnoreCase("t"))
{
result = true;
done = true;
}
else if (inputString.equalsIgnoreCase("false")
|| inputString.equalsIgnoreCase("f"))
{
result = false;
done = true;
}
else
{
System.out.println(
"Your input number is not correct.");
System.out.println("Your input number must be");
System.out.println("one of the following:");
System.out.println("the word true,");
System.out.println("the word false,");
System.out.println("the letter T,");
System.out.println("or the letter F.");
System.out.println("You may use either uppercase");
System.out.println("or lowercase letters.");
System.out.println("Please, try again.");
System.out.println("Enter input:");
}
}
return result;
}
/************************************************************
*Reads the next input character and returns that character. The
*next read takes place on the same line where this one left off.
***********************************************************/
public static char readChar()
{
int charAsInt = -1; //To keep the compiler happy
try
{
charAsInt = System.in.read();
}
catch(IOException e)
{
System.out.println(e.getMessage());
System.out.println("Fatal error. Ending Program.");
System.exit(0);
}
return (char)charAsInt;
}
/***********************************************************
*Reads the next nonwhite input character and returns that
*character. The next read takes place immediately after
*the character read.
**********************************************************/
public static char readNonwhiteChar()
{
char next;
next = readChar();
while (isWhitespace(next))
next = readChar();
return next;
}
/***********************************************************
*The following methods are not used in the text, except for
*a brief reference in Chapter 2. No program code uses them.
*However, some programmers may want to use them.
**********************************************************/
/************************************************************
*Precondition: The next input in the stream consists of an
*int value, possibly preceded by white space, but definitely
*followed by white space.
*Action: Reads the first string of nonwhite characters
*and returns the int value it represents. Discards the first
*whitespace character after the word. The next read takes
*place immediately after the discarded whitespace.
*In particular, if the word is at the end of a line, the
*next reading will take place starting on the next line.
*If the next word does not represent an int value,
*a NumberFormatException is thrown.
***********************************************************/
public static int readInt() throws NumberFormatException
{
String inputString = null;
inputString = readWord();
return (Integer.valueOf(inputString).intValue());
}
/************************************************************
*Precondition: The next input consists of a long value,
*possibly preceded by white space, but definitely
*followed by white space.
*Action: Reads the first string of nonwhite characters and
*returns the long value it represents. Discards the first
*whitespace character after the string read. The next read
*takes place immediately after the discarded whitespace.
*In particular, if the string read is at the end of a line,
*the next reading will take place starting on the next line.
*If the next word does not represent a long value,
*a NumberFormatException is thrown.
************************************************************/
public static long readLong()
throws NumberFormatException
{
String inputString = null;
inputString = readWord();
return (Long.valueOf(inputString).longValue());
}
/***********************************************************
*Precondition: The next input consists of a double value,
*possibly preceded by white space, but definitely
*followed by white space.
*Action: Reads the first string of nonwhitespace characters
*and returns the double value it represents. Discards the
*first whitespace character after the string read. The next
*read takes place immediately after the discarded whitespace.
*In particular, if the string read is at the end of a line,
*the next reading will take place starting on the next line.
*If the next word does not represent a double value,
*a NumberFormatException is thrown.
************************************************************/
public static double readDouble()
throws NumberFormatException
{
String inputString = null;
inputString = readWord();
return (Double.valueOf(inputString).doubleValue());
}
/***********************************************************
*Precondition: The next input consists of a float value,
*possibly preceded by white space, but definitely
*followed by white space.
*Action: Reads the first string of nonwhite characters and
*returns the float value it represents. Discards the first
*whitespace character after the string read. The next read
*takes place immediately after the discarded whitespace.
*In particular, if the string read is at the end of a line,
*the next reading will take place starting on the next line.
*If the next word does not represent a float value,
*a NumberFormatException is thrown.
************************************************************/
public static float readFloat()
throws NumberFormatException
{
String inputString = null;
inputString = readWord();
return (Float.valueOf(inputString).floatValue());
}
/***********************************************************
*Reads the first string of nonwhite characters and returns
*that string. Discards the first whitespace character after
*the string read. The next read takes place immediately after
*the discarded whitespace. In particular, if the string
*read is at the end of a line, the next reading will take
*place starting on the next line. Note, that if it receives
*blank lines, it will wait until it gets a nonwhitespace
*character.
************************************************************/
public static String readWord()
{
String result = "";
char next;
next = readChar();
while (isWhitespace(next))
next = readChar();
while (!(isWhitespace(next)))
{
result = result + next;
next = readChar();
}
if (next == '\r')
{
next = readChar();
if (next != '\n')
{
System.out.println("Fatal Error in method readWord of class SavitchIn.");
System.exit(1);
}
}
return result;
}
//The following was intentionally not used in the code for
//other methods so that somebody reading the code could more
//quickly see what was being used.
/************************************************************
*Reads the first byte in the input stream and returns that
* byte as an int. The next read takes place where this one
*left off. This read is the same as System.in.read(),
*except that it catches IOExceptions.
************************************************************/
public static int read()
{
int result = -1; //To keep the compiler happy
try
{
result = System.in.read();
}
catch(IOException e)
{
System.out.println(e.getMessage());
System.out.println("Fatal error. Ending Program.");
System.exit(0);
}
return result;
}
//The following was designed for use with J++. This method replaces
//Character.isWhitespace which J++ appears to not have.
private static boolean isWhitespace(char c)
{
return (c == ' ' || c == '\n' || c == '\t' || c == '\r');
}
}
No comments:
Post a Comment