L'Altruiste : Le langage Java - Gestion des entrées et sorties standards

Dans la plupart des cas, toutes les applications informatiques doivent être en mesure d'assurer une certaine interactivité entre la machine et un utilisateur. Les entrées provenant du clavier et les sorties affichées à l'écran fournissent un moyen de communication standard.

A cet effet, le langage Java dispose de la classe java.lang.System qui contient plusieurs champs et méthodes. Deux de ces champs sont particulièrement intéressants puisqu'ils fournissent un accès aux flux de sortie et d'entrée standards.

Le champ in représente le flux d'entrée standard qui est toujours disponible et prêt à recevoir des données provenant en général d'un clavier.
```
int cararactere = System.in.read();
```
Le champ out représente le flux de sortie standard qui est également toujours disponible et prêt à envoyer des données vers en général un écran d'ordinateur.
```
System.out.println("Données à afficher à l'écran !");
```

Pour une meilleure efficacité, le champ System.in, en fait un objet InputStream doit passer dans un premier temps par un objet InputStreamReader faisant office de pont entre un flux binaire et un flux de caractères, puis par un objet BufferedReader conservant dans une mémoire tampon un certain nombre de caractères saisis.

import java.io.*;
class InOut {
    public static void main(String args[]) throws IOException {
        BufferedReader entreeClavier = new BufferedReader(
                                       new InputStreamReader(System.in));
        System.out.println ("Saisissez une phrase :");
        String saisie = entreeClavier.readLine();
        System.out.println ("Merci !");
        System.out.println ("Votre phrase est : ");
        System.out.println (saisie);
    }
}

D'autres méthodes sont également utilisables pour récupérer le contenu du flux d'entrée standard, en mettant en oeuvre les méthodes de l'objet InputStream.

import java.io.*;
class InOut {
    public static void main(String args[]) throws IOException {
        byte[] tab = new byte[255];
        //Récupération dans le flux, de 255 caractères.
        int nb = System.in.read(tab, 0, tab.length);
        //Vide le contenu du flux d'entrée standard en
        //déchargeant la totalité des octets disponibles dans le flux.
        System.in.skip(System.in.available());
        String tampon = new String (tab);
        //Affiche la chaîne de caractères saisie 
        //en supprimant le terminateur de ligne.
        System.out.println(tampon.substring(0, 
                tampon.lastIndexOf(System.getProperty("line.separator"))));
    }
}

Désormais, la saisie en mode console résolue, il ne reste plus qu'à contrôler les entrées des utilisateurs afin de les incorporer dans un programme Java. Dans l'exemple ci-dessous, chaque type primitif Java fait l'objet d'un traitement particulier dans le but de récupérer effectivement une valeur correspondant à ce type.

import java.io.*;
import java.util.regex.*;
/**

 * La classe Console fournit les moyens à des utilisateurs en mode console,
 
 * de saisir des informations de différents types primitifs Java
 
 * ou de chaînes de caractères.

 * Cette classe est capable de lire un nombre d'un type primitif désiré
 
 * et d'en contrôler la validité.

 * Cette classe propose également de contrôler des chaînes de caractères
 
 * selon un format précis, à l'image d'adresses email, IP ou URL.

 *

 * @author Pascal EMMA

 * @version 1 du 24/08/2003

 * @see java.io.PrintStream

 * @see java.lang.System

 */
