Es tracta, doncs, de delimitar els caràcters que componen la cadena per una parella de cometes dobles "".

La classe java.lang.String conté els mètodes necessaris per a...

• determinar la longitud (nombre de caràcters) d'una cadena
  
  
• examinar individualment els caràcters que conté
  
  
• comparar cadenes lexicogràficament
  
  
• buscar i extreure subcadenes d'una cadena
  
  
• transformar tots els seus caràcters a majúscules o a minúscules
  
  
• ...i d'altres mètodes per executar procediments ben diversos.

A més, com ja has vist en l'exemple anterior, es pot fer servir l'operador "+" per a enganxar dues cadenes i formar-ne una de sola.

Tot seguit tens uns quants exemples de la sintaxi adequada:

• public int length(). Retorna la longitud de la cadena, és a dir, el nombre de caràcters que conté. Així:
  
  

  String cadena="Això és una cadena"; int n=cadena.length();

  
  posa un 18 a la variable n.

• public String substring(int inici). Extreu una subcadena que té com a primer caràcter el que ocupava el lloc inici a la cadena original i , com a darrer, el darrer de la cadena. Així, a
  
  

  String cadena="Això és una cadena"; String subcadenaU=cadena.substring(2); String subcadenaDos=cadena.substring(5);

  
  resulta subcadenaU="xò és una cadena " i subcadenaDos="és una cadena".
  
  Fes atenció a que...
  
  
  • inici no superi la longitud de la cadena, perquè et trobaries amb una excepció del tipus StringIndexOutOfBoundsException que t'aturaria el programa!
    
    
  • La primera posició correspon al 0, la segona a l'1, etc. Per aquesta raó cadena.substring(2) comença a la x de "Això...

• public String substring(int inici,int final). Extreu una subcadena que té com a primer caràcter el que ocupava el lloc inici a la cadena original i , com a darrer, el que ocupava el lloc final-1 a la inicial. Així, a
  
  

  String cadena="Això és una cadena"; String subcadenaU=cadena.substring(2,9); String subcadenaDos=cadena.substring(5,6); String subcadenaTres=cadena.substring(4,5); String subcadenaQuatre=cadena.substring(1,1);

  
  resulta subcadenaU="xò és u", subcadenaDos="é", subcadenaTres=" " i subcadenaQuatre="". Novament, vigila que ni inici ni final superin la longitud de la cadena, perquèm, com en el cas anterior, et trobaries amb una excepció StringIndexOutOfBoundsException!

• public String toUpperCase() i public String toLowerCase() retornen, respectivament, cadenes que resulten del pas a majúscula i a minúscula dels caràcters de la cadena original:
  
  

  String cadena="Títol: El Rector de Vallfogona"; String cadena_A=cadena.toUpperCase(); String cadena_A=cadena.toLowerCase();

  
  El resultats són: cadena_A="TÍTOL: EL RECTOR DE VALLFOGONA" i cadena_B="títol: el rector de vallfogona".
  

• public boolean equals(Object unObjecte). Retorna true si, i només si, l'objecte unObjecte és una instància de la classe String que representa exactament la mateixa successió de caràcters. Exemple:
  
  

  String cadena="Balsareny"; String cadena_A="Gironella"; String cadena_B="BalSareny"; String cadena_C="Balsareny"; boolean laA=cadena.equals(cadena_A); boolean laB=cadena.equals(cadena_B); boolean laC=cadena.equals(cadena_C);

  
  Resulta: laA=false, laB=false i laC=true.
  
  És totalment aconsellable fer servir la formulació anterior per definir els booleans i, en canvi, és completament desaconsellable plantejar-ho amb la sintaxi següent:
  
  

  boolean laA=(cadena==cadena_A); boolean laB=(cadena==cadena_B); boolean laC=(cadena==cadena_C);

  
  perquè, malgrat que dues cadenes continguin exactament els mateixos caràcters, són objectes diferents, és a dir, a la memòria, resideixen en llocs diferents i tenen, probablement, identificadors, també diferents. Ens podem trobar (depèn del sistema i de la manera com hagin estat construïdes les cadenes) que Java ens digui que "Tres quarts de quinze"=="Tres quarts de quinze" és false!

• public boolean equalsIgnoreCase(String unaCadena). Retorna true si, i només si, la cadena unaCadena representa exactament la mateixa successió de caràcters, però fent cas omís de si són majúscules o minúscules:
  
  

  String cadena="Balsareny"; String cadena_A="Gironella"; String cadena_B="balSareny"; String cadena_C="Valsareny"; boolean laA=cadena.equalsIgnoreCase(cadena_A); boolean laB=cadena.equalsIgnoreCase(cadena_B); boolean laC=cadena.equalsIgnoreCase(cadena_C);

  Resulta: laA=false, laB=true i laC=false. Ep! Java no passa pas de l'ortografia!

• public int compareTo(String unaCadena). Fa la comparació lexicogràfica de la cadena propietària del mètode (l'ordre d'un diccionari) amb la cadena unaCadena. El resultat és un nombre negatiu si unaCadena li és posterior, i positiu si unaCadena li és anterior. Si les dues cadenes són iguals, aleshores retorna un zero:
  
  

  String cadena="Balsareny"; String cadena_A="Gironella"; String cadena_B="Avià"; String cadena_C="Balsareny"; int laA=cadena.compareTo(cadena_A); int laB=cadena.compareTo(cadena_B); int laC=cadena.compareTo(cadena_C);

  
  Resulta: laA=<nombre negatiu>, laB=<nombre positiu> i laC=0.

