//<title>Programmation d'entrées/sorties en Java </title>

/*  EsXmp.java <xmp>
      utilise les fichiers: U.class, servletssrc.zip, ABR.java

   FluxCaractère: classe permettant les lectures de valeur de type String,
   int ou double à partir de caractères (saisie au clavier ou lecture
   dans un fichier).
   U  : classe utilitaire
	   économie sur la frappe de caractères
		saisie clavier faciles pour 'int', 'float' et 'string'
   FiltreExtension implements FileFilter

 Exemples d'utilisation:
 1. lecture d'un caractère au clavier
 2. lecture d'une ligne au clavier
 3. lecture d'un entier au clavier
 4. lecture par lignes d'un fichier texte
 5. recopie de fichier (flots d'octets)
 6. fichier extrait d'un fichier *.zip
 7. récupération d'une image sur un site
 8. sauvegarde/lecture de structure dynamique (construction d'un ABR)
 9. nom des fichiers dont l'extension est connue

 à partir d'un flot d'octets:<br>
   classes InputStream         -> InputStreamReader -> BufferReader

 à partir d'un fichier d'octets:<br>
        FileInputStream     -> InputStreamReader -> BufferReader

 à partir d'un fichier de caractères<br>
           FileReader          -> InputStreamReader -> BufferReader

  et aussi

  <!-- = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = -->

      <pre>
     <!-- 140980843   taille de jbuilder8.zip -->




   InputStreamReader fait le lien entre flots d'octets et flot de caractères,
      en convertissant les octets en caractères (codés sur 2 octets) (d'après
      une correspondance - voir classe Charset)
      (cf. sur Unicode: www.unicode.org/standard/translations/french.html)


 Conversions
     chaîne vers entier      Integer.parseInt("345")
     entier vers chaine      Integer.toString(123456)
     chaîne  vers  décimal   Float.parseFloat("3.14")
     décimal vers chaîne     Float.toString(3.14159)

 Obtenir un flot tamponné, de caractères, en lecture
     depuis un flot d'octets flotOct (classe InputStream)
        new BufferedReader(new InputStreamReader(flotOct))
     depuis un fichier de nom
        new BufferedReader(new FileReader("abcd"))
             FileNotFoundException

 Obtenir un flot de caractères, tamponné, en écritures
     vers un flot d'octets flotOct (classe OutputStream)
        new BufferedWriter(new OutputStreamWriter(flotOct));
     vers un fichier de nom "abcd"
        new BufferedWriter(new FileWriter("abcd"))
            IOException

    Reader -> InputStreamReader -> FileReader
    Writer -> OutputStreamWriter -> FileWriter

 Afficher tous les types élémentaires
      PrintStream
      PrintWriter

 Par exemple, pour un fichier avec tampon, on part d'une suite d'octets
    issus d'un fichier, considérée ensuite comme suite de caractères, puis
    à gérer avec une zone tampon. On peut donc construire successivement les
    objets suivants, chacun étant obtenu à partir du précédent:
       un fichier-java à partir d'une chaîne
       un flot d'octets
       un flot de caractères
       un tampon
    D'où les constructions:
        File fichier = new File("abc");
        FileInputStream flotOctets = new FileInputStream( fichier);
        InputStreamReader flotCars = new InputStreamReader( flotOctets);
        BufferedReader  tamponCars = new  BufferedReader(flotCars);

 Heureusement il existe des classes qui permettent des raccourcis; le même
    tampon est obtenu par:
       un flot de caractères obtenu à partir d'un nom de fichier:
           FileReader flotCar1 = new FileReader("abc");
       un tampon à partir d'un flot de caractères
           BufferedReader  flotTmpCar1 = new  BufferedReader(flotCar1);

 Lecture d'octets
    InputStream: classe abstraite permettant d'analyser les octets du flot
    FilterInputStream

 lecture avec tampon
            BufferedInputStream(InputStream in)
            BufferedInputStream(InputStream in, int taille)
         conversion des octets('binaire') vers les types de base
            DataInputStream

   UTF UTF-8  codage Unicode

   Types de base:
      boolean
      byte, char
      short, int, long
      float, double

   ClassCastException
   EOFException()
   FileNotFoundException
   IllegalArgumentException
   IndexOutOfBoundsException
   IOException
   NullPointerException
   NumberFormatException
   SecurityException
   UnsupportedEncodingException
   UTFDataFormatException

   InterruptedIOException
   InvalidClassException
   IOException
   NotActiveException
   NotSerializableException
   ObjectStreamException
      InvalidObjectException
      WriteAbortedException
   StreamCorruptedException
   SyncFailedException
   UnsupportedEncodingException
   UTFDataFormatException

 Passer d'un objet flot d'octets en objet flot de caractères:
      InputStreamReader   lecture de caractères
              InputStreamReader(InputStream in)
         InputStreamReader(InputStream in, String codage)

 Lecture, avec tampon, de caractères: BufferedReader
      (donc lecture par ligne)
           possibilité de construire à partir d'un InputStreamReader, avec ou
           sans précision de taille
         BufferedReader(Reader in)
                   BufferedReader(Reader in, int taille)

 Afficher la classe de l'objet entrée-clavier (System.in):
      System.out.println(System.in.getClass().getName());

 Exemple de lecture d'un 'float' au clavier
      // Suite de caractères à partir d'entrée clavier:
      InputStreamReader entClavier=new InputStreamReader(System.in);
      // Gestion par lignes de cette suite
      BufferedReader ent = new BufferedReader (entClavier );
      // Lecture de la valeur(suite de caractères)
      String ch=new String(ent.readLine());
      // Conversion en un objet Float:
      Float objF=new Float(ch);
      // Conversion en type float
      float f=objF.floatValue();
      // ou  sans passer par un objet Integer: float f=Float.parseFloat(ch);


 Converion ou l'information sous des formes différentes:
 Remarque: dans la classe Float, on trouve trois méthodes de conversion
    qui ne nécessitent pas d'objet(méthodes statiques), permettant les
    changements de forme:
       Float.parseFloat(chaine)        fournit un décimal(float)
       Float.toString(décimal)         fournit une chaîne(String)
       Float.valueOf(chaine)           fournit un Float
    et des méthodes sur objet Float
       objetFloat.floatString()        fournit une chaîne(String)
       objetFloat.toString()           fournit une chaîne(String)

 Exemple de lecture d'un 'int' au clavier
    // Conversion en un objet Integer:
    Integer objI=new Integer(ch);
    // Conversion en type int (ou long)
    int i=objI.intValue();
    // ou  sans passer par un objet Integer: int i=Integer.parseInt(ch);



   A partir de fichier:
      FileInputStream qui dérive de InputStream
      FileReader qui dérive de InputStreamReader
   A partir d'un tube
      PipedInputStream qui dérive de InputStream
   A partir de plusieurs flots:
      SequenceInputStream qui dérive de InputStream
   A partir de chaîne en mémoire
      StringBufferInputStream  qui dérive de InputStream

   A partir d'une URL
      URLConnection (paquage java.net)
   A partir d'une socket
      Socket (paquage java.net)
   A partir d'une requête Http
      ServletRequest (paquage javax.servlet)
   A partir d'un fichier compressé
      ZipInputStream (paquage java.util.zip)


        * @return     the next eight bytes of this file, interpreted as a
        *             <code>double</code>.
        * @exception  EOFException  if this file reaches the end before reading
        *             eight bytes.
        * @exception  IOException   if an I/O error occurs.
        * @see        java.io.RandomAccessFile#readLong()
        * @see        java.lang.parseDouble#longoBitsToDouble(long)

    des exemples: http://cui.unige.ch/java/exemples/index.html
   les classes du JDK: http://java.sun.com/j2se/1.4.1/docs/api/
   pour IU graphique: http://pandonia.canberra.edu.au/java/tut/tut.html
   </pre>









<xmp>
*/

