La classe String



Scaricare 145.91 Kb.
24.01.2018
Dimensione del file145.91 Kb.

La classe String
In Java, le stringhe non sono “pezzi di memoria” con dentro dei caratteri, come in C: sono oggetti appartenenti alla classe String


  • Una stringa Java rappresenta uno specifico valore e come tale è immodificabile: una String non è un contenitore!

  • Se occorre un contenitore (variabile di tipo stringa- da modificare) esiste StringBuffer

  • L’operatore + denota la concatenazione: "ciao" + " mondo\n" NB: la concatenazione è fatta a tempo di compilazione, quindi non introduce inefficienze


COSTANTI String



  • Le costanti String possono essere denotate nel modo usuale: "ciao" "mondo\n"

  • Quando si scrive una costante String tra virgolette, viene creato implicitamente un nuovo oggetto di classe String, inizializzato a tale valore.

  • Una costante String non può eccedere la riga: quindi, dovendo scrivere stringhe più lunghe, conviene spezzarle e concatenarle con +.


ALCUNE RIFLESSIONI (1/2)

Alla luce di quanto detto sulle costanti stringa:

quanti oggetti String vengono creati per una stessa costante?
String s1 = "ciao";

String s2 = "ciao";

Si crea un solo oggetto String
Che risultato darà il test s1 == s2 ?

Stringhe uguali s1 e s2 puntano alla stessa area di memoria - stesso oggetto


cosa succede se ci sono concatenazioni?
String s3 = "anna" + "maria";

String s4 = "annamaria";


Che risultato darà il test s3 == s4 ? Stringhe uguali.

s3 e s4 puntano alla stessa area memoria. Stessa costante di stringa


ALCUNE RIFLESSIONI (2/2)

E se utilizziamo variabili?

quanti oggetti String vengono creati ?

String s5 = "anna";

String s6 = "maria";

String s4 = "annamaria";


Vengono creati 3 oggetti
Che risultato darà il test s5+s6 == s4 ? Stringhe diverse poiché diverse sono le locazioni delle variabili s4 con le variabili s5+s6
È uguale al caso precedente?

NO!! Ora sono variabili diverse con diversa locazione; per verificare il contenuto occorre usare non l’operatore di == ma metodi specifici (uquals)


STRINGHE IN JAVA


  • Le stringhe Java non sono array di caratteri

  • Sono oggetti concettualmente diversi

    • non si applicano gli operatori degli array!

    • in particolare, non si applica il classico [ ]

  • Per selezionare il carattere i-esimo si usa il metodo charAt():

String s = "Nel mezzo del cammin";

char ch = s.charAt(4);


La classe String definisce decine di metodi: per i dettagli si più avanti e la documentazione

Le stringhe sono considerate oggetti (proprietà più metodi), anche se hanno caratteristiche di tipo primitivo. In Particolare una stringa è un oggetto della classe String. Ogni stringa delimitata dai segni “ “ è un oggetto della classe String.

In questo contesto (classe String ) le stringhe sono considerate immutabili, cioè non modificabili. Una volta creata non si può modificare. È possibile creare un’altra stringa che contiene caratteri diversi , ma la classe String non possiede metodi per modificare le stringhe.
Come si dichiara e si assegna un valore ad un oggetto della classe String?
La stringa può essere create in due modi:


  1. scrivendola direttamente nel codice, trattandola cioè come dato primitivo: String s="pippo";

  2. utilizzando il costruttore new della classe String, String s=new String ("pippo")


con 1 stessa area di memoria stessa stringa costante di uguale valore:

String s1="pippo";

String s2="pippo";


S2


“PIPPO”





S1

Stessa costante stringa, stessa area di memoria
con 2 diversi oggetti - diversa area di memoria
String s1=new String("pippo");

String s2=new String("pippo");



S1

S2

“PIPPO”


“PIPPO”



Quando si scrive String s1=”AAA” si ottiene


S1

“AAA”


Se dopo si scrive s1=”BBB” si ottiene


S1

“BBB”

