Stringurile reprezintă un tip de dată ce posedă caracteristici atât ale

tipurilor primitive, cât și ale obiectelor. Strict vorbind, stringul este un

obiect definit de clasa String. Un obiect string reprezintă o secvență de
caractere și aproape toate limbajele oferă această opțiune, fiindcă este
mai convenabil să lucrezi cu o colecție decât cu fiecare caracter
separat. Java are de asemenea mecanisme încorporate pentru
convertirea unui string într-un șir de caractere primitive și viceversa.

Java oferă o funcție specială a clasei String, ce permite obiectelor de

tip string să se comporte ca tipurile primitive. Un obiect string poate fi
creat utilizând caracterul =, iar stringurile pot fi concatenate utilizând
caracterul +. Dacă utilizăm + cu orice alt tip, vom cauza fie o eroare în
timpul execuției, fie o operație de adunare asupra unor tipuri ce nu
susțin acest lucru.

Crearea stringurilor

Cea mai comună metodă pentru crearea stringurilor este:

String message = "Hi!";

În exemplul de mai sus, am declarat o variabilă de tip string cu

denumirea message și valoarea Hi!. Deși tipul string nu este primitiv,
limbajul Java ne permite să-l creăm ca și cum ar fi astfel. Această
construcție a stringurilor se numește implicită.

La fel ca în cazul oricărui alt obiect, un string poate fi creat cu ajutorul

cuvântului cheie new. Să vedem un exemplu:

String word = new String("Hi!");

În linia anterioară, am creat un obiect de tip string utilizând cuvântul

cheie new și transmițând o valoare constructorului. O astfel de
construcție se numește explicită.

Există o diferență importantă între aceste două metode de creare a

stringurilor. În construcția implicită, Java are un mecanism special
pentru salvarea valorilor de tip string. Valorile textuale definite implicit
(fără un constructor) sunt salvate într-o secțiune specială numită
Common pool. Dacă definim două variabile de tip string cu aceeași
valoare, vor împărtăși același conținut în Common pool.

Pe de altă parte, obiectele de tip string create cu ajutorul cuvântului

cheie new și a constructorului vor fi stocate în heap, iar Common pool
nu va exista pentru ele, deoarece există pentru stringurile create în
același mod ca tipuri primitive.

Pentru a clarifica acest aspect, vom arăta câteva stringuri definite în

moduri diferite. În Figura 1, vom ilustra metoda de salvare a acestor
valori în memorie.

String s1 = "Hello";
String s2 = "Hello";
String s3 = s1;
String s4 = new String("Hello");
String s5 = new String("Hello");

Imaginea 20.1 Diferența dintre construcția implicită și explicită a

stringurilor
Concatenarea stringurilor

În introducerea acestei lecții am menționat că Java permite funcția de

concatenare. Când dorim să concatenăm un string cu un alt string,
folosim caracterul + sau metoda specială concat.

String myString = "My ";

String myString1 = "string";
[Link](myString+myString1);

Sau:

String myString = "My ";

String myString1 = "string";
[Link]([Link](myString1));

Ambele tehnici funcționează bine, însă doar pe termen scurt. Pentru o

concatenare mai serioasă a stringurilor, aceste metode nu sunt bune,
fiindcă nu concatenează un string cu un string existent, ci creează un
nou obiect string în memorie, al cărui conținut este alcătuit din cele
două stringuri concatenate. Aceasta este o consecință a faptului că
stringul nu este un obiect mutabil, ceea ce înseamnă că, după creare,
conținutul său nu se mai poate modifica. Aceasta în schimb înseamnă
că construcția unui mare număr de stringuri cu metoda concatenării va
duce la acumularea obiectelor string în memorie.

Vom rezolva acest lucru prin utilizarea clasei StringBuilder care este de
fapt o listă de stringuri reprezentate printr-un singur obiect. Utilizând
această clasă, vom reduce semnificativ consumul de memorie în
timpul concatenării stringurilor și vom crește lizibilitatea codului.
Următorul exemplu va da același rezultat ca cel anterior, doar că de
această dată vom utiliza clasa StringBuilder:

StringBuilder sb = new StringBuilder();

[Link]("My ");
[Link]("string");
[Link](sb);