import java.io.*;         // pour BufferedReader
import java.net.*;        // pour URL et URLConnection
import java.util.*;       // pour Enumeration
import java.util.zip.*;   // pour ZipFile

public class EsXmp {
// Entrée clavier
public static FluxCaractère clv = new FluxCaractère(System.in);

/** Divers exemples.
 * Lectures au clavier:
 * d'une chaîne de caractères, d'un nombre décimal (type double) et
 * d'un nombre entier.
 * @param m les mots de la ligne de commande
 */

public static void main(String[] m) {
    String txt; double dd; int ii; float x; char c;

    // U.a("Un caractère: ");
    // try {
    //   c = (char) System.in.read();
    //   U.a_("  -> lu " + c);
    // } catch (Exception e) { U.a("erreur ", e); } ;

    // essai1();
    // essai2(); if(true) System.exit(1);
    // essai3(); if(true) System.exit(1);
    // essai4(); if(true) System.exit(1);
    // essai5(); if(true) System.exit(1);
    // essai6(); if(true) System.exit(1);
    // essai7(); if(true) System.exit(1);
    // essai8(); if(true) System.exit(1);
    essai9(); if(true) System.exit(1);

    // Lecture d'une chaine avec FluxCaractère
    txt = U.string_("(FluxCaractère) Une chaine: ");
    U.a_("Chaine lue de longueur " + txt.length());

    // Lecture d'un double avec FluxCaractère
    // U.a("(FluxCaractère) Un double: ");
    // dd = clv.double_();
    // U.a_("lu : "+ dd);

   // Lecture d'un int avec FluxCaractère
   // ii = clv.int_("(FluxCaractère) Un entier : ");
   // U.a_("lu : "+ ii);
   // U.arrêt();

   // Lecture d'un float avec la clase U
   U.a("Un décimal : "); x = U.float_();
   U.a_("lu : "+ x);
   U.arrêt();

   String nFic="EsXmp.javaa";
   // Lecture par lignes d'un fichier texte
   try {
      FileReader f = new FileReader(nFic);
	    U.a("\nLecture dans " + nFic);
		  U.a_(" (codage caractères: " + f.getEncoding()+')');

      FluxCaractère ec = new  FluxCaractère(f);
      String lig; int num=0;

      lig = ec._string();
      while (ec.ready()){
          num++;
          // U.a_("" + num + " : " + lig);
          lig = ec._string();
          }
      f.close();
      U.a_("\n" + num + " lignes");
      }
   catch (IOException e) { U.a("EsXmp.main()",e); };


   // Copie de fichier texte, sans se préoccuper si le fichier créé écrase
   // un fichier existant du même nom. On considère que le fichier est petit,
   // ayant une taille de moins d'un méga octets. On demande d'abord sa taille
   // afin de lire en une seule instruction tous les caractères (cf. tableau
   // contenu); puis on écrit, également en une seule instruction, tous ces
   //  caractères.
   // Comme des exceptions peuvent être déclanchées, il est nécessaire d'ouvrir
   // les blocs try-catch.
   try {
      File unFic = new File(nFic);
      int taille = (int)unFic.length();
      FileReader fec =    // fichier en entrée de caractères
              new FileReader(unFic);
      FileWriter fsc =     // fichier en sortie de caractères
              new FileWriter("cop"+nFic.substring(0,nFic.length()-1));
      char contenu[]= new char[taille];
      // fec.read(contenu,0,taille);
      fec.read(contenu);
      fec.close();
      // U.arrêt(); U.a(new String(contenu));
      // fsc.write(contenu,0,taille);
      fsc.write(contenu);
      fsc.close();
      U.a("\nLecture et écriture de "+taille+" caractères");
      }
   catch (FileNotFoundException e) { U.a("Fichier non trouvé ",e); }
   catch (IOException e) { U.a("Création impossible ",e); };



    // Flux prédéfinis
    U.a_("\nSystem.in: "+System.in.getClass());
    U.a_("\nSystem.out: "+System.out.getClass());
    U.a_("\nSystem.err: "+System.err.getClass());

    U.a_("\nRépertoire courant: "+System.getProperty("user.dir"));

    /*  Création de fichier
       FileOutputStream extends OutputStream
      , FileReader
          FileOutputStream(File file)      throws FileNotFoundException
          FileOutputStream(String name)
          FileOutputStream(String name, boolean append)
       RandomAcessFile
    */

    String fic=".";                 // fic="EsXmp.java";
    File f=new File(fic);

    U.a_("\nTaille: " + f.length());

    // Pour répertoire ?
    U.a_("\nNom parent: "+f.getParent());

    U.a_("\nNom complet: "+f.getAbsolutePath());
    String rep=f.getAbsolutePath();
    U.a_("repértoire: " + rep.substring(0,rep.lastIndexOf(File.separator)));

    /* Page HTML récupérée sur un site
         try {
       URL url=new URL("http://www.iut-orsay.fr/");
       URLConnection con = url.openConnection();

       U.a_("Nb.octets: "+con.getContentLength());
       InputStream flb =con.getInputStream();
       // BufferedReader ft =new BufferedReader(new InputStreamReader(flb));
       FluxCaractère ec = new  FluxCaractère(flb);
       String lig; int num=0;
       U.a_("\nLecture depuis " + url.toString());
       U.arrêt();
       lig = ec._string();
       while (ec.ready()){
          num++;
          U.a_("" + num + " : " + lig);
          lig = ec._string();
          }
       flb.close();
       U.a_("\nRécupéré " +num + " lignes de " + url);
       }
    catch (IOException e) { U.a("Sur URL ",e); };
    */

    U.arrêt();
    }

