Para utilizar a classe console, acrescente-a ao seu projeto e utilize chamadas para leitura da entrada padrão conforme exemplo abaixo:
String valor= Console.readString();
A classe
devera ser obrigatoriamente incluída em seu projeto.
Classe
console:
import java.io.*;
import java.util.*;
/** Esta classe foi implementada no livro <b> Java Software Solutions: Foundations of Program Design </B>
de LEWIS, John e LOFTUS, W (2 ed., Adisson-Wesley, 2000).
O objetivo dessa classe é facilitar a entrada/saída de valores via Console, sem a necessidade
de um conhecimento mais aprofundado da classes da API padrão do Java que definem essa funcionalidade.
@version 1.0
@author:
*/
public class Console{
//-----------------------------------------------------------------
// Prints the appropriate error message
//-----------------------------------------------------------------
/** Imprime mensagem de erro */
private static void error (String str){
System.out.println (str);
}
//******************************************************************
// Tokenized Input Stream Section
//******************************************************************
private static String current_token = null;
private static StringTokenizer reader;
/** Esta variável in será utilizada para fazer os Inputs*/
private static BufferedReader in = new BufferedReader
(new InputStreamReader(System.in));
//-----------------------------------------------------------------
// Gets the next input token assuming it may be on subsequent
// input lines.
//-----------------------------------------------------------------
/** Captura o próximo pedaço (token) assumindo que este deverá
estar nas linhas subsequentes de entrada */
private static String getNextToken() {
return getNextToken (true);
}
//-----------------------------------------------------------------
// Gets the next input token, which may already have been read.
//-----------------------------------------------------------------
/** Captura o próximo pedaço (token) que já foi lido */
private static String getNextToken (boolean skip) {
String token;
if (current_token == null)
token = getNextInputToken (skip);
else
{
token = current_token;
current_token = null;
}
return token;
}
//-----------------------------------------------------------------
// Gets the next token from the input, which may come from the
// current input line or a subsequent one. The parameter
// determines if subsequent lines are used.
//-----------------------------------------------------------------
/** Captura o próximo pedaço (token) de entrada, que deve vir da
entrada na linha corrente ou subsequente. O Parâmetro determina
se as linhas subsequentes serão utilizadas. */
private static String getNextInputToken (boolean skip){
final String delimiters = " \t\n\r\f";
String token = null;
try
{
if (reader == null)
reader = new StringTokenizer(in.readLine(), delimiters, true);
while (token == null ||
((delimiters.indexOf (token) >= 0) && skip))
{
while (!reader.hasMoreTokens())
reader = new StringTokenizer(in.readLine(), delimiters,true);
token = reader.nextToken();
}
}
catch (Exception exception)
{
token = null;
}
return token;
}
//-----------------------------------------------------------------
// Returns true if there are no more tokens to read on the
// current input line.
//-----------------------------------------------------------------
/** Retorna true se não existem mais pedaços (token) para
serem lidos na linha corrente de entrada. */
private static boolean endOfLine() {
return !reader.hasMoreTokens();
}
//*****************************************************************
// Reading Section
//*****************************************************************
//-----------------------------------------------------------------
// Returns a boolean read from standard input.
//-----------------------------------------------------------------
/** Lê um valor do tipo primitivo boolean
@return retorna o valor booleano lido a partir da console
*/
public static boolean readBoolean() {
String token = getNextToken();
boolean bool;
try{
if (token.equalsIgnoreCase("true"))
bool = true;
else if (token.equalsIgnoreCase("false"))
bool = false;
else {
error ("Error reading boolean data, please try again.");
bool = readBoolean();
}
} catch (Exception exception){
error ("Error reading boolean data, please try again.");
bool = readBoolean();
}
return bool;
}
//-----------------------------------------------------------------
// Returns a character read from standard input.
//-----------------------------------------------------------------
/**Lê um valor do tipo primitivo char
@return retorna o valor caracter lido a partir da console
*/
public static char readChar(){
String token = getNextToken(false);
char value;
try {
if (token.length() > 1)
current_token = token.substring (1, token.length());
else
current_token = null;
value = token.charAt (0);
} catch (Exception exception) {
error ("Error reading char data, please try again.");
value = readChar();
}
return value;
}
//-----------------------------------------------------------------
// Returns a byte read from standard input.
//-----------------------------------------------------------------
/**Lê um valor do tipo primitivo byte
@return retorna o valor byte lido a partir da console
*/
public static byte readByte()
{
String token = getNextToken();
byte value;
try {
value = Byte.parseByte(token);
} catch (Exception exception) {
error ("Error reading byte data, please try again.");
value = readByte();
}
return value;
}
//-----------------------------------------------------------------
// Returns a short read from standard input.
//-----------------------------------------------------------------
/**Lê um valor do tipo primitivo short
@return retorna o valor short lido a partir da console
*/
public static short readShort(){
String token = getNextToken();
short value;
try {
value = Short.parseShort(token);
} catch (Exception exception) {
error ("Error reading short data, please try again.");
value = readShort();
}
return value;
}
//-----------------------------------------------------------------
// Returns an integer read from standard input.
//-----------------------------------------------------------------
/**Lê um valor do tipo primitivo int
@return retorna o valor inteiro lido a partir da console
*/
public static int readInt(){
String token = getNextToken();
int value;
try
{
value = Integer.parseInt(token);
}
catch (Exception exception)
{
error ("Error reading int data, please try again.");
value = readInt();
}
return value;
}
//-----------------------------------------------------------------
// Returns a long integer read from standard input.
//-----------------------------------------------------------------
/**Lê um valor do tipo primitivo long
@return retorna o valor long lido a partir da console
*/
public static long readLong(){
String token = getNextToken();
long value;
try {
value = Long.parseLong(token);
} catch (Exception exception) {
error ("Error reading long data, please try again.");
value = readLong();
}
return value;
}
//-----------------------------------------------------------------
// Returns a float read from standard input.
//-----------------------------------------------------------------
/**Lê um valor do tipo primitivo float
@return retorna o valor float lido a partir da console
*/
public static float readFloat()
{
String token = getNextToken();
float value;
try {
value = (new Float(token)).floatValue();
} catch (Exception exception) {
error ("Error reading float data, please try again.");
value = readFloat();
}
return value;
}
//-----------------------------------------------------------------
// Returns a double read from standard input.
//-----------------------------------------------------------------
/**Lê um valor do tipo primitivo double
@return retorna o valor double lido a partir da console
*/
public static double readDouble() {
String token = getNextToken();
double value;
try {
value = (new Double(token)).doubleValue();
} catch (Exception exception) {
error ("Error reading double data, please try again.");
value = readDouble();
}
return value;
}
//-----------------------------------------------------------------
// Returns a string read from standard input.
//-----------------------------------------------------------------
/**Lê um valor do tipo String
@return retorna o valor da String lido a partir da console
*/
public static String readString() {
String str;
try {
str = getNextToken(false);
while (! endOfLine()){
str = str + getNextToken(false);
}
}catch (Exception exception) {
error ("Error reading String data, please try again.");
str = readString();
}
return str;
}
}