* Cette classe offre des méthodes utiles pour lire * des valeurs à partir du clavier. À placer dans le * même répertoire que vos programmes Java. *
* Trois ensembles de méthodes de lectures sont offertes: *
readInt, readDouble,
* readChar et readBoolean:
* Lit une valeur simple.readIntLine, readDoubleLine,
* readCharLine: Lit toutes les valeurs sur une
* ligne et les place dans un tableau d'une longueur appropriée.readString:
* Lit une chaîne de caractères.* Aucune de ces méthodes ne permet de lire des valeurs de types * différents à partir d'une même ligne. *
* Prières d'utiliser ITI1520.class dans vos devoirs, et non * Lire.class tel qu'utilisé dans le manuel. *
* SVP: NE PAS ME MODIFIER! Merci.
*
* @author Alan Williams
* @author Daniel Amyot
* @author Amy Felty
* @author Stéphane Somé
* @version 2007
*/
public class ITI1520
{
private static final BufferedReader keyboard = new BufferedReader(
new InputStreamReader( System.in ) );
/**
* Ce constructeur privé indique qu'aucune instance de cette classe ne peut
* être créée.
*/
private ITI1520( )
{
}
/**
* Pour lire un nombre entier de type int à partir du
* clavier.
* Si l'utilisateur entre une valeur qui n'est pas un int,
* une exception {@link NumberFormatException} sera lancée et le programme
* terminera. Appuyer sur "Enter" sans entrer de valeur produira le
* même résultat.
*
* Notez bien que cette méthode ne permet pas de + avant l'entier. Par
* exemple, +123 n'est pas valide.
*
* @return Un entier (int) lu au clavier.
* @throws NumberFormatException
* si ce qui est entré n'est pas un entier.
*/
public static int readInt( )
{
String inputString = getInput( );
return Integer.parseInt( inputString );
}
/**
* Pour lire un nombre réel de type double à partir du
* clavier.
*
* Si l'utilisateur entre une valeur qui n'est pas un double,
* une exception {@link NumberFormatException} sera lancée et le programme
* terminera. Appuyer sur "Enter" sans entrer de valeur produira le
* même résultat.
*
* Notez aussi que la lecture d'un réel ne nécessite pas de 0 avant
* le point. Par exemple: -.2 est valide.
*
* @return Un nombre réel (double) lu au clavier.
* @throws NumberFormatException
* si ce qui est entré n'est pas un nombre réel.
*/
public static double readDouble( )
{
String inputString = getInput( );
return Double.parseDouble( inputString );
}
/**
* Pour lire un caractère simple
* de type char à partir du clavier.
*
* Si aucun caractère n'est fourni, l'exception * {@link StringIndexOutOfBoundsException} sera générée et le programme * terminera. Sinon, le premier caractère de la chaîne lue sera * retourné. *
*
* @return Un caractère de type char
* lu au clavier.
*/
public static char readChar( )
{
String inputString = getInput( );
// Retourne le premier caractère de la chaîne lue.
return inputString.charAt( 0 );
}
/**
* Pour lire une valeur booléenne simple
* de type boolean à partir du clavier.
*
* Retourne true si la chaîne "true" (en majuscule, minuscule ou * cases mélangées) est fournie au clavier, sinon retourne false. *
*
* @return Un booléen de type boolean
* lu au clavier.
*/
public static boolean readBoolean( )
{
String inputString = getInput( );
// Converti la chaîne à un booléen.
return Boolean.valueOf( inputString ).booleanValue( );
}
/**
* Pour lire un tableau de nombres réels de type
* double à partir du clavier.
*
* Les nombre réels doivent être séparés par au moins un espace. *
* Si l'utilisateur entre une valeur qui n'est pas un double,
* une exception {@link NumberFormatException} sera lancée et le programme
* terminera.
*
* Si toutes les valeurs entrées sont des double valides,
* alors un nouveau tableau est créé. La longueur du tableau correspond
* au nombre de valeurs entrées. Les valeurs sont placées dans le
* tableau dans l'ordre utilisé lors de leur entrée.
*
* @return Un tableau de nombres réels de type double
* contenant les valeurs lues au clavier.
* @throws NumberFormatException
*/
public static double[] readDoubleLine( )
{
String inputString = getInput( );
// StringTokenizer sépare la chaîne aux espaces blancs.
StringTokenizer st = new StringTokenizer( inputString );
// Combien de valeurs entrées?
int numberOfValues = st.countTokens( );
// Crée le tableau.
double[] values = new double[numberOfValues];
// Chaque morceau (token) est de type String et doit être
// converti en double.
for ( int index = 0; index < numberOfValues; index = index + 1 )
{
String stringValue = st.nextToken( );
values[index] = Double.parseDouble( stringValue );
}
return values;
}
/**
* Pour lire un tableau de nombres entiers de type
* int à partir du clavier.
*
* Les nombre entiers doivent être séparés par au moins un espace. *
* Si l'utilisateur entre une valeur qui n'est pas un int,
* une exception {@link NumberFormatException} sera lancée et le programme
* terminera.
*
* Si toutes les valeurs entrées sont des int valides,
* alors un nouveau tableau est créé. La longueur du tableau correspond
* au nombre de valeurs entrées. Les valeurs sont placées dans le
* tableau dans l'ordre utilisé lors de leur entrée.
*
* @return Un tableau de nombres entiers de type int
* contenant les valeurs lues au clavier.
* @throws NumberFormatException
*/
public static int[] readIntLine( )
{
String inputString = getInput( );
// StringTokenizer sépare la chaîne aux espaces blancs.
StringTokenizer st = new StringTokenizer( inputString );
// Combien de valeurs entrées?
int numberOfValues = st.countTokens( );
// Crée le tableau.
int[] values = new int[numberOfValues];
// Chaque morceau (token) est de type String et doit être
// converti en int.
for ( int index = 0; index < numberOfValues; index = index + 1 )
{
String stringValue = st.nextToken( );
values[index] = Integer.parseInt( stringValue );
}
return values;
}
/**
* Pour lire un tableau de caractères de type
* char à partir du clavier.
*
* L'utilisateur entre une chaîne de caractères et appuie sur "Enter" pour * retourner à la méthode invocatrice. Tous les caractères, espaces * inclus, sont placés dans le tableau. *
* La chaîne de caractères entrée est convertie en un tableau de
* caractères de longueur appropriée.
*
* @return Un tableau de caractères de type char
* contenant les caractères lus au clavier.
*/
public static char[] readCharLine( )
{
String inputString = getInput( );
// Converti la chaîne en tableau de caractères
return inputString.toCharArray( );
}
/**
* Pour lire une chaîne de caractères
* de type String à partir du clavier.
*
* L'utilisateur entre une chaîne de caractères et appuie sur "Enter" pour * retourner à la méthode invocatrice. Tous les caractères, espaces * inclus, sont placés dans le tableau. *
*
* @return Une chaîne de caractères de type String
* contenant les caractères lus au clavier.
*/
public static String readString( )
{
String inputString = getInput( );
return inputString;
}
/**
* Cette méthode privée lit l'entrée au clavier comme un String.
*
* Son intention est de gérer les exceptions {@link IOException} possibles
* qui pourraient être générées par la méthode readline() afin
* que la méthode main() n'ait pas à déclarer qu'elle doive
* gérer cette exception.
*
* Si l'exception survient, alors la pile des appels est affichée et le * termine. * * @return Un {@link String} contenant l'entrée fournie au clavier. */ private static String getInput( ) { String inputString = null; try { inputString = keyboard.readLine( ); } catch ( IOException e ) { e.printStackTrace( ); // Ceci pourrait ne pas fonctionner avec DrJava System.exit( 0 ); } return inputString; } }