   static void essai() {
   try {
      }
   catch (Exception e) { System.out.println("erreur de lecture "+e); } ;
   }

   static void essai1() {
   // Lecture d'un caractère au clavier
   InputStreamReader flotCar = new InputStreamReader(System.in);
   BufferedReader flotCarTampon =  new BufferedReader(flotCar);

   System.out.print("Une lettre: ");
   try {
      char c = (char)flotCarTampon.read();
      System.out.println(" -> Caractère Lu: '"+c+'\'');
      } catch (Exception e) { System.out.println("erreur de lecture "+e); } ;
   }
   static void essai2() {
   // Lecture d'une ligne au clavier

   // Obtenir un fichier tamponné, à partier de l'entrée standard
   InputStreamReader flotCar = new InputStreamReader(System.in);
   BufferedReader flotCarTampon =  new BufferedReader(flotCar);

   System.out.print("Nom, prénom: ");
   try {
      String ch=flotCarTampon.readLine();
      System.out.println(" -> Lu: "+ch);
      } catch (Exception e) { System.out.println("erreur de lecture "+e); } ;
   }

   static void essai3() {
   // Lecture d'une entier au clavier

   // Obtenir un fichier tamponné, à partier de l'entrée standard
   InputStreamReader flotCar = new InputStreamReader(System.in);
   BufferedReader flotCarTampon =  new BufferedReader(flotCar);

   int n=Integer.MIN_VALUE;
   try {
      System.out.print("Un entier: ");
      // Lecture suite de caractères
      String ch = flotCarTampon.readLine();
      // Conversion caractères -> entier
      n = Integer.parseInt(ch);
      }
   catch (NumberFormatException e) {
      System.out.println("FluxCaractère.int_(): (entier attendue!)"+e);
      }
   catch (IOException e) {
      System.out.println("FluxCaractère.int_() (erreur E/S)"+e);
      }
   System.out.println(" -> Entier obtenu: "+n);

   // En admettant les espaces autour de la valeur
   try {
      System.out.print("Un entier: ");
      String ch = flotCarTampon.readLine();
      n = Integer.parseInt(ch.trim());
      }
   catch (NumberFormatException e) {
      System.out.println("FluxCaractère.int_(): (entier attendue!)"+e);
      }
   catch (IOException e) {
      System.out.println("FluxCaractère.int_() (erreur E/S)"+e);
      }
   System.out.println(" -> Entier obtenu: "+n);
   }


