M3 - Programació estructurada / Continguts UF1: Cadenes de caràcters

A Java el tipus de dada compost cadena de text o String serveix per representar i gestionar de manera senzilla una seqüència de caràcters.

La classe String

• Tipus de dada compost.
• S'usa el terme classe per referir-se a un tipus de dada compost.
• Es poden assignar valors directament.
• S’usa el terme objecte per referir-se al valor assignat a una variable d’un tipus de dades compost.
• La classe que representa una cadena de text s’anomena explícitament String.

Inicialització d’objectes String

• Cal assignar un objecte.
• La representació d'un objecte pot variar depenent de la classe emprada.
• Pels string, es fa com amb un tipus de dada primitiu.
• Els objectes String es representant mitjançant un literal, en aquest cas, text envoltat entre cometes dobles.
• Exemple d'inicialització:

    String holaMon = "Hola, món!";

• Cadena buida:

    String cadenaBuida = "";

Manipulació d’objectes

• No hi ha operadors que manipulin o comparin directament objectes.
• La manipulació d’objectes es fa mitjançant la invocació de mètodes sobre les variables en què es troben emmagatzemats.
• La llista de mètodes que poden ser invocats sobre una variable on s’emmagatzema un objecte depèn exclusivament de la seva classe.
• Classes diferents permeten la invocació de diferents mètodes.
• Els mètodes es criden mitjançant l’identificador de la variable, seguida d’un punt, i llavors el nom del mètode que volem.
• Hi ha mètodes amb paràmetres: llista de valors entre parèntesis, separats per comes (..., ..., ...).
• Si el mètode no requereix cap paràmetre, només cal obrir i tancar parèntesis, ().
• La sintaxi seria:

   identificadorVariable.nomMètode (paràmetre1, paràmetre2,..., paràmetreN);

"Arrays" de cadenes de text

• Es poden declarar i usar arrays d’objectes, com les cadenes de text.
• S'utilitza la mateixa sintaxi que per els arrays de tipus primitiu.
• La instrucció vinculada a la definició del tipus ara indica el nom de la classe.
• Per exemple, array amb capacitat per a 5 cadenes de text:

   //Inicialització a valor concret.
   //Un literal d’una cadena de text es representa amb text entre cometes dobles.
   
   String[] arrayCadenaConcret= {"Valor1", "Valor2", "Valor3", "Valor4", "Valor5"};

   //Inicialització a valor per defecte.
   
   String[] arrayCadenaDefecte = new String[5];

• El valor per defecte és null.

Compte!!:

• Si es mostra per pantalla, apareix el text: “null”.
• Qualsevol invocació d’un mètode sobre seu dóna un error.

• Donat que a cada posició d'un array d'objectes hi ha un objecte, es poden invocar els seus mètodes:

public class ArrayString {

     public static void main(String[] args) {

       String[] text = {"Hi", "havia", "una", "vegada..."};
       System.out.println("El text de l’array és:");
       for (int i = 0; i < text.length; i++) {
         System.out.println("Posició " + i + ": " + text[i]);
       }
       System.out.println("Les seves mides són:");
       for (int i = 0; i < text.length; i++) {
         System.out.println("Posició " + i + ": " + text[i].length());
       }
     }
   }

Entrada de cadenes de text

• Dues possibilitats:

• Amb el teclat.
• Mitjançant arguments en el mètode principal.

Lectura des de teclat

• Només cal saber quines són les instruccions adients per obtenir cadenes de text des de teclat.
• Abans de veure les instruccions, repassarem els elements que intervenen en el procés de lectura de dades per teclat aprofitant que s’han introduït els conceptes de classe, objecte i mètode.

Lectura de paraules individuals

• El mètode de la classe Scanner vinculat a la lectura d’una cadena de text composta d’una única paraula és next().
• La invocació d’aquest mètode sobre un objecte de la classe Scanner avalua una cadena de text.
• En aquest context, una paraula és qualsevol combinació de lletres o nombres que no conté cap espai enmig. Per tant, aquest mètode pot llegir els textos individuals “Hola,”, “món!”, “1024”, “3.1426”, “base10”, etc.
• sempre avalua una cadena de text, mai un tipus numèric. Fins i tot quan el valor llegit és un nombre.
• No cal fer cap comprovació de tipus prèvia a la lectura (mètodes hasNext...) , ja que tota dada escrita mitjançant el teclat sempre és pot interpretar com una cadena de text.
• Exemple: El següent programa llegeix fins a 10 paraules i les va mostrant per pantalla.

• Proveu d’escriure més d’una paraula a cada línia (una frase sencera) i observeu com les llegeix totes una per una abans d’esperar novament una entrada de dades.
• Fixeu-vos que les paraules queden discriminades en la lectura, en estar separades amb espais.

