import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.util.StringTokenizer; /** * ITI1520 (Automne 2002-2007) *
* 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; } }