   static void essai4() {
   // Lecture, par lignes d'un fichier texte
   String nFic="EsXmp.java";
   String lig; int num=0; // num = nb. de lignes

   try {
      FileReader fc = new FileReader(nFic);
      BufferedReader fct = new BufferedReader(fc);

      // Parcours du fichier par ligne
      lig = fct.readLine();
      while (lig != null){
          num++;                       // une ligne de plus
          System.out.println("" + num + " : " + lig);
          lig = fct.readLine();
          }

      fct.close();
      }
   catch (FileNotFoundException e) {
      System.out.println("Fichier non trouvé "+e);
      }
   catch (IOException e) { System.out.println("Erreur E/S "+e); };
   }

   static void essai5() {
   // Copie de fichier texte, sans se préoccuper si le fichier créé écrase
   // un fichier existant du même nom. On considère que le fichier est petit,
   // ayant une taille de moins d'un méga octets. On demande d'abord sa taille
   // afin de lire en une seule instruction tous les caractères (cf. tableau
   // contenu); puis on écrit, également en une seule instruction, tous ces
   //  caractères.
   // Comme des exceptions peuvent être déclanchées, il est nécessaire d'ouvrir
   // les blocs try-catch.
   String nFic = "U.class";
   try {
      File unFic = new File(nFic);
      int taille = (int)unFic.length();
      FileInputStream fol =    // flot d'octets en lecture
              new FileInputStream(unFic);
      FileOutputStream foe =     // fichier d'octets en écriture
              new FileOutputStream("copie");
      byte contenu[]= new byte[taille];
      fol.read(contenu);
      fol.close();
      foe.write(contenu);
      foe.close();
      System.out.println("\nLecture et écriture de "+taille+" octets");
      }
      catch (FileNotFoundException e) {
       System.out.println("Fichier non trouvé "+e);
       }
    catch (IOException e) {
       System.out.println("Création impossible "+e);
       };
     }

