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().
• 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

• permet establir una entrada de dades al programa sense haver d’interrompre’n l’execució per haver de preguntar quelcom a l’usuari i esperar una entrada per teclat.
• És molt útil quan no es vol, o no es pot, esperar que l’usuari estigui pendent. Per exemple, per fer copies de seguretat cada nit (programar una execució periòdica) i es necessari proporcionar-li certa informació que no pot estar escrita dins el codi font.
• La llista d’arguments d’un programa s’introdueix com un conjunt de paraules a continuació del nom del fitxer executable, separades per espais.
• La llista de paraules que conformen els arguments es pot obtenir directament a partir de la variable especial que es defineix en la declaració del mètode principal: String[] args.
• Pren la forma d’un array de cadenes de text, en què aquestes ocupen les posicions en el mateix ordre que s’han escrit els arguments en executar el programa.
• Per saber amb quants arguments s’ha executat el programa cal usar l’atribut length associat als arrays.
• Si no s’ha passat cap argument, el seu valor serà 0. En aquest cas, l'accés a una posició de l’array serà sempre incorrecte.

Manipulació de cadenes de text

• La classe String ofereix molts mètodes amb els quals es poden manipular, de manera que en la immensa majoria de casos no caldrà fer un tractament individual de cada posició (per exemple, mitjançant estructures de repetició).
• Normalment, tots els esquemes d’ús i manipulació de cadenes de text es basen simplement en la invocació del mètode adient.
• Són immutables. La invocació d’un mètode mai modifica el valor inicial de la cadena de text original.
• Només es pot modificar la cadena original mitjançant l'assignació d'una nova.

Alguns mètodes de la classe String

Valor	Mètode	Descripció
caràcter	charAt(int index)	Retorna el valor del caràcter en la posició especificada
int	compareTo(String anotherString)	Compara dos strings lexicogràficament.
int	compareToIgnoreCase(String str)	Compara dos strings lexicogràficament ignorant diferències entre majúscules.
String	concat(String str)	Concatena aquest string al final del’original.
boolean	contains(CharSequence s)	Retorna cert si l’String conté aquesta seqüència de caràcters.
boolean	endsWith(String suffix)	Retorna cert si l’String finalitza amb aquest sufix.
boolean	equals(Object anObject)	Retorna cert si les dues cadenes són iguals.
boolean	equalsIgnoreCase(String anotherString)	Com l’anterior però ignorant diferències entre majúscules.
void	getChars(int srcBegin,int srcEnd,char[] dst, int dstBegin)	Copia els caràcters del String a la taula de caràcters.
int	indexOf(int ch)	Retorna l’índex de la primera aparició del caràcter especificat.
int	indexOf(String str)	Com l’anterior però amb un String
int	indexOf(int ch, int fromIndex)	Retorna l’índex de la primera aparició del caràcter especificat a partir de la posició especificada.
int	indexOf(String str, int fromIndex)	Com l’anterior però amb un String.
int	lastIndexOf(int ch)	Retorna l’índex de la última aparició del caràcter especificat.
int	lastIndexOf(String str)	Com l’anterior però amb un String.
int	lastIndexOf(int ch, int fromIndex)	Retorna l’índex de la última aparició del caràcter especificat a partir de la posició especificada.
int	lastIndexOf(String str, int fromIndex)	Com l’anterior però amb un String.
int	length()	Retorna la longitud.
boolean	regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)	Comprova si dos “trossos” dels String són iguals.
boolean	regionMatches(int toffset, String other, int ooffset, int len)	Comprova si dos “trossos” dels String són iguals.
String	replace(char oldChar, char newChar)	Retorna un nou String resultat de reemplaçar totes les ocurrències del antic caràcter pel nou.
String	replace(CharSequence target, CharSequence replacement)	Reemplaça cada substring original pel substring nou.
boolean	startsWith(String prefix)	Retorna cert si l’String comença amb aquest prefix.
boolean	startsWith(String prefix, int toffset)	Retorna cert si l’String comença amb aquest prefix a partir de la posició especificada.
String	substring(int beginIndex)	Retorna el substring que hi ha a partir de la posició especificada.
String	substring(int beginIndex, int endIndex)	Retorna el substring que hi ha entre les dues posicions.
char[]	toCharArray()	Converteix l’String en una taula de caràcters.
String	toLowerCase()	Converteix l’String a minúscules.
String	toUpperCase()	Converteix l’String a majúscules.
String	trim()	Retorna un String eliminant els espais en blanc a l’inici i al final.