Non si modifica il valore precedente, ma si costruisce uno nuovo e la garbage collection cancella il vecchio(“AAA”


Esempi:

String s1; //dichiaro s1

s1="AAA"; //assegno valore ad s1

String s2="AAA"; //dichiaro e assegno valore oggetto string

System.out.println("1."+ s1+" "+s2);//stampa AAA e AAA

String s3=new String ("DDD"); //creo oggetto String e assegno valore

/* inserisce in s2 la stringa contenuta in s3 - in pratica copia il contenuto di s3 in s2*/

s2=new String (s3);

System.out.println( "2."+ s1+" "+s2);//stampa AAA e DDD

s1=s2;// ora s1 punta a s2, se s2 fosse possibile modificarla, la modifica di

//s2 si riflette su s1 (vedi StringBuffer);non è una copia di s2 a s1 !!
System.out.println( "3."+ s1+" "+s2); //stampa DDD e DDD

s2=new String ("CCC");//creo nuova stringa nome s2, la vecchia s2 viene

//eliminata, s1 continua a puntare a DDD

System.out.println( "4."+ s1+" "+s2); //stampa DDD e CCC

s1=s2;

System.out.println( s1+" "+s2); //stampa CCC e CCC, s1 punta a s2


String hello = "Hello, World!";

int lung = hello.length(); //fornisce lunghezza stringa

System.out.println(lung); // stampa 13

Estrazione di una sottostringa: str.substring(start, End)

Restituisce la sottostringa di str a partire dalla posizione start (incluso) fino a End - 1.



Attenzione: il primo carattere di una stringa ha posizione 0, e l'ultimo ha posizione str.length()-1. In pratica l’ultimo carattere non viene estratto.


H

e

l

l

o

,



W

o

r

l

d

!

carattere

0

1

2

3

4

5

6

7

8

9

10

11

12

posizione

String saluto = "Hello, World!";


System.out.println(saluto.substring(7,12)); // stampa World
Concatenazione di Stringhe
La concatenazione di due stringhe "Mario" e "Rossi" è la stringa "MarioRossi".
L'operatore di concatenazione in Java è '+'.

String nome = "Mario";


String cognome = "Rossi";
System.out.println(nome + cognome); //stampa MarioRossi
System.out.println(nome + " " + cognome); //stampa Mario Rossi
L'operatore '+' è sovraccaricato (overloaded): può essere applicato sia a numeri che a stringhe.

Cosa succede se si mischiano numeri e stringhe in una espressione?


System.out.println("Rai" + 3); //stampa Rai3
System.out.println(3 + 4 + 5); //stampa 12
System.out.println("" + 3 + 4 + 5); //stampa 345
System.out.println(4 + 5 + "pippo"); //stampa 9pippo


Confronto tra stringhe

Due tipi di confronti tra due stringhe:



  1. sono uguali?

  2. quale stringa viene prima in ordine lessicografico?

La classe String fornisce i metodi necessari: equals e compareTo

  • s1.equals(s2) restituisce:

    • true se s1 e s2 sono uguali,

    • false altrimenti.

  • s1.compareTo(s2) è:

    • un valore minore di 0 se s1 precede s2 lessicograficamente,

    • un valore maggiore di 0 se s2 precede s1,

    • il valore 0 se sono uguali.

Con la libreria import static java.lang.System.* in testa al programma si può evitare di indicare la classe System nelle istruzioni di input - output

Confronto fra Stringhe

String s1 = "Ciao";

/*legge da tastiera*/

Scanner tastiera = new Scanner(System.in);//creo oggetto stream

String s2 = tastiera.nextLine();//acquisisce intere righe

boolean b = s1.equals(s2); // b vale true se inserito ciao

int c = "cargo".compareTo("cathode");// c vale -2

c = "cazgo".compareTo("cathode");// c vale >0

c = " cathode ".compareTo("cathode");// c vale >0


Attenzione: Non usare "==" per confrontare stringhe: può dare risultati inattesi.

String s1 = "Ciao";


String s2 = "Ciao";
boolean b = (s1 == s2); //b vale true

String s1 = "Ciao";


String s2 = tastiera.nextLine();
boolean b = (s1 == s2); //Input: Ciao
b vale false!!!
Conversione tra numeri e stringhe
Da numero a stringa: concatenazione con la stringa vuota
String s=””+12;
Da stringa a numero: metodi Integer.parseInt() o Double.parseDouble()

int riv = 1789;

String riv_string = riv;//NO! Tipo incompatibile

String riv_string = "" + riv; // converte in stringa il numero

double pi = "3.1415926"; // NO! Tipo incompatibile

double pi = Double.parseDouble("3.1415926");//converte stringa in numero

double pi1 = Double.parseDouble(riv_string);// converte stringa in numero
Se dobbiamo convertire numeri (interi o reali) da stringhe occorre utilizzare i corrispondenti metodi

Integer.parseInt(String)

Double.parseDouble(String)

Float.parseFloat (string)



La classe String
La distribuzione di Java contiene diverse classi per la manipolazione di stringhe, cioè sequenze di caratteri. Oltre a rivisitare la classe String, vedremo le classi StringBuffer e StringTokenizer.
Come spiegato precedentemente, le istanze di String sono stringhe non modificabili.

Ad esempio String str= new String("pippo");


non posso modificare il singolo carattere (non ci sono metodi), per trasformare la stringa "pippo" in "poppo", occorre creare un nuovo oggetto:
str=new String("poppo";
Ad esempio con il segmento di codice:
String str=new String("pippo");

str=new String("poppo");

System.out.println(str);
Produce come output "poppo"
Istanze di String si possono creare con la solita notazione, come tipo primitivo (sequenza di caratteri tra doppi apici, es. "Ciao Mondo!") o con i costruttori della classe, tra cui
/* crea una stringa vuota */

new String( )


/* crea una stringa che contiene i caratteri dell'array value */

String (char[] value)


Ad esempio, le seguenti istruzioni sono equivalenti:

String str = "abc";

char data[] = {'a', 'b', 'c'};

String str = new String(data);

String str= new String (“abc”);
/* trasforma una sequenza di caratteri non modificabile tipo String in una modificabile tipo StringBuffer (vedi più avanti)*/

String (StringBuffer buffer)


Conversione da oggetto String a oggetto StringBuffer
String s10="YYYYYY";// oggetto String

StringBuffer strA=new StringBuffer (s10);//da String ad oggetto StringBuffer


Classe String: metodi
La classe String comprende metodi:

  • per esaminare i singoli caratteri della sequenza,

  • per confrontare stringhe (in modo case sensitive oppure no),

  • per cercare o estrarre sottostringhe di una stringa,

  • per creare copie di stringhe, anche cambiando il case,

  • per convertire dati di qualunque tipo in stringhe (statici).

Alcuni metodi utili:

equals

/* restituisce true se le due stringhe sono uguali */

boolean equals (Object obj). Esempio:
String strA="Ciao";

String strB="Ciao";

boolean esito=strA.equals(strB) ;//notazione dot per invocare metodo

if(esito ){

System.out.println("sono uguali confronto con equals");

}

else{



System.out.println("Sono diverse confronto con equals");

}
Osservazione sull’utilizzo e notazione dei metodi.


Ricordiamo che nella OOP una classe un’astrazione per un gruppo di oggetti che condividono le stesse caratteristiche (proprietà) e le stesse funzionalità (metodi). Col termine classe si individua una categoria che permette di descrivere le componenti di un particolare oggetto. Una classe definisce le variabili ed i metodi di un insieme di oggetti. Tali oggetti vengono creati dinamicamente e vengono detti istanze di tale classe. In un certo senso la classe rappresenta un oggetto astratto. È possibile definire sia variabili che metodi di classe. Nel primo caso tali variabili sono condivise tra tutti gli oggetti che appartengono alla classe, per cui modifiche effettuate da un oggetto sulle variabili di classe sono viste da tutti gli altri oggetti della stessa classe.
La classe può essere vista come un contenitore per la definizione delle variabili e per i metodi associati con gli oggetti.
Nel contesto della programmazione ad oggetti, una classe dovrebbe quindi limitarsi a definire che struttura avranno gli oggetti che da essa saranno istanziati.
"Istanziare" è il termine object oriented che si usa in luogo di "creare fisicamente", ed il risultato di un’istanza viene detto "oggetto".
La classe serve per definire come saranno fatti gli oggetti. L’oggetto rappresenta una realizzazione fisica della classe.
Quindi la classe è l’insieme delle proprietà dell’oggetto e metodi (le operazioni che posso fare)

Ricordare che dato un oggetto appartenente ad una classe, per invocare le proprietà ed i metodi della classe su quello oggetto si ricorre alla seguente notazione dot:


nomeoggetto.metodo

nomeoggetto.proprietà


Nel nostro caso stiamo trattando solo dei metodi che classe String che Java mette ha disposizione (quindi non delle proprietà della classe). Per invocare i metodi di questa classe occorre usare la notazione dot.
Il metodo equals ha la seguente sintassi:
boolean equals (Object obj)
dove Boolean è ritorno del metodo mentre l’argomento è il tipo di dato in Java
Un esempio di sintassi di equals per invocare tale metodo è:
boolean esito=strA.equals(strB)
Di seguito la notazione per invocare i metodi per gestire le stringhe sarà la notazione dot
equals

/* restituisce true se le due stringhe sono uguali */

boolean equals (Object obj). Object è un qualsiasi oggetto, anche un vettore. In questo caso verifica se il riferimento, non il contenuto, è uguale. Se il parametro è una stringa allora confronta se le due stringhe sono uguali.

Caso vettori


................

for(i=0;i

vett2[i]=vett[i];

for (i=0;i

System.out.println("valori vettore intero"+i+"="+vett2[i]);

boolean esito=vett2.equals (vett2);//true, con vett2 e vett allora è false


Caso stringheEsempio:
String strA="Ciao";

String strB="Ciao";

boolean esito=strA.equals(strB) ;//notazione dot per invocare metodo

if(esito ){

System.out.println("sono uguali confronto con equals");

}

else{



System.out.println("Sono diverse confronto con equals");

}

equalsIgnoreCase

/ come equals, ignorando differenza tra maiuscole e minuscole */

boolean equalsIgnoreCase (String str). Esempio:


String strC="pippo";

String strD="PIPPO";

boolean esito1=strC.equalsIgnoreCase(strD) ;

if(esito1 ){

System.out.println("sono uguali confronto con ignorecase");

}

else{



System.out.println("Sono diverse confronto con ignorecase");

}

compareTo



  • s1.compareTo(s2) è:

    • un valore minore di 0 se s1 precede s2 lessicograficamente,

    • un valore maggiore di 0 se s2 precede s1,

    • il valore 0 se sono uguali.

/*confronta le stringhe rispetto all'ordinamento lessicografico */

int compareTo (String str). Esempio:
String mStrUno = new String("Prova");

String mStrDue = new String("Prova");

int esito2=mStrUno.compareTo(mStrDue);

if( esito2==0 )

{

System.out.println("Sono Uguali");



}

else


{

System.out.println("Sono Diverse");

}
length ()

/* restituisce la lunghezza della stringa; si applica anche a oggetti appartenenti alla classe StringBuffer, vedi più avanti*/

int length ().Esempio:
StringBuffer strA=new StringBuffer ("sss");//oggetti StringBuffer

int lun=strA.length();

System.out. println("lunghezza: "+lun);//valore3

String str=new String ("sssd");//oggetti String

lun=str.length();

System.out. println("lunghezza: "+lun);//valore4


charAt ()

/* restituisce l'i-esimo carattere contenuto nella stringa: i deve essere compreso tra 0 e la lunghezza della stringa )

char charAt (int i) */.esempio:
for (int i=0;i

System.out.print((s.charAt(i)));

System.out.print("\n");
substring ()

/* restituisce la sottostringa contenente i caratteri dalla posizione i alla posizione j-1, cioè j è escluso. i è indice di partenza, il secondo è l’indice a cui si vuole arrivare escludendo il valore j*/

String substring (int i, int j). Esempio:
st3="Mauro Filipponi";

System.out.println("estrae sotto stringhe da \"Mauro Filipponi\"");

System.out.println(st3.substring(0,5));\\estrae Mauro

String st4=st3.substring(6);// estrae "Filipponi ed assegna a st4";




concat

/* restituisce la concatenazione fra due stringhe*/

String concat (String str).Esempio:
S1=”Ciao”:

S2=” Pippo!”;

String s3=s1.concat(s2);

System.out(s3); //output Ciao Pippo!



indexOf

/* restituisce l'indice da cui parte la prima sottostringa uguale a str; restituisce -1 se non esiste */

int indexOf (String str). Esempio:
String s1="Mario rossi";

int pos=s1.indexOf ("rio"); //restituisce 2

pos=s1.indexOf ("zia"); //restituisce -1

/* conta vocali*/

int nVocali=0;

String vocali="aAeEiIoOuU";

String frase="oggi e' una bella giornata!";

for (int i=0;i

pos=vocali.indexOf(frase.substring(i,i+1));

if(pos !=-1)

nVocali++;

}//chiude for

System.out.println("vocali: "+nVocali);//11 vocali
Alternativamente, usando charAt)

nVocali=0;

for ( int i=0;i

pos=vocali.indexOf(frase.charAt(i));

if(pos !=-1)

nVocali++;

}//chiude for

System.out.println("vocali: "+nVocali);//11 vocali


valueOf

/* restituisce la rappresentazione come stringa dell'argomento. E' definito per ogni tipo di dati Java, grazie all'overloading. E' un metodo statico. */

static String valueOf( arg). Esempio:

String s;int k=10;

s= String.valueOf(10);//s contiene 10
alternativamente

s=""+k;
startsWith - endstWith

/* verifica se una stringa inizia con un prefisso o termina con un suffisso*/

String startsWith (String)

String endstWith (String)


String s1="Mario Rossi";

boolean b=s1.startsWith("Ma");

System.out. println("esito: "+b);//true

b=s1.endsWith("ssi");

System.out. println("esito: "+b);/true
replace

/* restituisce una stringa ottenuta sostituendo il carattere vecchioCar con uno nuovo, nuovoCar oppure sostituendo una sottostringa con una sottostringa nuova*/

String replace (vecchioCar, nuovoCar)

String replace (vecchiaSottoStringa, nuovaSottoStringa)

String st1="Mario Rossi";

st1=st1.replace ('R','D');

System.out.println("metodo replace: "+st1);
Oppure
String st1="Mario Rossi";

st1=st1.replace ("ari","arc");

System.out.println("metodo replace: "+st1);//Marco Rossi
Attenzione che con replace si modifica la stringa originale creandone una nuova. Quindi nella condivisione di oggetti viene meno il riferimento comune. Questo lo si può verificare con il frammento di codice:
String st1=new String("Mario Rossi");

String st2;

st2=st1;//st2 punta alla stringa “Mario Rossi”

st1=st1.replace ("ario","arco");//modifico st1

System.out.println("metodo replace: "+st1+" "+st2); //Marco Rossi Mario Rossi
Ora st2 punta sempre alla stringa “Mario Rossi” mentre st1 punta ad una stringa diversa (“Marco Rossi”)
toLowerCase -toUpperCase

/* trasforma caratteri da maiuscolo a minuscolo e viceversa*/

String toLowerCase ( )

String toUpperCase ( )


st1="mario rossi";

st1=st1.toUpperCase ();

System.out.println("tutte maiuscole: "+st1);

st1="MARIO ROSSI";

st1=st1.toLowerCase ();

System.out.println("tutte minuscole: "+st1);//mario rossi



La classe StringBuffer
La classe StringBuffer è simile a String, ma le sue istanze sono stringhe modificabili nel contenuto e nella lunghezza.
Sia dato ad esempio un oggetto della classe String
String str= new String("pippo");
non posso modificare il singolo carattere (non ci sono metodi), per trasformare la stringa "pippo" in "poppo", occorre creare un nuovo oggetto:
str=new String("poppo");
Ad esempio con il segmento di codice:
String str=new String("pippo");

str=new String("poppo");

System.out.println(str);//output "poppo"
Questo vale per la classe String.
Per creare oggetti modificabili si ricorre alla classe StringBuffer.

StringBuffer strA

strA= new StringBuffer (“pippo”);
oppure

StringBuffer strA=StringBuffer (“pippo”);


Dichiarazione stringhe per la classe StringBuffer:


La stringa può essere creata soltanto utilizzando il costruttore new della classe StringBuffer
StringBuffer strAs=new StringBuffer ("pippo")
La classe ha i seguenti costruttori:

/* crea uno StringBuffer vuoto, di 16 caratteri */

StringBuffer (.).Esempio:
StringBuffer testo = new StringBuffer();

/* contenuto iniziale: str di tipo string. Consente di usare indirettamente i costruttori della classe String */

StringBuffer (String str). Esempio:
String s1="YYYYYY";// oggetto String

StringBuffer strA=new StringBuffer (s1);//utilizza oggetto String e lo trasforma in oggetto StringBuffer



Esempi creazione oggetti classe StringBuffer
String s="AAAAAAAA";//String s non modificabile

StringBuffer strA=new StringBuffer("pippo");//dichiarazione e creazione oggetto StringBuffer (modificabile)

//strA="AAAAAAA";//NO!!! così non si assegna

//strA=s;//NO!!così non si assegna

strA=new StringBuffer(s);//assegno ad strA il contenuto di String s

/*in pratica passo da oggetto String (non modificabile) ad oggetto StringBuffer modificabile*/

System.out.println("risultato: "+ strA);//AAAAAAAA
StringBuffer strB;//dichiaro strB

strB= new StringBuffer ("pippo");//creo nuova stringa e assegno valore

System.out.println("Valore stringBuffer: "+ strB);
/* assegno il riferimento di strB a strA, ogni modifica di strB viene vista da strA e viceversa*/

strA=strB;

/* modifico il valore di strB e poi strA: le modifiche sono viste da entrambi*/

strA.append(" e pluto");//modifico strA con metodo append(vedi dopo)

System.out.println("risultato: "+ strA+" "+ strB);

strB.append(" e pluto1");

System.out.println("risultato: "+ strA+" "+ strB);

output video



N.B. con

String s1=”pippo”;//dichiaro oggetto s1

StringBuffer strA=new StringBuffer(s1);//nuovo oggetto strA (contenuto di s1)


Passo da un oggetto di classe String (non modificabile)ad oggetto StringBuffer (modificabile)
Con:

StringBuffer strB=new StringBuffer(“pippo”);

String s2=new String(strB);//nuovo oggetto s2 (contenuto strB)
Passo da un oggetto di classe StringBuffer (modificabile)ad oggetto String (non modificabile)

Classe StringBuffer: metodi
La classe StringBuffer contiene metodi:


  • per inserire una sequenza di caratteri nel mezzo o alla fine del buffer,

  • per cancellare o rimpiazzare uno o più caratteri del buffer,

  • per invertire il contenuto del buffer,

  • per trasformare il contenuto in un oggetto non modificabile (di tipo String).

ciascun metodo non restituiscono oggetti (infatti i metodi hanno void come valore di ritorno). Questo vuol dire che modificano l'oggetto su cui sono invocati, non restituiscono un nuovo oggetto. Infatti, negli esempi, a sinistra non c'è mai operatore =, cioè Lvalue. Esempio di descrizione del metodo
StringBuffer append ( arg)
Dove StringBuffer davanti al metodo non è il ritorno ma l’oggetto su cui invocare il metodo!!!.

Alcuni metodi:

append

/* concatena la rappresentazione testuale dell'argomento al proprio contenuto; definito per qualunque di dati Java */

StringBuffer append ( arg). Esempio:
StringBuffer strA = new StringBuffer();// stringa modificabile

StringBuffer strB=new StringBuffer("pippo");//SI!!

StringBuffer strA="pippo";//NO!!!

strB.append(" e pluto");//append a strB la stringa " e pluto"

int lun=strB.length (); //output 13

System.out.println("lunghezza stringa dopo append: "+ lun);




insert

/* inserisce la rappresentazione testuale dell'argomento a partire dalla posizione offset; definito per qualunque di dati Java */

StringBuffer insert (int offset, arg). Esempio:
strA=new StringBuffer ("AAAAAAAAAAAAA");

strA.insert(4,"XX");//offset uguale a 4

System.out.println ("stringa dopo insert : " + strA); //AAAAXXAAAAAAAAA
setCharAt

/* modifica il carattere presente nella posizione specificata con il carattere Car la sottostringa da start ad end con str */

StringBuffer setCharAt(posizione,Car). Esempio:
strA=new StringBuffer ("AAAAAAAAAAAAA");

strA.setCharAt(2,'X');//inizia con 2

System.out.println ("stringa dopo modifica: " + strA);// AAXAAAAAAAAAA

delete

/* cancella dalla sequenza la sottostringa tra start e end */

StringBuffer delete (int start, int end). Esempio:
StringBuffer strB=new StringBuffer("stringa da cancellare”);

strB.delete (0, strB.length ());



replace

/* rimpiazza la sottostringa da start ad end con str.

StringBuffer replace (int start, int end, String str)

La sottostringa da sostituire deve essere di tipo String */Esempio:


String s1="TUTTI!";

StringBuffer strA=new StringBuffer ("AMMAZZA ");

StringBuffer strB=new StringBuffer ();

strB=strA;

System.out.println("risultato condivisione: "+ strA+" "+ strB);

strA.replace(8,13,s1);//posizione iniz.le 8; s1 deve essere tipo String

System.out.println ("stringa sostituita: " +strA);// AMMAZZA TUTTI!

System.out.println("risultato condivisione dopo modifica: "+ strA+" "+ strB);


a video


reverse a

/* inverte la sequenza di caratteri */

StringBuffer reverse (). Esempio:

StringBuffer sb = new StringBuffer();

sb.append("Mauro Filipponi");

sb.reverse();

System.out.println(sb);

setLength()

/* imposta la lunghezza della stringa al valore lunghezza passato come parametro */


String testo="frase molto lunga da inserire in una string di tipo StringBuffer";

StringBuffer strD=new StringBuffer("frase iniziale");//creo strD

System.out.println("lun strD: "+strD.length());//lunghezza stringa iniziale strD

strD.setLength(testo.length());//strD deve essere lunga quanto testo

System.out.println("lun strD: "+strD.length());//lunghezza dopo modifica
/* ora inserisco carattere per carattere stringa testo dentro strD

var i che parte da 0 fino alla lunghezza della stringa testo

strD dopo setLength() è più grande. I caratteri di testo si inseriscono

alla posizione i in strD. Il carattere da mettere nella 'StringBuffer strD è ogni carattere di testo.*/


for(int i=0;istrD.setCharAt(i,testo.charAt(i));//stessa posizione in sequenza

}

System.out.println("stringa riempita: \n"+strD);




Concatenazione di stringhe
La classe StringBuffer non è molto usata in modo esplicito dai programmatori, ma lo è dal compilatore Java.

In particolare, i metodi append sono utilizzati dal compilatore per implementare l'operatore di concatenazione di stringhe'+'.

Ad esempio, il comando

x = "a" + 4 + 'c';

viene compilato come se fosse l'espressione

x = new StringBuffer().append("a").append(4).append('c').toString();

che crea un oggetto di classe StringBuffer vuoto, quindi ci concatena in sequenza "a", 4 e 'c', e infine restituisce la stringa corrispondente.

Esempio:

String x = new StringBuffer().append("a").append(4).append('c').toString();

System.out.println("stringa riempita1: "+x);

StringBuffer x1 = new StringBuffer().append("v").append(5).append('d');

System.out.println("stringa riempita2: "+x1);
La classe StringTokenizer
La classe StringTokenizer (del package java.util) fornisce metodi per spezzare una stringa in tokens.

Ad esempio, il programma seguente legge una frase in input, e ne stampa le singole parole una per riga:

import java.util.StringTokenizer;
public class StampaParole {
public static void main (String[] args) {

{

InputStreamReader In = new InputStreamReader(System.in);



BufferedReader tastiera = new BufferedReader(In);

String frase;

try

{

System.out.println("Scrivi una frase:");



String frase = tastiera.readLine();

System.out.println("\nQueste sono le parole:\n");


/* si crea un tokenizer per la stringa 'frase' */

StringTokenizer st = new StringTokenizer(frase);


/* si stampano uno alla volta i token di 'frase' */

while (st.hasMoreTokens()) {

System.out.println(st.nextToken());

}

}



}

StringTokenizer: costruttori

Un token è una sequenza massimale di caratteri che non contiene un delimitatore. Una istanza di StringTokenizer viene creata indicando:



  • la stringa da spezzare,

  • l'eventuale insieme di delimitatori (per default " \t\n\r\f")

  • se i delimitatori sono token o no.

/* Crea un tokenizer per 'str', che usa i caratteri in 'delim', come delimitatori. 'returnDelims' indica se restituire i delimitatori come token oppure scartarli. */

StringTokenizer (String str, String delim, boolean returnDelims)


/* Come sopra, con returnDelims == false. */

StringTokenizer (String str, String delim)


/* Come sopra, con delim == " \t\n\r\f" */

StringTokenizer (String str)


StringTokenizer: metodi
Una istanza di StringTokenizer scorre la stringa sequenzialmente dall'inizio alla fine, restituendo i token uno alla volta. I metodi principali sono:
/* restituisce true se c'e' ancora un token da restituire */

boolean hasMoreTokens()


/* restituisce il prossimo token */

String nextToken()


/* restituisce il prossimo token, usando i caratteri di 'delim' come delimitatori */

String nextToken(String delim)


/* restituisce il numero di token che restano da esaminare nella stringa */

int countTokens()










©astratto.info 2017
invia messaggio

    Pagina principale