   static void essai6() {
      // Dans le fichier servletssrc.zip, plusieurs fichiers compressés; on
      // veut lire l'original relatif à
      //            org/eclipse/help/internal/webapp/data/Topic.java
      // import java.util.zip.*
      try {
         ZipFile zip = new ZipFile("servletssrc.zip");
         ZipEntry item;
         // Si on veut afficher toutes les entrées dans le fichier *.zip
         // Enumeration items=zip.entries();  int ni=0;
         // U.a_("items: " + items);
         // while(items.hasMoreElements()) {
         //    item = (ZipEntry) items.nextElement(); ni++;
         //    U.a("  "+item.getName());
         //    if(ni % 5 == 0) U.a_("");
         //    }

         // Une entrée seule nous intéresse
         item = zip.getEntry("org/eclipse/help/internal/webapp/data/Topic.java");
         // Constructions des flots
         InputStream flotOctet=zip.getInputStream(item);
         BufferedReader flotCT =
            new BufferedReader(
               new InputStreamReader(flotOctet));
         // Affichage par lignes
         String ligne = flotCT.readLine();
         while (ligne != null){
             System.out.println(ligne);
             ligne = flotCT.readLine();
             }

         zip.close();
         }
      // Pour ouvrir servletssrc.zip
      catch(ZipException e){ System.out.println("Fichier zip "+e); }
      // Pour obtenir item
      catch(IllegalStateException e){ System.out.println("Fichier zip "+e); }
      // Pour obtenir flot d'octets
      catch (IOException e) { System.out.println("erreur sur flot "+e); }
      catch (Exception e) { System.out.println("erreur de lecture "+e); } ;
      }

