Entrada / Sortida en Java

       Strings

       Escriptura de dades

       Lectura de dades de teclat

       Lectura de dades de la línia de comandes

     En les aplicacions que es programaran en aquest curs es faran servir mecanismes de lectura i escriptura de dades senzills. Tots ells es basaran en la manipulació de dades de tipus String.

     Una variable de tipus String es pot interpretar com un vector de carącters. Hi ha diferents operacions que podem fer sobre strings: concatenar, calcular la seva longitud, convertir-los en altres tipus de dades. Els strings seran el tipus de dades que farem servir per comunicar les nostres aplicacions amb els dispositus de lectura i escriptura de dades: teclat i pantalla. Algunes coses que podem fer sobre strings:

• Podem declarar una variable de tipus String:
  
            String s;
  
  
• Podem assignar-li un valor:
  
            s = "Aixo es un string."
  
  
• Podem concatenar strings. En l'exemple anterior hi podriem afegir:
  
            s = "Hola. " + s + " Es mes llarg que abans."
  
        i tindriem que el valor de la variable s seria "Hola. Aixo es un string. Es mes llarg que abans.".
  
  
• Quan estem treballant amb strings, Java permet fer conversions implícites d'altres tipus a strings. Per exemple, suposem que tenim una variable x de tipus int. El valor de la variable en aquests moments es 5. Després de fer:
  
            s = "El valor de x es " + x
  
        el string s valdria "El valor de x es 5". En l'assignació anterior, s'interpreta que el resultat .nal ha de ser un string. Per aquesta raó, l'operand x de la concatenació es converteix implícitament a string.
  
  
• Podem saber la longitut d'un string:
  
            s = "Hola."; int l=s.length;
  
        Després d'executar les sentències anteriors, el valor de l serà 5.
  
  
• Podem fer conversions explícites de strings a altres tipus de dades. Per això cal que el string convertit contingui un vector de caràcters que sigui interpretable com una dada del tipus al que volem convertir. Per exemple, si s="385", podem convertir el valor de s a unenter de la següent manera:
  
            int x = Integer.parseInt(s)
  
        i tindrem el valor enter 385 a la variable x. Si la mateixa sentència s'hagués executat amb el valor s="Hola", hauriem observat un error d'execució del programa indicant que el contingut de la variable s no pot ser interpretat com un enter.
  
       java.lang.NumberFormatException: Hola
            at java.lang.Integer.parseInt(Integer.java)
            at java.lang.Integer.parseInt(Integer.java)
            at programa.main(suma.java:11)
  
  
• Amb els strings es poden fer moltes altres coses. Algunes d'elles es veuran posteriorment en el curs. Només una advertència: els strings no es poden comparar fent servir operadors relacionals convencionals. Per exemple, després d'executar:
  
       String s1 = "Hola";
       String s2 = "Hola";
       int x;
       if (s1 == s2) x = 1; else x=2;
  
       el valor de la variable x ser. a 2. Quan calgui, ja es veuràa com comparar strings.

     Sovint voldrem veure el resultat calculat pels nostres programes a la pantalla del nostre ordinador. aixó ho podrem fer amb la sentència:

              System.out.println (s);

     on s és una expressió de tipus string. Tal com s'ha vist amb la manipulació de strings, aquesta expressió pot incloure operands d'altres tipus que seran convertits implícitament a strings. La sentència anterior escriu el string per pantalla i hi afegeix un salt de línia. Per exemple, la sentència:

      String s = "Missatge: ";
      int x = 13;
      System.out.println (s + "el valor de x es " + x + ".");

      escriuria la següent línia a la pantalla de l'ordinador:

      Missatge: el valor de x es 13.

     En el cas de que no es vulgui afegir el salt de línia, es pot fer servir la sentència System.out.print (s)

    Molts dels nostre programes ens demanaran que entrem dades a través del teclat i que simultàniament observarem a la pantalla. Hi ha moltes maneres d'entrar dades. En els nostres primers programes ho farem amb un mecanisme senzill: llegint línies que contenen strings. En aquests moments no cal preocupar-se sobre el significat exacte de les sentències que s'esplicaran. Només cal saber que ens permetran llegir dades que després podrem utilitzar en els nostres programes.

     Explicarem el mecanisme amb un exemple d'un programa que calcula la suma de dos nombres enters:

     import java.io.*;
     public class suma
     {
          public static void main (String args []) throws IOException
          {
               String s; // s acollira els strings llegits
               BufferedReader in; // Dispositiu d'on
                                  // llegirem les dades
               int x,y,sum;
               // Primer identifiquem el
               // dispositiu d'entrada de dades (teclat)
               in = new BufferedReader(new InputStreamReader(System.in));
               System.out.print ("Entra el primer nombre: ");
               s = in.readLine();
               x = Integer.parseInt(s);
               System.out.print ("Entra el segon nombre: ");
               y = Integer.parseInt(in.readLine());
               sum = x+y;
               System.out.println ("La suma de " + x + " i " + y + " es " + sum);
          }
     }


     El dispositiu d'entrada de dades el declararem com una variable de tipus BufferedReader. Al principi de l'execució del programa, identificarem el dispositiu que volem fer servir:

     in = new BufferedReader(new InputStreamReader(System.in));

     El dispositiu System.in correspon al teclat del nostre ordinador. A partir d'aquí, podem llegir línies (seqüències de caràcters fins al final de línia) i enmagatzemar-les en variables de tipus String. Les sentències:

     s = in.readLine();
     x = Integer.parseInt(s);

     llegeixen un string i l'enmagatzemen a s. Després s'interpreta el contingut de s con un enter i s'assigna a x. Tot aixó es pot fer amb una única sentència, tal i com es mostra quan es llegeix la variable y:

     y = Integer.parseInt(in.readLine());

     Durant l'execució del programa anterior, s'observaria la següent interacció amb l'usuari:

     > java suma
     Entra el primer nombre: 12
     Entra el segon nombre: 5
     La suma de 12 i 5 es 17
     >

     L'execució de programes en Java ens permet llegir dades directament de la línia de comandes on invoquem al programa. Per exemple, podriem canviar la interacció amb l'usuari del programa anterior de la següent manera:

     > java suma 12 5
     La suma de 12 i 5 es 17
     >

     El programa seria més senzill que l'anterior:

     import java.io.*;
     public class suma2
     {
          public static void main (String args []) throws IOException
          {
               int x,y,sum;
               x = Integer.parseInt (args[0]);
               y = Integer.parseInt (args[1]);
               sum = x+y;
               System.out.println ("La suma de " + x + " i " + y + " es " + sum);
          }
     }


     La funció main (programa principal) recull en el vector args tots els strings que afegim darrera del nom del programa. Així, args[0] conté el primer string, args[1] el segon string, etc. Amb aquest mecanisme cal, però, garantir que el programa no accedirà a més arguments dels que haguem especificat a la línia de comandes. Si, per exemple, executessim l'anterior programa de la següent manera:

     > java suma 12
     java.lang.ArrayIndexOutOfBoundsException: 1
     at suma.main(suma.java:9)
     >

     obtindriem l'error observat degut a que la sentència y = Integer.parseInt (args[1]); estaria intentant accedir al segon element del vector args en un cas en el que aquest vector només té un element.