import java.util.Scanner;

   //Llegeix un cert nombre de paraules (en aquest cas, 10).

   public class LecturaParaules {

     public static final int NUM = 10;

     public static void main(String[] args) {

       Scanner lector = new Scanner(System.in);
       System.out.println("Escriu " + NUM + " paraules separades per espais.");
       System.out.println("Les pots escriure en línies de text diferent, si vols.");
       for (int i = 0; i < NUM; i++) {
         String paraula = lector.next();
         System.out.println("Paraula " + (i+1) + ": \"" + paraula + "\".");
       }
       //Es llegeix la resta de la línia i s’ignora el contingut.
       lector.nextLine();
     }
   }

Lectura de caràcters individuals

• La classe Scanner no ofereix cap mètode per llegir caràcters individuals.
• Cal llegir l’entrada com una cadena de text, comprovar que aquesta només es compon d’un únic caràcter i extreure’l.

• Per llegir una cadena de text hi ha el mètode next().
• Per establir la llargària d’una cadena de text es disposa del mètode length(). En aquest cas, cal veure si és 1.
• Per extreure un caràcter individual, tenim el mètode charAt(numPosició). En aquest cas, la posició per consultar és la 0.

• Exemple: Escollir la resposta correcta entre quatre opcions etiquetades amb una lletra.

• Per simplificar el codi, només es permet un sol intent.
• Executeu-lo i observeu atentament cadascuna de les passes tot just descrites per veure si s’ha llegit realment una única lletra i extreure-la.

import java.util.Scanner;

   //Mostra una pregunta tipus test i mira si s’endevina.

   public class LecturaCaracter {

     public static void main(String[] args) {

       final char RESPOSTA_CORRECTA = 'b';
       Scanner lector = new Scanner(System.in);
       System.out.println("Endevina la pregunta.");
       System.out.println("Quin dels següents no és un tipus primitiu?");
       System.out.println("a) Enter");
       System.out.println("b) Scanner");
       System.out.println("c) Caràcter");
       System.out.println("d) Booleà");
       System.out.print("La teva resposta és l’opció: ");
       //Es llegeix la cadena de text.
       String paraula = lector.next();
       //És una paraula d’un únic caràcter?
       if (paraula.length() == 1) {
         //S’extreu el caràcter de la cadena de text.
         char caracter = paraula.charAt(0);
         //És un caràcter vàlid? (a, b, c o d)
         if ((caracter >= 'a') && (caracter <= 'd')) {
           //La resposta final és correcta?
           if (caracter == RESPOSTA_CORRECTA) {
             System.out.println("Efectivament, la resposta era "+ RESPOSTA_CORRECTA + ".");
           } else {
               System.out.println("La resposta " + caracter + " és incorrecta.");
             }
         } else {
             System.out.println(" " + caracter + " és una opció incorrecta.");
           }
       } else {
           System.out.println("\"" + paraula + "\" no és un caràcter individual.");
         }
       lector.nextLine(); 
     }
   }

Lectura de frases senceres

• El mètode de la classe Scanner vinculat a la lectura d’una cadena de text en forma de frase en què hi ha diverses paraules separades per espais és nextLine().

Fins al moment, aquest mètode ha estat usat per descartar tota la llista d’elements pendents de llegir del teclat (en el cas que s’hagi escrit més d’un element en una única línia). En realitat, aquest mètode el que fa és llegir tots els elements pendents de llegir a la línia actual i avaluar la cadena de text que els conté tots. Per tant, serveix per llegir conjunts d’elements de cop, independentment dels espais en blanc que els separen. A efectes pràctics amb vista a la lectura de cadenes de text, si mai no es combina l’ús de nextLine() amb altres mètodes de lectura d’elements individuals (next(), nextInt(), etc.) és possible usar-lo per llegir frases senceres directament. Cada cop que s’invoca, el programa es bloqueja i espera que l’usuari entri una frase sencera i pitgi la tecla de retorn. Llavors, avalua tota la frase escrita (totes les paraules amb espais inclosos). En aquest cas, i al contrari que amb la resta de mètodes de lectura, no és possible escriure més d’un element dins una mateixa línia de text, ja que llegeix tota la línia al complet des de la darrera lectura fins a trobar un salt de línia. El programa d’exemple següent mostra com es llegeix una línia de text completa escrita pel teclat, de manera molt semblant a l’exemple anterior de llegir paraules individuals. Tot i així, fixeu-vos que hi ha algunes diferències en el codi i en el comportament. Concretament, mai no es donarà el cas que una lectura pel teclat no ocasioni el bloqueig del programa a l’espera que escriviu quelcom. Absolutament sempre s’aturarà a esperar que escriviu un text i pitgeu la tecla de retorn.