   static void essai7() {
      // Récupération d'une image sur un site
      // http://localhost:8080/test/logo-iut.gif
      // import java.net.*;          // pour URL et URLConnection
      String urlImage="http://localhost:8080/test/logo-iut.gif";
      String nomCopie="copie.gif";    // fichier contenant la copie
      try {
         // Déclarer la connexion et ouvrir un flot
         URL url = new URL(urlImage);
         InputStream flotUrl = url.openStream();
         // Fichier et flot recevant la copie
         FileOutputStream flotCopie = new FileOutputStream(nomCopie);

         // byte im[] = new byte[tailleFicImage];
         // flotUrl.read(im);
         // foe.write(im); foe.flush();

         // Transfert octet par octet
         int b=flotUrl.read();
         U.a_("Disponible: "+flotUrl.available());
         while( flotUrl.available()>0) {
            flotCopie.write(b); b=flotUrl.read();
            }
         // Fermer fichier image
         flotUrl.close(); flotCopie.close();
         // En plus
         URLConnection  urlCon = url.openConnection();
         int tailleFicImage = urlCon.getContentLength();
         U.a_("Taille image: "+tailleFicImage);
         }
      catch (MalformedURLException e) {System.out.println("erreur sur url "+e);}
      catch (IOException e) { System.out.println("erreur sur flot "+e);}
      }

   static void essai8() {
      // Construction d'un ABR
      // edelweiss crocus campanule aster gentiane oeillet genépi soldanelle
      ABR abr=new ABR("edelweiss");    // la racine de l'arbre
      // Ajout de plusieurs noeuds
      abr.ajouter("crocus");
      // abr.ajouter("campanule");
      // abr.ajouter("aster");
      abr.ajouter("gentiane");
      abr.ajouter("genepi");
      // abr.ajouter("oeillet");
      abr.ajouter("soldanelle");

      System.out.println("Ordre alphabétique: " + abr);
      try {
         String nomFicAbr="fic.abr";
         abr.afficher("Arbre transmis vers fichier:");
         abr.versFichier(nomFicAbr);
         ABR abrLu = ABR.depuisFichier(nomFicAbr);
         abrLu.afficher("Arbre récupéré du fichier:");
         }
      catch (IOException e) { System.out.println("erreur sur fic.abr "+e);}

      // abr.afficher();
      }

   static void essai9() {
      String ext="class";
      // String nomRépertoire = "D:\\roger\\app\\java\\jb\\es";
      String nomRépertoire = ".";

      File rep= new File(nomRépertoire);
      if(! rep.isDirectory() ) {
         System.out.println(rep + " n'est pas un répertoire");
         System.exit(1);
         }
      // Fichiers de ce répertoire
      // File contenu[]=rep.listFiles();
      // for( int i=0; i<contenu.length; i++) {
      //    if(contenu[i].isDirectory()) U.a("rep: ");
      //    U.a_(contenu[i].getName());
      //    }
      // U.arrêt();

      System.out.println("Fichier d'extension "+ ext + " dans "
           +rep.getAbsolutePath() + " et ses sous-répertoires");
      FiltreExtension f = new FiltreExtension(ext);
      f.listeFichiers(rep);
      }


} // fin class EsXmp



// cf jdk/demo/jfc/FileChooser
class FiltreExtension implements FileFilter  {
   private String extension;
   FiltreExtension(String e) {extension=e.toLowerCase();}

   /** Fournit les répertoires et les fichiers dont l'extension    *
    * @param f
    * @return
    */
   public boolean accept(File f) {
      if(f == null) return false;
      else if(f.isDirectory()) return true;
      else return extension.compareTo(getExtension(f)) == 0;
      }


   public void listeFichiers(File rep) {
      listeFichiers(rep,"");
      }

   private void listeFichiers(File rep, String mg) {
      int i,nff;  // nff = nb. fichiers filtrés
      String mg1=mg+"   ";
      File contenu[]=rep.listFiles(this);
      // Parcours des Fichiers simples
      for( i=0,nff=0; i<contenu.length; i++) {
         if(contenu[i].isFile()) {
            nff++;
            if(nff==1) System.out.println(mg+contenu[i].getParent());
            System.out.println(mg1+contenu[i].getName());
            }
         }
      // Parcours des sous-répertoires
      for( i=0,nff=0; i<contenu.length; i++)
           if(contenu[i].isDirectory()) listeFichiers(contenu[i],mg1);
     }