Mètodes length, charAt i getChars

• Mètode length: determina la longitud de la cadena.
• Mètode charAt: obté el caràcter que es troba en una posició específica d’una cadena
• Mètode getChars: copia els caràcters del String a una taula de caràcters.

getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)

srcBegin: índex inicial de la cadena a partir de la qual es copiaran els caràcters.
srcEnd: índex que està en una posició més endavant de l’últim caràcter que es copiarà.
dst: taula on es copiaran.
dstBegin: índex inicial on es col·locaran els caràcters copiats.

• Exemple:

public class VarisString {

     public static void main(String args[]) {

       String s1 = "hola a tothom";
       char arrayChar[] = new char[4];
       System.out.printf("s1: %s", s1);
       System.out.printf("\nLongitud de s1: %d", s1.length());
       System.out.print("\nLa cadena invertida és: ");
       for (int compta = s1.length() - 1; compta >= 0; compta--) {
         System.out.printf("%s ", s1.charAt(compta));
       }
       s1.getChars(0, 4, arrayChar, 0);
       System.out.print("\nLa cadena de caràcters és: ");
       for (char caracter : arrayChar) {
         System.out.print(caracter);
       }
     System.out.println();
    }
   }

Comparació de cadenes

• Tots els caràcters es representen a l’ordinador com codis numèrics.
• Quan l’ordinador compara cadenes, en realitat compara els codis numèrics dels caràcters de les cadenes.

• Comparar amb ==

No compara les cadenes, sinó si la instancia es la mateixa. Así,

String cadena1 = new String("java");  
String cadena2 = new String("java");
if (cadena1 == cadena2)              // compara les instancies

Dos instancies diferents per tant la comparació avalua a False.

En canvi:

String cadena1 = "java";
String cadena2 = "java";
if (cadena1 == cadena2)

És la mateixa cadena, el compilador crea una única instancia i per tant avalua a True.

• Mètode equals: Compara la igualtat entre dues cadenes de caràcters. Distingeix majúscules de minúscules.
• Mètode equlasIgnoreCase: Compara la igualtat entre dues cadenes de caràcters. Ignora si les lletres són majúscules o minúscules.
• Mètode compareTo: Compara dos strings lexicogràficament. S'utilitza per a l'ordenació de cadenes de caràcters. Retorna 0 si les dues cadenes tenen el mateix contingut, negatiu si el String és menor que el paràmetre i positiu en el cas de que sigui major. La comparació és segons la taula de codis Ascii, per tant, les majúscules van abans que las minúscules i las últimes seran les lletres accentuades.
• Mètode regionMatches: Compara si certes parts de dues cadenes són iguals.

regionMatches(int toffset, String other, int ooffset, int len)

toffset: índex inicial a la cadena que invoca al mètode.
other: cadena de comparació.
ooffset: índex inicial a la cadena de comparació.
len: número de caràcters a comparar.

Existeix una versió amb cinc arguments: quan el primer argument és true el mètode ignora l’ús de majúscules i minúscules.

Compte!

• Java tracta a tots els literals de cadena amb el mateix contingut com a un sol objecte String que té moltes referències. Això ajuda a estalviar memòria.
• Quan es comparen referències amb == es poden produir errors lògics, ja que == compara les referències per determinar si es refereixen al mateix objecte, no si dos objectes tenen el mateix contingut. Si es comparen dos objectes idèntics (però separats ) amb == el resultat serà fals. Si s’han de comparar objectes per determinar si tenen el mateix contingut cal utilitzar el mètode equals.

