Diferència entre revisions de la pàgina «M3 - Programació estructurada / Continguts UF1: Cadenes de caràcters»

Revisió del 12:36, 19 feb 2018

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().
• El mètode nextLine() llegeix tots els elements pendents de llegir a la línia actual i avalua la cadena de text que els conté tots.
• 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.

• Exemple: Llegir línies de text escrites pel teclat.

• Fixeu-vos que sempre el programa s’aturarà a esperar que escriviu un text i pitgeu la tecla de retorn.

import java.util.Scanner;

   //Llegeix frases escrites pel teclat.

   public class LecturaFrase {

     public static void main(String[] args) {

       final int NUM_FRASES = 4;
       Scanner lector = new Scanner(System.in);
       System.out.println("Escriu " + NUM_FRASES + " frases.");
       System.out.println("Per acabar una frase, pitja la tecla de retorn.");
       for (int i = 0; i < NUM_FRASES; i++) {
         //Es van llegint frases una per una.
         String frase = lector.nextLine();
         System.out.println("Frase " + i + ": Has escrit \"" + frase + "\".");
       }
       //Ara no cal llegir la resta de cap línia, ja que sempre es llegeixen
       //línies senceres...
     }
   }

Argument del mètode principal

Manipulació de cadenes de text

Alguns mètodes de la classe String

Mètodes length, charAt i getChars

Comparació de cadenes

Localització de cadenes i subcadenes

Extracció de subcadenes

Concatenació de cadenes

Diversos mètodes

El mètode valueOf