  /** Fournit l'extension du nom d'un objet File
   * @param f
   * @return les caractères de l'extension ou null si f==null ou si le
   * nom n'a pas d'extension
   */
   private String getExtension(File f) {
      if(f == null) return null;
      String nom = f.getName();
      int pp = nom.lastIndexOf('.'); // position du point
      if(pp>0 && pp<nom.length()-1)
         return nom.substring(pp+1).toLowerCase();
      else return null;
       }
   } // fin class FiltreExtension


/**
  Simplifie la lecture au clavier.
*/

class FluxCaractère extends BufferedReader {

/** Création à partir d'un flux d'octets.
 * Exemple  FluxCaractère clavier = new FluxCaractère(System.in);
 * @param flOctets est un flux d'octets
 */
public FluxCaractère( InputStream flOctets) {
    super( new InputStreamReader(flOctets) );
    // pour connaître le codage des caractères:
    // InputStreamReader isr = new InputStreamReader(is);
    // a_("(FluxCaractère():  codage " + isr.getEncoding());
    }
/**
 * Création à partir d'un flux de caractères.
 *
 * @param flCaractères un flux de caractères
 */
public FluxCaractère( Reader flCaractères) {
    super( flCaractères );
    // pour connaître le codage des caractères:
    // InputStreamReader isr = new InputStreamReader(is);
    // a_("(FluxCaractère():  codage " + isr.getEncoding());
    }

/** Affiche l'intitulé intit et lit une valeur numérique décimale
 *  (cette lecture est bloquante).
 * @param intit message d'invite affiché avant la saisie
 * @return le double lu ou Double.NEGATIVE_INFINITY si les caractères
*  lus ne sont pas convertibles en un 'double'.
*/
public double double_(String intit) {
    U.a( intit );
    return this.double_();
    }

/** Lit une valeur numérique décimale (cette lecture est bloquante).
  * @return le double lu ou Double.NEGATIVE_INFINITY si les caractères
  *     lus ne sont pas convertibles en un 'double'.
*/
public double double_() {
    double dd=Double.NEGATIVE_INFINITY;
    try {
      String ch = this.readLine();
      while( ch.length()==0 ) ch = this.readLine();
      // une possibilité: Double dD = new Double(ch); dd = dD.doubleValue();
      dd=Double.parseDouble(ch);
      }
    catch (NumberFormatException e) {U.a("double_(): (décimal attendu)",e); }
    catch (IOException e) {U.a("double_() (erreur E/S)",e);}
    return dd;
    }

/**
    Affiche un intitulé et lit une ligne.
    @param intitulé : message affiché, avant la saisie
    @return suite de caractères lus (sans saut R/C ni saut de ligne)
*/
public String _string(String intitulé) {
   U.a( intitulé );
   return this._string();
   }
/**
    Lit une ligne.
    @return suite de caractères lus (sans saut R/C ni saut de ligne)
*/
public String _string() {
   String ch=null;
   try { ch = this.readLine(); }
   catch(IOException e) { U.a("FluxCaractère._string() ", e); }
   return ch;
   }

/**
    Affiche un intitulé et lit une valeur numérique entière
    (cette lecture est bloquante).

    @param intitulé : message affiché, avant la saisie
    @return l'entier lu ou Integer.MIN_VALUE si les caractères lus ne
       sont pas convertibles en un 'int'.
*/
public int int_(String intitulé) {
    U.a( intitulé );
    return this.int_();
    }

/**
    Lit une valeur numérique entière (cette lecture est bloquante).
    @return l'entier lu ou Integer.MIN_VALUE si les caractères lus
    ne sont pas convertibles en un 'double'.
*/
public int int_() {
    int ii=Integer.MIN_VALUE;
    try {
      String ch = this.readLine().trim();        // espaces enlevés
      while( ch.length()==0 ) ch = this.readLine().trim();
      // Une possibilité: ii=(new Integer(ch)).intValue();
      ii = Integer.parseInt(ch);
      }
    catch (NumberFormatException e) {
       U.a("FluxCaractère.int_(): (entier attendue!)",e);
      }
    catch (IOException e) {
       U.a("FluxCaractère.int_() (erreur E/S)",e);
      }
    return ii;
    }
  } // fin class FluxCaractère