• Exemple:

public class CompararCadenes{

     public static void main( String args[] ){

       String s1 = new String( "hola" );
       String s2 = "adeu";
       String s3 = "Bon aniversari";
       String s4 = "bon aniversari";

       System.out.printf("s1 = %s\ns2 = %s\ns3 = %s\ns4 = %s\n\n", s1, s2, s3, s4 );
       if ( s1.equals( "hola" ) )
         System.out.println( "s1 és igual a \"hola\"" );
       else
         System.out.println( "s1 no és igual a \"hola\"" );

       if ( s1 == "hola" )
         System.out.println( "s1 és el mateix objecte que \"hola\"" );
       else
         System.out.println( "s1 no és el mateix objecte que \"hola\"" );

       if ( s3.equalsIgnoreCase( s4 ) )
         System.out.printf("%s és igual a %s si s'ignora l'ús de majúscules/minúscules\n", s3, s4 );
       else
         System.out.println( "s3 no és igual a s4" );

       System.out.printf("\ns1.compareTo( s2 ) és %d", s1.compareTo( s2 ) );
       System.out.printf("\ns2.compareTo( s1 ) és %d", s2.compareTo( s1 ) );
       System.out.printf("\ns1.compareTo( s1 ) és %d", s1.compareTo( s1 ) );
       System.out.printf("\ns3.compareTo( s4 ) és %d", s3.compareTo( s4 ) );
       System.out.printf("\ns4.compareTo( s3 ) és %d\n\n", s4.compareTo( s3 ) );

       if ( s3.regionMatches( 0, s4, 0, 5 ) )
         System.out.println( "Els primers 5 caràcters de s3 y s4 coincideixen" );
       else
         System.out.println( "Els primers 5 caràcters de s3 y s4 no coincideixen" );

       if ( s3.regionMatches( true, 0, s4, 0, 5 ) )
         System.out.println( "Els primers 5 caràcters de s3 y s4 coincideixen");
       else
         System.out.println("Els primers 5 caràcters de s3 y s4 no coincideixen");
     }
   }

Si executem el resultat serà :

   s1 és igual a "hola"
   s1 no és el mateix objecte que "hola"
   Bon aniversari és igual a bon aniversari si s'ignora l'ús de majúscules/minúscules
   s1.compareTo( s2 ) és 7
   s2.compareTo( s1 ) és -7
   s1.compareTo( s1 ) és 0
   s3.compareTo( s4 ) és -32
   s4.compareTo( s3 ) és 32
   Els primers 5 caràcters de s3 y s4 no coincideixen
   Els primers 5 caràcters de s3 y s4 coincideixen

• Mètode startsWith: dues versions, en la més simple rep un paràmetre i indica si l’objecte String comença amb els caràcters indicats. La versió amb dos paràmetres rep un enter que especifica l’índex a partir d’on ha de començar la comparació.
• Mètode endsWith: només té una versió i determina si l’objecte String acaba amb els caràcters indicats.

• Exemple:

public class CadenaIniciFinal {

      public static void main(String args[]) {
     
        String cadenes[] = {"comença", "començant", "acaba", "acabant"};
        for (String cadena : cadenes) {
          if (cadena.startsWith("co")) {
            System.out.printf("\"%s\" comença amb \"co\"\n", cadena);
          }
        }
        System.out.println();
        for (String cadena : cadenes) {
          if (cadena.startsWith("enç", 3)) {
            System.out.printf("\"%s\" comença amb \"enç\" a la posició 3\n", cadena);
          }
        }
        System.out.println();
        for (String cadena : cadenes) {
          if (cadena.endsWith("nt")) {
            System.out.printf("\"%s\" acaba amb \"nt\"\n", cadena);
          }
        }
      }
    }

