650 lines
18 KiB
Java
650 lines
18 KiB
Java
|
package iutsud ;
|
|||
|
|
|
|||
|
|
import java.io.BufferedReader ;
|
|||
|
|
import java.io.InputStreamReader ;
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Cette classe fournit des m<EFBFBD>thodes simples pour lire les types
|
|||
|
|
* de base sur l'entr<EFBFBD>e standard (au clavier).<p>
|
|||
|
|
* La lecture est faite par des instructions du type :
|
|||
|
|
* <pre><code> int i = Console.<b>readInt()</b> ;
|
|||
|
|
* double d = Console.<b>readDouble()</b> ;
|
|||
|
|
* char c = Console.<b>readChar()</b> ;
|
|||
|
|
* ...</code> </pre>
|
|||
|
|
*
|
|||
|
|
* <li>Le principe g<EFBFBD>n<EFBFBD>ral est de lire ligne par ligne et de ne traiter
|
|||
|
|
* qu'une seule donn<EFBFBD>e par ligne.
|
|||
|
|
* <li>En cas d'erreur le programme est arr<EFBFBD>t<EFBFBD> en levant une exception ;
|
|||
|
|
* il affiche alors un message d'erreur ainsi que le contenu de la pile d'ex<EFBFBD>cution.
|
|||
|
|
* <li>L'introduction d'une ligne vide provoque une erreur sauf pour <code>readChar()</code>
|
|||
|
|
* qui renvoie le caract<EFBFBD>re de fin de ligne <code>'\n'</code>, et sauf pour <code>readLine()</code>
|
|||
|
|
* qui renvoie la cha<EFBFBD>ne vide.
|
|||
|
|
* <li>La rencontre de la fin de fichier (Ctrl-D au clavier) est g<EFBFBD>n<EFBFBD>ralement
|
|||
|
|
* consid<EFBFBD>r<EFBFBD>e comme une erreur sauf pour <code>readLine()</code> qui renvoie <code>null</code>.
|
|||
|
|
* <p>
|
|||
|
|
* Le point de d<EFBFBD>part a <EFBFBD>t<EFBFBD> la classe <code>sdsu.io.Console</code> de l'universit<EFBFBD>
|
|||
|
|
* de San Diego (<a href="http://www.eli.sdsu.edu/java-SDSU">http://www.eli.sdsu.edu/java-SDSU</a>).
|
|||
|
|
* Cette classe a <EFBFBD>t<EFBFBD> simplifi<EFBFBD>e pour r<EFBFBD>pondre <EFBFBD> nos besoins particuliers pour
|
|||
|
|
* l'enseignement de l'introduction <EFBFBD> l'algorithmique.
|
|||
|
|
* Le code a <EFBFBD>t<EFBFBD> enti<EFBFBD>rement remani<EFBFBD> pour utiliser les fonctions de
|
|||
|
|
* conversion du langage Java.
|
|||
|
|
* Des am<EFBFBD>liorations pourraient certainement y <EFBFBD>tre apport<EFBFBD>es en utilisant
|
|||
|
|
* la classe <code>Number</code> notamment pour les probl<EFBFBD>mes d'internationalisation,
|
|||
|
|
* li<EFBFBD>s <EFBFBD> l'<EFBFBD>criture des nombres en <b>virgule</b> flottante.
|
|||
|
|
* <p>
|
|||
|
|
*
|
|||
|
|
* <b>Utilisation</b> : <p>
|
|||
|
|
* <li>Le fichier <code>Console.class</code> se trouve sous le r<EFBFBD>pertoire
|
|||
|
|
* <code>/usr/local/lib/java/iutsud</code>.
|
|||
|
|
* <li>La variable <code>CLASSPATH</code> doit contenir
|
|||
|
|
* <code>/usr/local/lib/java</code>. Sur <i>sterne</i> elle est initialis<EFBFBD>e
|
|||
|
|
* automatiquement au d<EFBFBD>marrage de la session avec cette valeur.
|
|||
|
|
* <li>Les classes utilisatrices doivent importer la classe
|
|||
|
|
* <code>Console</code> depuis le package <code>iutsud</code> par l'instruction
|
|||
|
|
* <code>import iutsud.Console</code>
|
|||
|
|
*
|
|||
|
|
*
|
|||
|
|
* <p>Le document de pr<EFBFBD>sentation peut <EFBFBD>tre g<EFBFBD>n<EFBFBD>r<EFBFBD> depuis le source par la commande : <br>
|
|||
|
|
* <code> javadoc -version -author iutsud</code>
|
|||
|
|
* @author Raymond Schneider
|
|||
|
|
* (<a href=mailto:Raymond.Schneider@iutsud.u-strasbg.fr>Raymond.Schneider@iutsud.u-strasbg.fr</a>)
|
|||
|
|
* @version version 0.1 17/07/98
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
public class Console {
|
|||
|
|
|
|||
|
|
private static BufferedReader cin = new BufferedReader(
|
|||
|
|
new InputStreamReader(
|
|||
|
|
System.in )) ;
|
|||
|
|
|
|||
|
|
|
|||
|
|
private static void main(String args[]) {
|
|||
|
|
|
|||
|
|
while (true) {
|
|||
|
|
|
|||
|
|
System.out.print( "Print a Base ");
|
|||
|
|
int base = Console.readInt() ;
|
|||
|
|
System.out.print( "Print a Long in base " + base + " : ") ;
|
|||
|
|
long lb = Console.readLong(base) ;
|
|||
|
|
System.out.println( "You typed: " + lb );
|
|||
|
|
|
|||
|
|
System.out.print( "Print a Byte ");
|
|||
|
|
byte k = Console.readByte() ;
|
|||
|
|
System.out.println( "You typed: " + k );
|
|||
|
|
|
|||
|
|
System.out.print( "Print a Short ");
|
|||
|
|
int j = Console.readShort() ;
|
|||
|
|
System.out.println( "You typed: " + j );
|
|||
|
|
|
|||
|
|
System.out.print( "Print a Int ");
|
|||
|
|
int i = Console.readInt() ;
|
|||
|
|
System.out.println( "You typed: " + i );
|
|||
|
|
|
|||
|
|
System.out.print( "Print a Long ");
|
|||
|
|
long l = Console.readLong() ;
|
|||
|
|
System.out.println( "You typed: " + l );
|
|||
|
|
|
|||
|
|
System.out.print( "Print a Float ");
|
|||
|
|
float f = Console.readFloat() ;
|
|||
|
|
System.out.println( "You typed: " + f );
|
|||
|
|
|
|||
|
|
System.out.print( "Print a Double ");
|
|||
|
|
double d = Console.readDouble() ;
|
|||
|
|
System.out.println( "You typed: " + d );
|
|||
|
|
|
|||
|
|
System.out.print( "Print a Boolean ");
|
|||
|
|
boolean b = Console.readBoolean() ;
|
|||
|
|
System.out.println( "You typed: " + b );
|
|||
|
|
|
|||
|
|
System.out.print( "Print a Char ");
|
|||
|
|
char c = Console.readChar() ;
|
|||
|
|
System.out.println( "You typed: " + c );
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private Console()
|
|||
|
|
{
|
|||
|
|
super() ;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Exception lev<EFBFBD>e lors d'une erreur de lecture
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
public static class ReadException extends RuntimeException
|
|||
|
|
{
|
|||
|
|
public ReadException(String message)
|
|||
|
|
{
|
|||
|
|
super(message) ;
|
|||
|
|
}
|
|||
|
|
} // end class ReadException
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Exception lev<EFBFBD>e lors d'une erreur de conversion
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
public static class ConvertionException extends RuntimeException
|
|||
|
|
{
|
|||
|
|
public ConvertionException(String message)
|
|||
|
|
{
|
|||
|
|
super(message) ;
|
|||
|
|
}
|
|||
|
|
} // end class ConvertionException
|
|||
|
|
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Quitte le programme en levant l'exception e
|
|||
|
|
* Le syst<EFBFBD>me affichera<EFBFBD> le message d'erreur associ<EFBFBD>
|
|||
|
|
* ainsi que la pile d'ecx<EFBFBD>cution
|
|||
|
|
* @param e l'exception <EFBFBD> lever
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Exits programs after throwing an exception
|
|||
|
|
* @param e exception to be thrown
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
static final void exitProgram( RuntimeException e )
|
|||
|
|
{
|
|||
|
|
throw e ;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Quitte le programme suite <EFBFBD> une erreur de conversion ;
|
|||
|
|
* affiche un message d'erreur en levant l'exception
|
|||
|
|
* <code>Console.ConvertionException</code>
|
|||
|
|
* @param s la cha<EFBFBD>ne <EFBFBD> convertir
|
|||
|
|
* @param t le type vers lequel il fallait convertir
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Exits programs after displaying a conversion error message
|
|||
|
|
* and after dumping the Thread's stack
|
|||
|
|
* @param s String that could not be converted
|
|||
|
|
* @param t Conversion Destination Type
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
private static final void conversionError( String s , String t )
|
|||
|
|
{
|
|||
|
|
exitProgram( new ConvertionException(
|
|||
|
|
conversionErrorMessage( s , t ) ) ) ;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Quitte le programme suite <EFBFBD> une erreur de lecture ;
|
|||
|
|
* affiche un message d'erreur en levant l'exception
|
|||
|
|
* <code>Console.ReadException</code>
|
|||
|
|
* @param s la raison de l'erreur <EFBFBD> afficher
|
|||
|
|
* @param t le type lu
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Exits programs after displaying a conversion error message
|
|||
|
|
* and after dumping the Thread's stack
|
|||
|
|
* @param s the error cause
|
|||
|
|
* @param t Read Destination Type
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
private static final void readError( String s , String t )
|
|||
|
|
{
|
|||
|
|
exitProgram( new ReadException ( s + " lors de la lecture d'un " + t) );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Compose le message d'erreur <EFBFBD> afficher suite <EFBFBD> une erreur de conversion ;
|
|||
|
|
* @param s la cha<EFBFBD>ne <EFBFBD> convertir
|
|||
|
|
* @param t le type vers lequel il fallait convertir
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Bulids a conversion error message
|
|||
|
|
* @param s String that could not be converted
|
|||
|
|
* @param t Conversion Destination Type
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
private static String conversionErrorMessage( String s, String t )
|
|||
|
|
{
|
|||
|
|
return '"' + s + '"' + " ne peut <20>tre convertie en " + t ;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Input methods ----------------------------------------------------
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Lit une valeur bool<EFBFBD>enne dans une ligne.
|
|||
|
|
* Lit une ligne et d<EFBFBD>termine si elle repr<EFBFBD>sente <code>true</code> ou <code>false</code>.
|
|||
|
|
* Les valeurs possibles sont : <i>true</i> and <i>false</i>,
|
|||
|
|
* <i>vrai</i> and <i>faux</i>.
|
|||
|
|
* La comparaison est insensible <EFBFBD> la casse (majuscule, minuscule).
|
|||
|
|
*
|
|||
|
|
* Le programme stoppe en cas d'erreur de lecture ou en fin de fichier
|
|||
|
|
* @return la valeur bool<EFBFBD>ene correspondante.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Reads an ASCII boolean value.
|
|||
|
|
* It reads a word and determines if it represents <code>true</code> or
|
|||
|
|
* <code>false</code>. Possible values are: <i>true</i> and <i>false</i>,
|
|||
|
|
* <i>vrai</i> and <i>faux</i>.
|
|||
|
|
* The comparison is case insensitive.
|
|||
|
|
* Program exits on read errors or EOF
|
|||
|
|
* @return the boolean.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
public static boolean readBoolean()
|
|||
|
|
{
|
|||
|
|
boolean b = false ;
|
|||
|
|
String s ;
|
|||
|
|
|
|||
|
|
s= readLine("boolean") ;
|
|||
|
|
|
|||
|
|
if (s.equalsIgnoreCase(String.valueOf(false))
|
|||
|
|
|| s.equalsIgnoreCase("faux") )
|
|||
|
|
b= false;
|
|||
|
|
|
|||
|
|
else if (s.equalsIgnoreCase(String.valueOf(true))
|
|||
|
|
|| s.equalsIgnoreCase("vrai") )
|
|||
|
|
b= true;
|
|||
|
|
|
|||
|
|
else
|
|||
|
|
conversionError( s , "boolean" ) ;
|
|||
|
|
|
|||
|
|
return b;
|
|||
|
|
|
|||
|
|
} // end readBoolean
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Lit un caract<EFBFBD>re dans une ligne.
|
|||
|
|
* La ligne lue doit contenir au maximum un caract<EFBFBD>re.
|
|||
|
|
* Si la ligne est vide le caract<EFBFBD>re <code>'\n'</code> est renvoy<EFBFBD>.
|
|||
|
|
*
|
|||
|
|
* Le programme stoppe en cas d'erreur de lecture ou en fin de fichier
|
|||
|
|
* ou encore si la ligne contenait plusieurs caract<EFBFBD>res.
|
|||
|
|
* @return le caract<EFBFBD>re lu ou <code>'\n'</code> si la ligne <EFBFBD>tait vide.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Reads one ASCII character and convert it into the internal <code>char</code>
|
|||
|
|
* format. If the line is empty <code>'\n'</code> is returned.
|
|||
|
|
* If more than one character are available in the line, only the first one is returned ; all other are
|
|||
|
|
* ignored.
|
|||
|
|
* Program exits on read errors or EOF or if more characters are available
|
|||
|
|
* @return the character or <code>'\n'</code> if line was empty.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
public static char readChar()
|
|||
|
|
{
|
|||
|
|
String s ;
|
|||
|
|
char c = '\n' ;
|
|||
|
|
|
|||
|
|
s= readNewLine("char");
|
|||
|
|
|
|||
|
|
if (s.length() == 1)
|
|||
|
|
c= s.charAt(0);
|
|||
|
|
else if ( s.length() != 0 )
|
|||
|
|
exitProgram( new ReadException(
|
|||
|
|
"La ligne lue contenait plus d'un caract<63>re : "
|
|||
|
|
+ '"' + s + '"' + '\n' )
|
|||
|
|
);
|
|||
|
|
|
|||
|
|
return c ;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Lit un nombre en virgule flottante et en double pr<EFBFBD>cision dans une ligne.
|
|||
|
|
* Ces nombres doivent <EFBFBD>tre conforme <EFBFBD> l'<EFBFBD>criture standard des constantes
|
|||
|
|
* <code>double</code> en Java et permettre la conversion par :
|
|||
|
|
* <code>Double(String).doubleValue()</code>
|
|||
|
|
* Le nombre peut <EFBFBD>tre pr<EFBFBD>c<EFBFBD>d<EFBFBD> ou suivi d'un nombre quelconque d'espaces
|
|||
|
|
* (SPACE ou TAB). La ligne lue ne doit comporter qu'un seul nombre.
|
|||
|
|
*
|
|||
|
|
* Le programme stoppe en cas d'erreur ou en fin de fichier
|
|||
|
|
* @return la valeur <code>double</code> correspondante.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Reads an ASCII decimal floating point number.
|
|||
|
|
* A floating point number should obey Java String conversion :
|
|||
|
|
* <code>Double(String).doubleValue()</code>
|
|||
|
|
* Program exits on read errors or EOF
|
|||
|
|
* @return the double.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
public static double readDouble()
|
|||
|
|
{
|
|||
|
|
String s ;
|
|||
|
|
double d = 0.0 ;
|
|||
|
|
|
|||
|
|
s= readLine("double");
|
|||
|
|
|
|||
|
|
try
|
|||
|
|
{
|
|||
|
|
d = new Double(s).doubleValue() ;
|
|||
|
|
}
|
|||
|
|
catch (NumberFormatException e)
|
|||
|
|
{
|
|||
|
|
conversionError( s, "double");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return d ;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Lit un nombre en virgule flottante et en simple pr<EFBFBD>cision dans une ligne.
|
|||
|
|
* Ces nombres doivent <EFBFBD>tre conforme <EFBFBD> l'<EFBFBD>criture standard des constantes
|
|||
|
|
* <code>float</code> en Java et permettre la conversion par :
|
|||
|
|
* <code>Float(String).floatValue()</code>
|
|||
|
|
* Le nombre peut <EFBFBD>tre pr<EFBFBD>c<EFBFBD>d<EFBFBD> ou suivi d'un nombre quelconque d'espaces
|
|||
|
|
* (SPACE ou TAB). La ligne lue ne doit comporter qu'un seul nombre.
|
|||
|
|
*
|
|||
|
|
* Le programme stoppe en cas d'erreur ou en fin de fichier
|
|||
|
|
* @return la valeur <code>float</code> correspondante.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Reads an ASCII decimal floating point number.
|
|||
|
|
* A floating point number should obey Java String conversion :
|
|||
|
|
* <code>Float(String).floatValue()</code>
|
|||
|
|
* Program exits on read errors or EOF
|
|||
|
|
* @return the double.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
public static float readFloat()
|
|||
|
|
{
|
|||
|
|
String s ;
|
|||
|
|
float f = 0.0F ;
|
|||
|
|
|
|||
|
|
s= readLine("float");
|
|||
|
|
|
|||
|
|
try
|
|||
|
|
{
|
|||
|
|
f = new Float(s).floatValue() ;
|
|||
|
|
}
|
|||
|
|
catch (NumberFormatException e)
|
|||
|
|
{
|
|||
|
|
conversionError( s, "float" );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return f ;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Lit un nombre entier dans une ligne.
|
|||
|
|
* Ces nombres doivent <EFBFBD>tre conforme <EFBFBD> l'<EFBFBD>criture standard des constantes
|
|||
|
|
* <code>int</code> en Java et permettre la conversion par :
|
|||
|
|
* <code>Integer.parseInt(String)</code>.
|
|||
|
|
* Le nombre peut <EFBFBD>tre pr<EFBFBD>c<EFBFBD>d<EFBFBD> ou suivi d'un nombre quelconque d'espaces
|
|||
|
|
* (SPACE ou TAB). La ligne lue ne doit comporter qu'un seul nombre.
|
|||
|
|
*
|
|||
|
|
* Le programme stoppe en cas d'erreur ou en fin de fichier
|
|||
|
|
* @return la valeur <code>int</code> correspondante.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Reads an ASCII decimal integer conforming to <code>Integer.parseInt(String)</code>.
|
|||
|
|
* Integers can be preceded by optional whitespace (SPACE or TAB).
|
|||
|
|
* Program exits on read errors or EOF
|
|||
|
|
* @return the integer.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
public static int readInt()
|
|||
|
|
{
|
|||
|
|
int i = 0 ;
|
|||
|
|
String s ;
|
|||
|
|
|
|||
|
|
s= readLine("int");
|
|||
|
|
|
|||
|
|
try
|
|||
|
|
{
|
|||
|
|
i = Integer.parseInt(s) ;
|
|||
|
|
}
|
|||
|
|
catch (NumberFormatException e)
|
|||
|
|
{
|
|||
|
|
conversionError( s, "int" );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return i ;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Lit un nombre entier long <EFBFBD>crit en base <code>b</code> dans une ligne.
|
|||
|
|
* Ces nombres doivent <EFBFBD>tre conforme <EFBFBD> l'<EFBFBD>criture standard des constantes
|
|||
|
|
* <code>long</code> en Java et permettre la conversion par :
|
|||
|
|
* <code>Long.parseLong(String,b)</code>
|
|||
|
|
* Le nombre peut <EFBFBD>tre pr<EFBFBD>c<EFBFBD>d<EFBFBD> ou suivi d'un nombre quelconque d'espaces
|
|||
|
|
* (SPACE ou TAB). La ligne lue ne doit comporter qu'un seul nombre.
|
|||
|
|
*
|
|||
|
|
* Le programme stoppe en cas d'erreur ou en fin de fichier
|
|||
|
|
* @param b la base dans laquelle l'entier lu est exprim<EFBFBD>
|
|||
|
|
* @return la valeur <code>long</code> correspondante.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Reads an ASCII long expressed in base <code>b</code> and conforming
|
|||
|
|
* to <code>Long.parseLong(String,b)</code>
|
|||
|
|
* Longs can be preceded by optional whitespace (SPACE or TAB).
|
|||
|
|
* Program exits on read errors or EOF
|
|||
|
|
* @param b the numbering base used to make the conversion
|
|||
|
|
* @return the long.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
public static long readLong(int b)
|
|||
|
|
{
|
|||
|
|
long l = 0L;
|
|||
|
|
String s ;
|
|||
|
|
String t = "long" ;
|
|||
|
|
|
|||
|
|
if ( b != 10)
|
|||
|
|
t= t + " in base " + b ;
|
|||
|
|
|
|||
|
|
s= readLine(t);
|
|||
|
|
|
|||
|
|
|
|||
|
|
try
|
|||
|
|
{
|
|||
|
|
l = Long.parseLong(s, b) ;
|
|||
|
|
}
|
|||
|
|
catch (NumberFormatException e)
|
|||
|
|
{
|
|||
|
|
conversionError( s, t) ;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return l ;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Lit un nombre entier long dans une ligne.
|
|||
|
|
* Ces nombres doivent <EFBFBD>tre conforme <EFBFBD> l'<EFBFBD>criture standard des constantes
|
|||
|
|
* <code>long</code> en Java et permettre la conversion par :
|
|||
|
|
* <code>Long.parseLong(String)</code>
|
|||
|
|
* Le nombre peut <EFBFBD>tre pr<EFBFBD>c<EFBFBD>d<EFBFBD> ou suivi d'un nombre quelconque d'espaces
|
|||
|
|
* (SPACE ou TAB). La ligne lue ne doit comporter qu'un seul nombre.
|
|||
|
|
*
|
|||
|
|
* Le programme stoppe en cas d'erreur ou en fin de fichier
|
|||
|
|
* @return la valeur <code>long</code> correspondante.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Reads an ASCII decimal long conforming to <code>Long.parseLong(String)</code>
|
|||
|
|
* Longs can be preceded by optional whitespace (SPACE or TAB).
|
|||
|
|
* Program exits on read errors or EOF
|
|||
|
|
* @return the long.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
public static long readLong()
|
|||
|
|
{
|
|||
|
|
return readLong(10) ;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Lit un nombre entier court dans une ligne.
|
|||
|
|
* Ces nombres doivent <EFBFBD>tre conforme <EFBFBD> l'<EFBFBD>criture standard des constantes
|
|||
|
|
* <code>short</code> en Java et permettre la conversion par :
|
|||
|
|
* <code>Short.parseShort(String)</code>
|
|||
|
|
* Le nombre peut tre pre<EFBFBD>c<EFBFBD>d<EFBFBD> ou suivi d'un nombre quelconque d'espaces
|
|||
|
|
* (SPACE ou TAB). La ligne lue ne doit comporter qu'un seul nombre.
|
|||
|
|
*
|
|||
|
|
* Le programme stoppe en cas d'erreur ou en fin de fichier
|
|||
|
|
* @return la valeur <code>short</code> correspondante.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Reads an ASCII decimal short.
|
|||
|
|
* Shorts can be preceded by optional whitespace (SPACE or TAB).
|
|||
|
|
* Program exits on read errors or EOF
|
|||
|
|
* @return the short.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
public static short readShort()
|
|||
|
|
{
|
|||
|
|
short j = 0 ;
|
|||
|
|
String s = readLine("short");
|
|||
|
|
|
|||
|
|
try
|
|||
|
|
{
|
|||
|
|
j = Short.parseShort(s) ;
|
|||
|
|
}
|
|||
|
|
catch (NumberFormatException e)
|
|||
|
|
{
|
|||
|
|
conversionError( s, "short" );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return j ;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Lit un octet dans une ligne.
|
|||
|
|
* Ces nombres doivent <EFBFBD>tre conforme <EFBFBD> l'<EFBFBD>criture standard des constantes
|
|||
|
|
* <code>byte</code> en Java et permettre la conversion par :
|
|||
|
|
* <code>Byte.parseByte(String)</code>
|
|||
|
|
* Le nombre peut <EFBFBD>tre pr<EFBFBD>c<EFBFBD>d<EFBFBD> ou suivi d'un nombre quelconque d'espaces
|
|||
|
|
* (SPACE ou TAB). La ligne lue ne doit comporter qu'un seul nombre.
|
|||
|
|
*
|
|||
|
|
* Le programme stoppe en cas d'erreur ou en fin de fichier
|
|||
|
|
* @return la valeur <code>byte</code> correspondante.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Reads an ASCII decimal byte.
|
|||
|
|
* Bytes can be preceded by optional whitespace (SPACE or TAB).
|
|||
|
|
* Program exits on read errors or EOF
|
|||
|
|
* @return the byte.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
public static byte readByte()
|
|||
|
|
{
|
|||
|
|
byte b = 0 ;
|
|||
|
|
String s = readLine("byte");
|
|||
|
|
|
|||
|
|
try
|
|||
|
|
{
|
|||
|
|
b = Byte.parseByte(s) ;
|
|||
|
|
}
|
|||
|
|
catch (NumberFormatException e)
|
|||
|
|
{
|
|||
|
|
conversionError( s, "byte" );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return b ;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Lit une ligne.
|
|||
|
|
*
|
|||
|
|
* Le programme stoppe en cas d'erreur de lecture.
|
|||
|
|
* @return une cha<EFBFBD>ne indiquant le contenu de la ligne ou
|
|||
|
|
* une cha<EFBFBD>ne vide lorsque la ligne <EFBFBD>tait vide ou
|
|||
|
|
* <code>null</code> en fin de fichier .
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Reads a line.
|
|||
|
|
* Program exits on read errors
|
|||
|
|
* @return the line content or an empty string if nothing entered or <code>null</code> if EOF reached .
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
public static String readLine()
|
|||
|
|
{
|
|||
|
|
String s = null ;
|
|||
|
|
|
|||
|
|
try
|
|||
|
|
{
|
|||
|
|
s= cin.readLine();
|
|||
|
|
}
|
|||
|
|
catch ( java.io.EOFException error)
|
|||
|
|
{
|
|||
|
|
s = null ;
|
|||
|
|
}
|
|||
|
|
catch ( Exception error )
|
|||
|
|
{
|
|||
|
|
exitProgram( new RuntimeException(error.toString()) ) ;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return s ;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Lit une nouvelle ligne.
|
|||
|
|
*
|
|||
|
|
* Le programme stoppe en cas d'erreur de lecture ou si la fin de fichier
|
|||
|
|
* est rencontr<EFBFBD>e.
|
|||
|
|
* @param t cha<EFBFBD>ne indiquant le type de la donn<EFBFBD>e lue dans cette ligne
|
|||
|
|
* @return une cha<EFBFBD>ne indiquant le contenu de la ligne ou
|
|||
|
|
* une cha<EFBFBD>ne vide lorsque la ligne <EFBFBD>tait vide .
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Reads a new line.
|
|||
|
|
* Program exits on read errors or if EOF is reached.
|
|||
|
|
* @param t String indicating the type expected in the line
|
|||
|
|
* @return the line content or an empty string if nothing entered .
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
private static String readNewLine(String t)
|
|||
|
|
{
|
|||
|
|
String s ;
|
|||
|
|
|
|||
|
|
s= readLine() ;
|
|||
|
|
|
|||
|
|
if ( s == null)
|
|||
|
|
readError ( " Fin de fichier inattendue" , t) ;
|
|||
|
|
|
|||
|
|
return s ;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Lit une donn<EFBFBD>e de type <code>t</code> dans une ligne non vide.
|
|||
|
|
*
|
|||
|
|
* Le programme stoppe en cas d'erreur de lecture, de fin de fichier
|
|||
|
|
* ou si la ligne <EFBFBD>tait vide.
|
|||
|
|
* @param t cha<EFBFBD>ne indiquant le type de la donn<EFBFBD>e lue dans cette ligne
|
|||
|
|
* @return une cha<EFBFBD>ne indiquant le contenu non vide de la ligne.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Reads a data of type <code>t</code> in a non empty line.
|
|||
|
|
* Program exits on read errors or EOF or if line is empty
|
|||
|
|
* @param t String indicating the type expected in the line
|
|||
|
|
* @return the non empty line content
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
private static String readLine(String t)
|
|||
|
|
{
|
|||
|
|
String s ;
|
|||
|
|
|
|||
|
|
s= readNewLine(t).trim() ;
|
|||
|
|
|
|||
|
|
if (s.length() == 0)
|
|||
|
|
readError ( " Ligne vide" , t) ;
|
|||
|
|
|
|||
|
|
return s ;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
} // end class Console
|