/**
    Classe utilitaire, évitant des frappes au clavier.
    Remplacer: System.out.print par <b>U.a</b>
    <br>System.out.println par <b>U.a_</b>
    <br>Utiliser aussi <b>U.a(String message, Exception e)</b>

*/
class U {
private static BufferedReader clavier =
        new BufferedReader( new InputStreamReader(System.in));
  /** Afficher le texte txt.

   * Utiliser cette méthode pour abréger la frappe au clavier, car <tt>U.a(</tt>
   * est plus court à écrire que <tt>System.out.print(</tt>
   * </p>
   * @param txt : texte à afficher
   */
  static void a( String txt) {System.out.print(txt);}
  /**
   * Afficher le texte txt, et <b>passer</b> à la ligne
   * @param txt : texte à afficher
   */
  static void a_( String txt) {System.out.println(txt);}
  /** Affiche le texte txt, puis le message lié à une exception.
   * <p>La pile d'appels n'est pas affichée.</p>
   * @param txt : texte à afficher
   * @param e :   exception
   *  */
  static void a( String txt, Exception e) {
     a_("\n"+txt);
     if( e != null) {
        // a_("     --> "+e.getLocalizedMessage());   // message court
        a_("     --> " + e.toString());
        // e.printStackTrace();    // trace des appels
        }
     }

  /** lecture au FluxCaractère blocante */
  static void arrêt() {
    byte aux[]=new byte[80];
    try { a("\nSuite >>> "); System.in.read(aux,0,80);}
    catch (Exception e) {}
    }

    /**
        Lit une valeur numérique décimale (cette lecture est bloquante).
        @return le décimal(float) lu ou <b>Float.NEGATIVE_INFINITY</b> si les
     *   caractères lus ne sont pas convertibles en un 'double'.
    */
   public static float float_() {
        float dd=Float.NEGATIVE_INFINITY;
        try {
          String ch = clavier.readLine().trim();
          while( ch.length()==0 ) ch = clavier.readLine().trim();
          dd=Float.parseFloat(ch);
          }
        catch (NumberFormatException e) {U.a("float_(): (décimal attendu)",e); }
        catch (IOException e) {U.a("float_() (erreur E/S)",e);}
        return dd;
        }

   /**
            Affiche un intitulé et lit une valeur numérique entière
            (cette lecture est bloquante).

            @param intitulé : message affiché, avant la saisie
            @return l'entier lu ou Integer.MIN_VALUE si les caractères lus ne
               sont pas convertibles en un 'int'.
        */
   public static int int_(String intitulé) {
       U.a( intitulé );
       return int_();
       }

   /**
       Lit une valeur numérique entière (cette lecture est bloquante).
       @return l'entier lu ou Integer.MIN_VALUE si les caractères lus
       ne sont pas convertibles en un 'double'.
   */
   public static int int_() {
       int ii=Integer.MIN_VALUE;
       try {
         String ch = clavier.readLine().trim();        // espaces enlevés
         while( ch.length()==0 ) ch = clavier.readLine().trim();
         // Une possibilité: ii=(new Integer(ch)).intValue();
         ii = Integer.parseInt(ch);
         }
            catch (NumberFormatException e) {
               U.a("FluxCaractère.int_(): (entier attendue!)",e);
              }
            catch (IOException e) {
               U.a("FluxCaractère.int_() (erreur E/S)",e);
              }
            return ii;
            }
   /**
     Affiche un intitulé et lit une ligne.
     @param intitulé : message affiché, avant la saisie
     @return suite de caractères lus (sans saut R/C ni saut de ligne)
   */
   public static String string_(String intitulé) {
      U.a( intitulé );
      return string_();
      }
   /**
    Lit une ligne.
    @return suite de caractères lus (sans saut R/C ni saut de ligne)
    */
public static String string_() {
     String ch=null;
     try { ch = clavier.readLine(); }
     catch(IOException e) { U.a("U.string_() ", e); }
     return ch;
     }


  }  // fin class U



 // fin EsXmp.java </xmp>