Si l’executem el resultat serà:

 
   "comença" comença amb "co" 
   "començant" comença amb "co" 
   "comença" comença amb "enç" a la posició 3 
   "començant" comença amb "enç" a la posició 3 
   "començant" acaba amb "nt" 
   "acabant" acaba amb "nt" 

Localització de cadenes i subcadenes

• indexOf: Retorna l’índex de la primera aparició del caràcter o string especificat.
• lastIndexOf: Retorna l’índex de la última aparició del caràcter o string especificat.

• Les versions amb índex, indiquen la posició des d'on començar la cerca.
• En cas de no trobar el caràcter o string, retornen -1.

public class MetodesIndexString {

     public static void main(String args[]) {

       String lletres = "abcdefghijklmabcdefghijklm";
       System.out.printf("'c' es troba a l'índex %d\n", lletres.indexOf('c'));
       System.out.printf("'a' es troba a l'índex %d\n", lletres.indexOf('a', 1));
       System.out.printf("'$' es troba a l'índex %d\n\n", lletres.indexOf('$'));
       System.out.printf("La última 'c' es troba a l'índex %d\n", lletres.lastIndexOf('c'));
       System.out.printf("La última 'a' es troba a l'índex %d\n", lletres.lastIndexOf('a', 25));
       System.out.printf("La última '$' es troba a l'índex %d\n\n", lletres.lastIndexOf('$'));
       System.out.printf("\"def\" es troba a l'índex %d\n", lletres.indexOf("def"));
       System.out.printf("\"def\" es troba a l'índex %d\n", lletres.indexOf("def", 7));
       System.out.printf("\"hola\" es troba a l'índex %d\n\n", lletres.indexOf("hola"));
       System.out.printf("La última ocurrència de \"def\" es troba a l'índex %d\n", lletres.lastIndexOf("def"));
       System.out.printf("La última ocurrència de \"def\" es troba a l'índex %d\n", lletres.lastIndexOf("def", 25));
       System.out.printf("La última ocurrència de \"hola\" es troba a l'índex %d\n", lletres.lastIndexOf("hola"));
     }
   }

Extracció de subcadenes

• substring(int beginIndex): Retorna el substring que hi ha a partir de la posició especificada.
• substring(int beginIndex, int endIndex): Retorna el substring que hi ha entre les dues posicions. El segon paràmetre especifica l’índex que està una posició més enllà de l’últim caràcter a copiar.

public class SubString {

     public static void main(String args[]) {

       String lletres = "abcdefghijklmabcdefghijklm";
       System.out.printf("La subcadena des de l ́índex 20 fins el final és \"%s\"\n",lletres.substring(20));
       System.out.printf("%s \"%s\"\n", "La subcadena des de l ́índex 3 fins a l'índex 6, per sense incloure el caràcter de la posició 6 és", lletres.substring(3, 6));
     }
   }

Concatenació de cadenes

• concat(String str): concatena dos objectes String i retorna un nou objecte String el qual conté els caràcters dels dosobjectes originals.

• L’expressió s1.concat(s2) forma una cadena, annexant els caràcter de la cadena s2 als caràcters de la cadena s1. Els objectes originals no són modificats.

Diversos mètodes

La classe String proporciona diversos mètodes que retornen còpies modificades de cadenes o que retornen taules de caràcters:

• replace(char oldChar, char newChar): Retorna un nou String resultat de reemplaçar totes les ocurrències del antic caràcter pel nou.
• replace(CharSequence target, CharSequence replacement): Reemplaça cada substring original pel substring nou.

• Si no hi ha ocurrències del primer argument, el mètode retorna la cadena original.

• toLowerCase(): Converteix l’String a minúscules.
• toUpperCase(): Converteix l’String a majúscules.

• trim(): Retorna un String eliminant els espais en blanc a l’inici i al final.
• La cadena original no es canvia.

• toCharArray(): Converteix l’String en una taula de caràcters.

public class VarisString2{
     