class Console {
    /**

     * Le champ encodage contient le type d'encodage de caractères 

     * de la plateforme courante.

     */
    public static String encodage = System.getProperty("file.encoding");
    /**

     * Le champ termintateur contient le le terminateur de lignes
 
     * de la plateforme courante.

     */
    private static String terminateur = System.getProperty("line.separator");
    /**

     * Le champ statique in représente une instance de la classe Console.

     */
    public static final Console in = new Console();
    /**

     * Le champ statique out représente un flux vers la sortie standard.

     * @see java.io.PrintStream

     */
    public static final PrintStream out = new PrintStream(System.out, true);
    /**

     * La méthode saisirLigne permet de lire une valeur saisie
 
     * par l'utilisateur sur l'entrée standard.

     * @return retourne la chaîne de caractères saisie par l'utilisateur 

     *  ou la valeur 'null' dans le cas contraire.

     */
    public String saisirLigne(){
        try{
            BufferedReader entreeClavier = new BufferedReader(
                                           new InputStreamReader(System.in));
            return entreeClavier.readLine();
        }
        catch (IOException e) {
            return null;
        }
    }
    /**

     * La méthode verifNombre permet de vérifier la validité
 
     * des nombres saisis par l'utilisateur.

     * Il est possible de vérifier soit des entiers, soit des réels.

     * @param valeur représente la valeur saisie par l'opérateur.

     * @param type représente le type de nombres à vérifier.
 
     *  <ul>

     *  <li>La valeur 'reel' permet de tester les nombres réels,</li>

     *  <li>La valeur 'entier' permet de tester les nombres entiers.</li> 

     * </ul>

     * @return retourne 'true' si la valeur testée est un nombre
 
     *          ou 'false' dans le cas contraire.

     */
    private boolean verifNombre(String valeur, String type) {
        String regexp;
        if(type.equals("entier"))
            regexp = "[+-]?[0-9]*";
        else
            regexp = "[+-]?[0-9]*[.Ee]?[+-]?[0-9]*";
        Pattern modele = Pattern.compile(regexp);
        Matcher correspondance = modele.matcher(valeur);
        if(valeur != null && !valeur.equals("") && correspondance.matches())
            return true;
        else
            return false;
    }
    /**

     * La méthode saisirLong permet de lire des nombres entiers
 
     * de type primitif 'long'.

     * @return retourne une valeur entière de type 'long'.

     *  Si la valeur saisie par l'opérateur excède les limites du type 'long'
 
     *  alors la valeur entière maximum ou minimum selon le cas est retournée. 

     */
    public long saisirLong(){
        double nb = 0;
        String valeur = saisirLigne(); 
        if(verifNombre(valeur, "entier"))
            nb = Double.parseDouble(valeur);
        if(nb < Long.MAX_VALUE && nb > Long.MIN_VALUE)
            return Long.parseLong(valeur);
        else if(nb > 0)
            return Long.MAX_VALUE;
        else
            return Long.MIN_VALUE;
    }
    /**

     * La méthode saisirInt permet de lire des nombres entiers de type primitif 'int'.

     * @return retourne une valeur entière de type 'int'.

     *  Si la valeur saisie par l'opérateur excède les limites du type 'int'
 
     *  alors la valeur entière maximum ou minimum selon le cas est retournée.

     */
    public int saisirInt(){
        long valeur = saisirLong();
        if(valeur < Integer.MAX_VALUE && valeur > Integer.MIN_VALUE)
            return (int)valeur;
        else if(valeur > 0)
            return Integer.MAX_VALUE;
        else
            return Integer.MIN_VALUE;
    }
    /**

     * La méthode saisirShort permet de lire des nombres entiers
 
     * de type primitif 'short'.

     * @return retourne une valeur entière de type 'short'.

     *  Si la valeur saisie par l'opérateur excède les limites du type 'short'
 
     *  alors la valeur entière maximum ou minimum selon le cas est retournée.

     */
    public short saisirShort(){
        long valeur = saisirLong();
        if(valeur < Short.MAX_VALUE && valeur > Short.MIN_VALUE)
            return (short)valeur;
        else if(valeur > 0)
            return Short.MAX_VALUE;
        else
            return Short.MIN_VALUE;
    }
    /**

     * La méthode saisirByte permet de lire des nombres entiers de type primitif 'byte'.

     * @return retourne une valeur entière de type 'byte'.

     *  Si la valeur saisie par l'opérateur excède les limites du type 'byte'
 
     *  alors la valeur entière maximum ou minimum selon le cas est retournée.

     */
    public byte saisirByte(){
        long valeur = saisirLong();
        if(valeur < Byte.MAX_VALUE && valeur > Byte.MIN_VALUE)
            return (byte)valeur;
        else if(valeur > 0)
            return Byte.MAX_VALUE;
        else
            return Byte.MIN_VALUE;
    }
    /**

     * La méthode saisirDouble permet de lire des nombres à virgule flottante
 
     * de type primitif 'double'.

     * @return retourne une valeur réelle de type 'double'.

     *  Si la valeur saisie par l'opérateur excède les limites du type 'double'
 
     *  alors la valeur entière maximum ou minimum selon le cas est retournée.

     */
    public double saisirDouble(){
        double nb = 0;
        String valeur = saisirLigne(); 
        if(valeur.indexOf(",") != -1) valeur = valeur.replace(',','.');
        if(verifNombre(valeur, "reel"))
            nb = Double.parseDouble(valeur);
        if(nb < Double.MAX_VALUE && nb > Double.MIN_VALUE)
            return nb;
        else if(nb > 0)
            return Double.MAX_VALUE;
        else
            return Double.MIN_VALUE;
    }
    /**

     * La méthode saisirFloat permet de lire des nombres à virgule flottante
 
     * de type primitif 'float'.

     * @return retourne une valeur réelle de type 'float'.

     *  Si la valeur saisie par l'opérateur excède les limites du type 'float'
 
     *  alors la valeur entière maximum ou minimum selon le cas est retournée.

     */
    public float saisirFloat(){
        double valeur = saisirDouble();
        if(valeur < Float.MAX_VALUE && valeur > Float.MIN_VALUE)
            return (float)valeur;
        else if(valeur > 0)
            return Float.MAX_VALUE;
        else
            return Float.MIN_VALUE;
    }
    /**

     * La méthode saisirChar permet de lire un unique caractère
 
     * de type primitif 'char'.

     * @return retourne une valeur de type 'char'.

     *  Si la valeur saisie par l'opérateur est nulle ou vide
 
     *  alors la valeur minimum est retournée.

     */
    public char saisirChar(){
        String valeur = saisirLigne();
        if(valeur != null && !valeur.equals(""))
            return valeur.charAt(0);
        else
            return Character.MIN_VALUE;
    }
    /**

     * La méthode saisirAvecMasque permet de lire une chaîne de caractères
 
     * respectant le format passé en argument.

     * @param format représente le masque de format sous la forme
 
     *  d'une chaîne de caractères et respectant les standards
 
     *  des expressions régulières.

     * @return retourne une chaîne de caractères respectant un certain format.

     *  Si la saisie est erronée, alors la valeur 'null' est retournée.

     */
    public String saisirAvecMasque(String format){
        String valeur = saisirLigne();
        Pattern modele = Pattern.compile(format);
        Matcher correspondance = modele.matcher(valeur);
        if(valeur != null && valeur.length() > 0 && correspondance.matches())
            return valeur;
        else
            return null;
    }
    /**

     * La méthode saisirEmail permet de lire une chaîne de caractères
 
     * respectant le format d'une adresse email.

     * @return retourne une chaîne de caractères représentant une adresse email.

     *  Si la saisie est erronée, alors la chaîne de caractères
 
     *  'utilisateur@domaine.ext' est retournée.

     */
    public String saisirEmail(){
        String masque = "^[a-zA-Z]+[a-zA-Z0-9\\._-]*[a-zA-Z0-9]@[a-zA-Z]+"
                                + "[a-zA-Z0-9\\._-]*[a-zA-Z0-9]+\\.[a-zA-Z]{2,4}$";
        String valeur = saisirAvecMasque(masque);
        if(valeur != null)
            return valeur;
        else
            return "utilisateur@domaine.ext";
    }
    /**

     * La méthode saisirEmail permet de lire une chaîne de caractères
 
     * respectant le format d'une adresse IP (Internet Protocol).

     * @return retourne une chaîne de caractères représentant une adresse IP.

     *  Si la saisie est erronée, alors la chaîne de caractères
 
     * '000.000.000.000' est retournée.

     */
    public String saisirIP(){
        String masque = "^[0-2]?[0-9]{0,2}\\.[0-2]?[0-9]{0,2}\\.[0-2]?"
                                + "[0-9]{0,2}\\.[0,2]?[0-9]{0,2}$";
        String valeur = saisirAvecMasque(masque);
        if(valeur != null)
            return valeur;
        else
            return "000.000.000.000";
    }
    /**

     * La méthode saisirURL permet de lire une chaîne de caractères
 
     * respectant le format d'une adresse URL (Uniform Resource Locator).

     * @return retourne une chaîne de caractères représentant une adresse URL.

     *  Si la saisie est erronée, alors la chaîne de caractères
 
     *  'protocole://domaine:port/repertoire/

     *        fichier.ext?champ=valeur&champ2=valeur' est retournée.

     */
    public String saisirURL(){
        String masque = "^[a-z]*://[a-z0-9\\._-]*(\\.[a-z]{2,4})?"
                      + "(:[0-9]{1,5})?((/[a-z0-9\\.-_ ]*)*(\\.[a-z]{2,4}(\\?.*)?)?)?";
        String valeur = saisirAvecMasque(masque);
        if(valeur != null)
            return valeur;
        else
            return "protocole://domaine:port/repertoire" 
                              + "/fichier.ext?champ=valeur&champ2=valeur";
    }
}

Télécharger l'ensemble des exemples