Pots trobar més mètodes i les explicacions a la documentació de la classe java.lang.String.

A la pràctica 2 del mòdul 4 t'expliquem idees generals sobre la documentació dels projectes de Java i com la podràs confegir per als teus projectes. Ara bé, les classes públiques elaborades pels programadors de Sun Microsystems, com és ara la java.lang.String, tenen documentacions excel·lents que ens faciliten tots els detalls que ens permetran importar-les i aprofitar-les per als nostres projectes. Pots veure-ho si enllaces amb la pàgina web "oficial" de Java; per a la classe String, la documentació es troba a

http://java.sun.com/j2se/1.4.2/docs/api/java/lang/String.html

per a la darrera versió oficial del programa quan s'han redactat aquests materials, a saber, J2SE 1.4.2 SDK. Allà trobaràs molts més mètodes i més explicacions.

• public static String valueOf(boolean b). Retorna la representació com a cadena del valor de veritat de la variable boolean b:
  
  

  boolean b_1=(2==3); boolean b_2=(3==3); String cadenaB_1=String.valueOf(b_1); String cadenaB_2=String.valueOf(b_2);

  
  Aleshores, b_1=false, b_2=true, cadenaB1="false" i cadenaB_2="true". Observa que, com que el mètode és static, cal cridar-lo tot posant com a prefix el nom de la classe, "String", no pas el de cap objecte de la classe String. (Mira la corresponent explicació a la pràctica 5 del mòdul 2)

• public static String valueOf(int n). Retorna la representació com a cadena del valor numèric de la variable int n:
  
  

  int n_1=-436; int n_2=2004; String cadenaN_1=String.valueOf(n_1); String cadenaN_2=String.valueOf(n_2);

  
  Resulta n_1=-436, n_2=2004 i cadenaN_1="-436", cadenaN_2="2004".
  
  Observa que n_1+n_2=1568, però cadenaN_1+cadenaN_2="-4362004". Igualment, n_1-n_2=-2440, però cadenaN_1-cadenaN_2 no té sentit.
  
  Observa, a més, que aquest mètode té el mateix nom que l'anterior: valueOf, però el paràmetre és ara int n, en lloc de boolean b. Això és, precisament, la sobrecàrrega de mètodes.

• public static String valueOf(double db), public static String valueOf(float fl)i public static String valueOf(long lng) fan la mateixa feina, però per a valors numèrics dels tipus double, float i long respectivament. (Més sobrecàrrega!)
  

Les conversions inverses (de String a int, de String a float, etc.) no són, com és lògic, mètodes de la classe String, sinó que són mètodes static de les corresponents classes Integer, Float, etc:

• static int Integer.parseInt(String string)
  
  
• static float Float.parseFloat(String string)
  
  
• static double Double.parseDouble(String string).

• Es comença per declarar la variable d'instància int maxim:
  
  

  private int maxim;

  
  que contindrà el nombre màxim que la classe comprovarà per veure si és de quadrat automòrfic o no.

• Finalment, hi ha el mètode public void llistarAutomorfic (), el qual analitza els nombres de 0 a elMaxim, i imprimeix els que siguin de de quadrat automòrfic.
  
  
  • A la primera línia d'aquest mètode s'imprimeix una capçalera per a la taula de nombres de quadrat automòrfics que imprimirà després. Observa l'ús del caràcter de tabulació "\t":
    
    

    System.out.println("\tNombre:\tQuadrat:");

    
    
  • Aleshores comença una estructura for(...) {...} per fer l'anàlisi de tots i cadascun dels nombres de 0 a elMaxim. La primera acció és convertir aquests nombres i els seus quadrats a cadenes de caràcters:
    
    

    String valor=String.valueOf(i);                 String quadrat=String.valueOf(i*i);

    
    
  • Després se'n demana la longitud, és a dir el nombre de caràcters (xifres, en aquest cas) de cadascuna de les dues cadenes:
    
    

    int longValor=valor.length();                 int longQuadrat=quadrat.length();

    
    
  • Ara cal mirar les últimes xifres de la cadena quadrat per poder-les comparar amb la cadena valor completa. Es tracta d'extreure'n la subcadena que comença just a la posició longQuadrat-longValor:
    
    

    StringperComparar=              quadrat.substring(longQuadrat-longValor);

• Ja està tot a punt. Es tracta de mirar si la cadena valor i la cadena perComparar són iguals:
  
  

  if (valor.equals(perComparar)) {

  
  Si ho són, que vol dir que i (la variable comptador del bucle, que s'ha transformat a cadena valor pel mètode String.valueOf(i)) és de quadrat automòrfic, imprimeix les cadenes amb les xifres del nombre i les del seu quadrat:
  
  

  System.out.println("\t"+valor+                                            "\t"+quadrat);

  
  amb els corresponents caràcters "\t" de tabulació, per tal d'aconseguir una taula clara i fàcilment legible.