     public static void main( String args[] ){

       String s1 = new String( "hola" );
       String s2 = new String( "ADEU" );
       String s3 = new String( " espais " );
       System.out.printf( "s1 = %s\ns2 = %s\ns3 = %s\n\n", s1, s2, s3 );
       System.out.printf("Remplaçar 'l' amb 'L' a s1: %s\n\n", s1.replace( 'l', 'L' ) );
       System.out.printf( "s1.toUpperCase() = %s\n", s1.toUpperCase() );
       System.out.printf( "s2.toLowerCase() = %s\n\n", s2.toLowerCase() );
       System.out.printf( "s3 després de trim = \"%s\"\n\n", s3.trim() );
       char arregloChar[] = s1.toCharArray();
       System.out.print( "s1 com a taula de caràcters = " );
       for ( char caracter : arregloChar )
         System.out.print( caracter );
       System.out.println();
     }
   }

El resultat de l’execució és :

   s1 = hola
   s2 = ADEU
   s3 =  espais
 
   Remplaçar 'l' amb 'L' a s1: hoLa

   s1.toUpperCase() = HOLA
   s2.toLowerCase() = adeu

   s3 després de trim = "espais"

   s1 com a taula de caràcters = hola

El mètode valueOf

• String.valueOf(argument)): rep un argument de qualsevol tipus i el converteix en un objecte String.

Compte!!

• De forma predeterminada, Java tracta els literals enters com a tipus int i els literals en coma flotant com a tipus double. Si s’annexa la lletra L s’indica el compilador que ha de tractar-se com a long i si s’annexa f s’indica que ha de tractar-se com a float. En qualsevol dels casos la lletra pot estar en majúscules o en minúscules.

public class StringValueOf {

     public static void main(String args[]) {

       char taulaChar[] = {'a', 'b', 'c', 'd', 'e', 'f'};
       boolean valorBoolean = true;
       char valorCaracter = 'Z';
       int valorEnter = 7;
       long valorLong = 10000000000L; //L indica long
       float valorFloat = 2.5f; // f indica que 2.5 és un float
       double valorDouble = 33.333;
       Object refObjecte = "hola"; // assigna la cadena a una refèrencia Object
       System.out.printf("taula de valors char = %s\n", String.valueOf(taulaChar));
       System.out.printf("part de la taula char = %s\n", String.valueOf(taulaChar, 3, 3));
       System.out.printf("boolean = %s\n", String.valueOf(valorBoolean));
       System.out.printf("char = %s\n", String.valueOf(valorCaracter));
       System.out.printf("int = %s\n", String.valueOf(valorEnter));
       System.out.printf("long = %s\n", String.valueOf(valorLong));
       System.out.printf("float = %s\n", String.valueOf(valorFloat));
       System.out.printf( "double = %s\n", String.valueOf(valorDouble));
       System.out.printf("Object = %s\n", String.valueOf(refObjecte));
     }
   }

Mètode Split

• split(String separador): retorna una taula de cadenes de text on a cada posició conté un tros de la cadena original usant com a divisor separador.

• El valor de separador ha de ser una cadena de text.

• Exemple:

• Exemple: invertir l’ordre de les paraules d’una frase.

import java.util.Scanner;
   //Programa que inverteix l'ordre de les paraules d'una frase.

   public class InverteixOrdreParaules {

     public static void main(String[] args) {
     
       Scanner lector = new Scanner(System.in);
       System.out.println("Escriu una línia de text qualsevol i pitja retorn:");
       String text = lector.nextLine();
       //Dividim la frase en paraules, separades per espais.
       String[] paraules = text.split(" ");
       System.out.println("El text invertit és:");
       //Imprimim les paraules en ordre invers.
       for (int i = paraules.length - 1; i >= 0; i--) {
       System.out.print(paraules[i]);
       //El mètode split elimina el text de separació (en aquest cas, els espais)
       System.out.print(" ");
     }
     System.out.println();
   }
}