Această modalitate de gestionare a stringurilor este considerată cea

mai bună atunci când vorbim de concatenare.

Funcțiile stringurilor

După cum am spus deja, tipul string este un tip de date complex în
Java, fiind un tip de obiect. Acest lucru ne permite ca asupra
variabilelor de acest tip să apelăm diverse metode pentru procesarea
valorilor acestor variabile. În partea următoare, vom utiliza câteva
dintre cele mai utilizate metode pentru procesarea stringurilor. Una
dintre metode este un bloc de cod ce efectuează o anumită funcție.
Metoda poate avea parametri de intrare și de ieșire, însă acest lucru nu
este obligatoriu. Parametrii de intrare, dacă aceștia există, sunt
introduși între paranteze după denumirea metodei. Parametrii de ieșire
reprezintă rezultatul de execuție a metodei.

toCharArray()

Dacă dorim să tratăm o valoare textuală de tip string ca șir, va trebui

să convertim mai întâi stringul într-o secvență de caracteri. Putem face
acest lucru utilizând metoda toCharArray.

String word = "Hello";

char[] charArray = [Link]();

for (int i = 0; i < [Link]; i++) {

[Link](charArray[i]);
}

Codul de mai sus ilustrează utilizarea metodei toCharArray, pe care am

utilizat-o pentru a converti un string într-un șir de caractere. Mai apoi,
am utilizat o buclă for pentru a lista caracterele și pentru a afișa
rezultatele la ieșire.

length()

Această metodă se utilizează pentru a obține informații despre

lungimea unei variabile de tip string. Funcția returnează numărul de
caractere conținut de obiectul string. Haideți să privim următorul cod:

public static void main(String args[]) {

String word = "Hello";

int len = [Link]();
[Link]( "String length is : " + len );

După execuția codului anterior, vom obține următorul rezultat la ieșire:

String Length is 5

toUpperCase()

Această funcție convertește în majuscule toate caracterele stringului

transmis. Bineînțeles, această funcție ia în considerare doar
caracterele literale, așadar caracterele care nu sunt litere vor rămâne
nemodificate. Să privim următorul exemplu:

public static void main(String[] args) {

String str = "Welcome to UTM!";

[Link]("Return Value : ");

[Link]([Link]());
}

Rezultatul la ieșire este:

Return Value : WELCOME TO UTM!

toLowerCase()

Analoagă funcției anterioare, funcția toLowerCase() efectuează

operația opusă, convertind toate caracterele literale în minuscule.

public static void main(String[] args) {

String str = "Welcome to UTM !";

[Link]("Return Value : ");

[Link]([Link]());
}

Rezultatul ieșirii este următorul:

Return Value : welcome to utm!

trim()

Metoda trim() se folosește pentru a tăia caracterele goale de la

începutul și finalul unui string. Să privim următorul exemplu:

public static void main(String[] args) {

String Str = " Welcome to UTMoldova ";

[Link]("Return Value :");
[Link]([Link]());
}

Puteți vedea că am inițializat stringul în exemplul de mai sus prin

introducerea unui anumit număr de caractere goale la începutul și
sfârșitul stringului. Haideți să vedem rezultatul acestei metode:

Return Value :Welcome to UTMoldova

După cum puteți vedea, am obținut un string ”trunchiat” la ieșire, un

string fără spații goale la început și la sfârșit.

Această metodă se folosește adesea pentru validarea unei introduceri

de client, mai ales în aplicațiile Web. Să ne imaginăm că sistemul are o
astfel de validare de client, unde "mypassword" și "my password " nu
este același lucru. În astfel de cazuri, un client poate încerca să facă
autentificarea cu date care, deși valide, nu pot trece cu succes
validarea de sistem.

indexOf()

Metoda indexof() are câteva variații, respectiv moduri de funcționare,

în funcție de numărul și tipul de parametrii transmiși. Putem confirma
acest lucru cu ajutorul mediului de dezvoltare NetBeans:

Imaginea 20.2 Metoda indexOf

 indexOf(int ch) – în cazul în care metoda acceptă un caracter
ca parametru, aceasta îi returnează indexul în cadrul stringului;
să nu vă inducă în eroare faptul că așteaptă o valoare de tip int
ca parametru de intrare; fiecare caracter are un anumit cod în
UNICODE care îl reprezintă; de exemplu, caracterul "A" are
valoarea zecimală 65 în UNICODE, așadar putem transmite atât
valoarea întreagă a codului, cât și caracterul însuși; în cazul în
care caracterul nu este găsit în cadrul stringului, funcția va
returna -1

indexOf(String str) – funcția caută dacă stringul transmis

este localizat într-un alt string; funcția returnează ca valoare
indexul de unde începe stringul dorit; dacă stringul nu este
găsit, funcția va returna -1

indexOf(String str, int fromIndex) – această metodă

funcționează la fel ca cea anterioară, cu excepția faptului că
stringul transmis va fi căutat de la indexul transmis în raport cu
parametrul fromIndex; dacă stringul nu este găsit, funcția
returnează -1

indexOf(int ch, int fromIndex) – similar cu funcția

anterioară, această funcție caută caracterul transmis în cadrul
stringului, cu excepția faptului că începe căutarea de la indexul
marcat cu parametrul fromIndex

Pentru a clarifica, haideți să privim următorul exemplu:

public static void main(String[] args) {
String str = "Welcome to UTMoldova";
String subStr1 = "UTMoldova";
String subStr2 = "[Link]";

[Link]("Found Index :");

[Link]([Link]('o'));
[Link]("Found Index :");
[Link]([Link]('o', 5));
[Link]("Found Index :");
[Link]([Link](subStr1));
[Link]("Found Index :");
[Link]([Link](subStr1, 15));
[Link]("Found Index :");
[Link]([Link](subStr2));

Rezultatul la ieșire este:

Found Index :4
Found Index :9
Found Index :11
Found Index :-1
Found Index :-1

charAt()

Această metodă returnează un caracter care se află la un anumit index

în cadrul stringului. Sintaxa acestei metode arată astfel:

public char charAt(int index)

După cum putem vedea, această metodă necesită ca parametru o

valoare de tip int ce reprezintă indexul caracterului și returnează o
valoare de tip char. Să privim utilizarea acestei metode într-un
exemplu:

public static void main(String[] args) {

String s = "This is string";
char result = [Link](8);
[Link](result);
}

La ieșire vom obține valoarea 's', deoarece caracterul 's' se află

localizat pe poziția 8. Acordați atenție faptului că indexarea șirurilor
începe de la zero (0), așadar al nouălea caracter se află pe poziția
indexului 8 (chiar și un spațiu gol reprezintă un caracter.

substring()

Această metodă are două variații, în funcție de parametrii de intrare:

- public String substring(int beginIndex)

- public String substring(int beginIndex, int endIndex)

Aceste metode extrag un anumit string dintr-un string existent. Este

logic ca aceste metode să aibă o valoare de tip string ca valoare de
returnare.

Prima metodă acceptă doar un parametru care marchează începutul

unui nou string. Acest lucru înseamnă că noul string va fi creat de la
indexul specificat până la finalul stringului sursă.

Metoda substring() utilizează și indexul de final, pe lângă indexul

inițial, așadar noul string va fi alcătuit din caracterele aflate începând
cu primul index şi terminând cu caracterele până la cel de-al doilea
index, însă neincluzând caracterul corespunzător celui de-al doilea
index.

Haideți să vedem cum se utilizează această metodă în ambele

variante:

public static void main(String[] args) {

String str = "Welcome to UTMoldova;

[Link]("Return Value :");

[Link]([Link](10));

[Link]("Return Value :");

[Link]([Link](10, 14));
}

La ieșire vom obține acest rezultat:

Return Value : UTMoldova

Return Value : UTM

equals()

Metoda equal se folosește pentru a verifica egalitatea a două stringuri.

Haideți să privim un exemplu:

public static void main(String[] args) {

String str1 = "First value";
String str2 = "Second value";
String str3 = new String("First value");
String str4 = new String("Second value");

boolean retVal = [Link](str3);

[Link](retVal);
retVal = [Link](str2);
[Link](retVal);}

În codul de mai sus, am declarat patru variabile de tip string, unde

primul și al treilea, și al doilea și al patrulea au aceeași valoare. Primele
două valori sunt create implicit, iar celelalte două valori explicit.

Metoda equals returnează valori de tip boolean (true sau false) ca

rezultat al procesării sale. La ieșire vom obține următorul rezultat:

true
false

Concluzia este că, indiferent de metoda în care am creat o valoare

textuală, dacă utilizăm metoda equals, vom obține întotdeauna o
valoare de returnare ce corespunde cu realitatea.

Pentru a compara stringurile, putem utiliza caracterul pentru egalitate

logică (==). Cu toate acestea, abordarea menționată nu este
recomandată, fiindcă în acest mod, comparăm doar adresele unde
aceste două obiecte sunt localizate, având în vedere că o variabilă
păstrează valoarea adresei unui obiect. Metoda equals compară
stringurile caracter cu caracter, ceea ce este cea mai bună metodă de
comparare a stringurilor.

Haideți să privim următorul exemplu, unde comparațiile utilizând

ambele metode vor da rezultate diferite, deși stringurile pe care le
comparăm sunt identice:

public static void main(String[] args) {

String str1 = "First value";
String str2 = new String("First value");

[Link]([Link](str2));
[Link](str1 == str2);}
}

Rezultatul la ieșire va fi acesta:

true
false

Prima variabilă textuală str1 a fost creată implicit și, prin urmare, a fost
stocată în Common pool, în timp ce a doua variabilă str2 este de fapt
un obiect stocat în heap. Variabilele str1 și str2 conțin doar adresele
valorilor propriu-zise. Acesta este motivul pentru care comparația
făcută cu operatorul de comparație nu dă rezultatele așteptate, fiindcă
operatorul compară de fapt două adrese. Utilizarea metodei equals dă
rezultatele așteptate, având în vedere că stringurile sunt comparate
caracter cu caracter. Pentru verificarea egalităţii string-urilor se poate
utiliza o metodă înrudită cu equals(), această metodă fiind
equalsIgnoreCase(). Această metodă va permite verificarea egalităţii
string-urilor case insensitive.

startsWith()

Această metodă are două variații, în funcție de parametrii de intrare:

public boolean startsWith(String prefix)

public boolean startsWith(String prefix, int toffset)

În esență, această metodă verifică dacă un anumit string începe cu

prefixul specificat. În primul caz, prefixul dorit este transmis sub forma
unei variabile de tip string. În cazul celei de-a doua metode, există un
parametru adițional care ne spune unde ar trebui să începem
verificarea prefixului. Acest parametru asigură ca verificarea să nu
înceapă de la început, ci de la indexul specificat de această variabilă.
Ambele metode returnează valoarea true sau false, în funcție dacă
prefixul transmis a fost găsit sau nu. Haideți să privim un exemplu
practic de utilizare a acestor metode:

public static void main(String[] args) {

String str = "Welcome to UTMoldova";

[Link]("Return Value :");

[Link]([Link]("Welcome"));

[Link]("Return Value :");

[Link]([Link]("UTMoldova"));

[Link]("Return Value :");

[Link]([Link]("UTMoldova", 11)); }

After this, we get the following output:

Return Value :true

Return Value :false
Return Value :true

endsWith()

Această metodă se folosește pentru a verifica dacă un anumit string se

încheie în maniera specificată. Sintaxa acestei metode arată astfel:

public boolean endsWith(String suffix)

După cum putem vedea, funcția acceptă tipul string ca parametru de

intrare și afișează tipul boolean (true sau false) ca valoare de
returnare. Utilizarea sa arată astfel:
public static void main(String[] args) {
String str = "This is string!";
boolean retVal;

retVal = [Link]("string!");
[Link]("Returned Value = " + retVal);

retVal = [Link]("This");
[Link]("Returned Value = " + retVal);
}

Obținem următoarea ieșire:

Returned Value = true

Returned Value = false

replace()

Uneori va fi nevoie să înlocuim anumite caractere dintr-un string sau

șir cu alte caractere. Putem obține acest lucru cu ajutorul metodei
replace a clasei string. Semnătura metodei arată astfel:

public String replace(char oldChar, char newChar)

Putem vedea că metoda acceptă doi parametri și aceștia sunt

caracterele care trebuie înlocuite, primul cu cel de-al doilea.

String word = "--Hello--";

[Link]([Link]("-", "*"));

Codul de mai sus va produce următorul rezultat:

**Hello**
split()

Întregul conținut al unui string este tratat în mod egal, indiferent de

caracteristici. Numerele și literele sunt egale, literele și caracterele
sunt egale etc. Acesta este motivul pentru care o problemă des
întâlnită în lucrul cu stringurile este identificarea și izolarea unui
anumit element sau a unui șir de elemente. Prin utilizarea metodei
split(), putem împărți un string într-un șir de substringuri. Metoda
split() are următorul format:

public String[] split(String regex)

public String[] split(String regex, int limit)

Putem vedea că metoda split poate accepta unul sau doi parametri și
că are o funcție diferită în funcție de numărul de parametri. În primul
caz, metoda acceptă un parametru de tip string. Acest parametru
reprezintă stringul în funcție de care stringul sursă va fi împărțit. Al
doilea parametru pe care această metodă îl poate accepta se referă la
numărul maxim de elemente ale șirului final. Cu acest parametru, noi
am definit de fapt numărul maxim de cuvinte în care stringul sursă va
fi împărțit. Haideți să privim un exemplu practic de utilizare a metodei
split, astfel încât totul să devină mai clar:

public static void main(String[] args) {

String str = "Welcome-to-UTMoldova";

[Link]("Return Value :");

String[] wordArray1 = [Link]("-");
for (int i = 0; i < [Link]; i++) {
[Link](wordArray1[i]);
}

[Link]("Return Value :");

String[] wordArray2 = [Link]("-", 2);
for (int i = 0; i < [Link]; i++) {
[Link](wordArray2[i]);
}
}

Vom obține următorul rezultat:

Return Value :
Welcome
to
UTMoldova
Return Value :
Welcome
to-UTMoldova

În prima parte, am utilizat metoda split cu caracterul "-" transmis.

Împărțirea se va face pe baza acestui criteriu, astfel încât vom obține 3
cuvinte la ieșire (noul șir creat va avea trei elemente). Când am utilizat
metoda split pentru a doua oară, am expediat de asemenea și al doilea
parametru care se referă la numărul maxim de elemente ale șirului ce
pot să apară. Din acest motiv, șirul creat are două elemente (tot ce a
rămas de la prima împărțire a devenit un string, respectiv un element
al șirului). Încă nu am discutat despre șiruri și nu este posibil să
explicăm acest exemplu fără utilizarea șirurilor. Despre șiruri vom
discuta mai târziu în acest modul. De asemenea, în acest exemplu am
utilizat o buclă for pentru a trece prin toate elementele șirurilor create
și pentru a le afișa la ieșire.

Exemplul de mai sus se referă la utilizarea metodei split, când am

utilizat un singur caracter ca criteriu de împărțire. Haideți să vedem
cum putem face împărțirea în funcție de mai multe criterii:

public static void main(String[] args) {

String str = "This is a sentence. This is a question, right? Yes! It is.";

[Link]("Return Value :");

String[] wordArray = [Link]("[ .,?!]+");
for (int i = 0; i < [Link]; i++) {
[Link](wordArray[i]);
}
}

Vom obține următorul rezultat:

Return Value :
This
is
a
sentence
This
is
a
question
right
Yes
It
Is

Din exemplul de mai sus putem extrage concluzia că putem specifica

mai multe caractere ca parametru ce reprezintă criteriul de împărțire.
Toate caracterele în funcție de care dorim să facem împărțirea sunt
plasate între paranteze pătrate, la fel ca în codul de mai sus. Probabil
vă întrebați de ce avem caracterul + în afara parantezelor pătrate. Se
poate întâmpla ca stringul susrsă să aibă două caractere de împărțire
identice, unul după celălalt. La fel ca în exemplul nostru: avem un
spațiu dublu în două locuri. Semnul plus ne permite să tratăm astfel de
caractere de împărțire continue ca și cum ar fi un singur caracter.
Încercați să scoateți caracterul + din expresia de mai sus, porniți
aplicația și verificați ce obțineți la ieșire.