Se afișează postările cu eticheta String. Afișați toate postările
Se afișează postările cu eticheta String. Afișați toate postările

luni, 23 februarie 2026

Expresii regulate. Validarea șirurilor de caractere

În Java, o expresie regulată, numită regex, este un model de verificare a unui text. Ea ne permite să controlăm dacă un șir respectă o anumită regulă sau nu. 
De exemplu putem valida dacă șirul introdus de utilizator este: email, număr de telefon, parolă, cod poștal, doar cifre, doar litere, etc

Pentru aceasta se folosesc clasele din pachetul java.util.regex
import java.util.regex.Pattern;
import java.util.regex.Matcher;
Dar un mod mai simplu de a valida un șire de caractere este metoda matches() a clasei String care are forma:
String.matches("regex");
"regex" este o expresie regulată, adică un model (regulă) după care verificăm textul, cu alte cuvinte anume acesta este șablonul după care validăm șirul de caractere. 
Pentru a construi șablonul trebuie să cunoaștem simbolurile cheie: 

Vom examina în continuare mai multe exemple practice. 

Exemplul următor va valida dacă șirul de caractere conține doar cifre. Expresia regulată în acest caz va conține \\d,  adică doar cifre, și + ceea ce înseamnă una sau  mai multe apariții, deci verificăm dacă în șirul de caractere apare una sau mai multe cifre: 
class Testare{
public static void main(String [] args){
String text = "12345";
if (text.matches("\\d+")) {
System.out.println("Codul este valid!");}
else
System.out.println("Codul trebuie să conțină doar cifre!");
}}

O astfel de verificare este frecvent utilizată în aplicații reale: validarea unui cod numeric, a unui ID, a unui PIN sau a unui număr de ordine.

De exemplu cunoaștem că un code PIN are 4 cifre, deci expresia care va valida dacă șirul de caractere este un cod corecte va conține {} și acesta este: 
class Testare{
public static void main(String [] args){
String pin = "2255";
if (pin.matches("\\d{4}")) {
System.out.println("Codul pin valid");
}
}}

Exemplul următor va valida dacă șirul de caractere conține doar litere. Expresia regulată în acest caz va conține [a-zA-Z],  adică doar litere mari și mici, și semnul + ceea ce înseamnă una sau  mai multe apariții, deci verificăm dacă în șirul de caractere apare una sau mai multe litere, fie litere mari, fie litere mici: 
class Testare{
public static void main(String [] args){
String text = "ProgramareJava";
if (text.matches("[a-zA-Z]+")) {
System.out.println("Valid - doar litere");
}
}}

Următorul exemplu verifică dacă șirul de caractere va conține cel puțin o literă acesta nu va promova validarea: 
class Testare{
 public static void main(String [] args){
     String text = "1F2345";
     if (text.matches(".*[a-zA-Z].*")) {
         System.out.println("Codul este valid!");}
     else System.out.println("Codul trebuie să conțină cel puțin o literă!");
 }}

În cazul condițiilor combinate este necesar de utilizat simbolurile:
^  - începutul șirului
$  - sfârșitul șirului

De exemplu, vom verifica dacă șirul conține litere și cifre: 
class Testare{
public static void main(String [] args){
String text = "Java2026";
if (text.matches("^[a-zA-Z0-9]+$")) {
System.out.println("Valid - doar litere si cifre");
}
else {
System.out.println("Invalid");
}
}}

De asemenea, în condițiile combinate se folosește (?=…), numit lookahead, care verifică o condiție fără să „consume” textul, adică se uită dacă regula este respectată, dar nu modifică șirul și nu utilizează caracterele verificate, nu-i modifică dimensiunea, astfel încât restul expresiei să poată continua să analizeze întreg șirul.

Următoarele două exemple evidențiază utilitatea lookahead-ului în condiții combinate, dorim să validăm dacă parola conține cel puțin o cifră și minim 6 caractere : 

Exemplu fără lookahead
class Testare{
public static void main(String [] args){
String parola = "abc123";
// Regex fără lookahead
// Caută să înceapă cu o cifră, apoi 5 sau mai multe caractere
if (parola.matches("\\d.{6,}")) {
System.out.println("Parola este validă");
}
else { System.out.println("Parola NEVALIDĂ");}
}}


Deși parola conține cel puțin o cifră și minim 6 caractere, aceasta nu trece testul de validare. Este din motiv că regex fără lookahead caută să înceapă cu o cifră, în caz contrar rezultatul este false.

Exemplu cu lookahead
class Testare{
public static void main(String [] args){
String parola = "abc123";
if (parola.matches("^(?=.*\\d).{6,}$")) {
System.out.println("Parola este validă");
}
else { System.out.println("Parola NEVALIDĂ");}
}}

Exemplu în care vom verifica dacă utilizatorul indică un email corect: 

class Testare{
public static void main(String [] args){
String email = "test@gmail.com";
if (email.matches("^[A-Za-z0-9+_.-]+@(.+)$")) {
System.out.println("Email valid");
}
else { System.out.println("Email nu este valid");}
}}

Exemple de expresii regex și destinația acestora:

.matches("^[a-zA-Z0-9_]+$") - verifică dacă expresia conține litere, cifre și underscore, util pentru validare username


.matches("^\\d{6}$") - verifică dacă șase cifre, util pentru verificarea unui cod poștal

.matches("^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d).{8,}$") - verifică dacă șirul de caractere conține cifre, litere mici, litere mari, util pentru verificarea unei parole mai complexe

.matches("^[A-Za-z].*$") - verifică dacă șirul de caractere începe cu o litera

.matches(".*\\d$") - verifică dacă șirul de caractere finisează cu o cifră

.matches("^\\d+(\\.\\d+)?$") - verifică dacă șirul de caractere  este un număr zecimal. Va accepta de exemplu 10, la fel și 10.5. Nu va accepta litere

.matches("^[A-Za-z][A-Za-z0-9_]*$") - verifică dacă șirul de caractere  începe cu o literă după care urmează litere, cifre sau semnul underscore

Expresiile regulate sunt foarte utile în programare, oferind o metodă rapidă și precisă pentru verificarea și manipularea șirurilor de caractere, astfel asigurând securitatea datelor cu care lucrează aplicația. 

Îți dorești un anumit conținut să apară în această postare? 
Vezi meniul 👉 CONTACTE 
Aștept un e-mail 💬

Succes!
❤️

luni, 16 februarie 2026

Set de probleme. Clasa StringBuilder. Clasa StringBuffer


1. Scrieți un program în care creați un obiect StringBuffer și un obiect StringBuilder cu textul "Salut" la care adăugați folosind append() numele dvs și un semn de punctuație. La final, afișați rezultatul pentru ambele obiecte. Rezultat așteptat: "Salut, [numele tău]!"

2. Scrieți un program în care creați un obiect StringBuffer și un obiect StringBuilder cu textul "Salut dragă lume", ștergeți cuvântul "dragă " folosind delete(). Afișați rezultatul pentru ambele clase. Rezultat așteptat: "Salut lume"

3. Scrieți un program în care creați un obiect StringBuffer și un obiect StringBuilder cu textul "Salut lume!". Folosiți deleteCharAt() pentru a elimina semnul de exclamare, aplicând metoda atât pe StringBuffer, cât și pe StringBuilder. Rezultat așteptat: "Salut lume"

4. Scrieți un program în care creați un obiect StringBuffer și un obiect StringBuilder cu textul "Buna ziua". Înlocuiți "ziua" cu "seara" folosind replace(). Afișați rezultatul pentru ambele clase. Rezultat așteptat: "Buna seara"

5. Scrieți un program în care creați un obiect StringBuffer și un obiect StringBuilder cu textul "Java". Folosiți reverse() pentru a inversa șirul, aplicând metoda atât pe StringBuffer, cât și pe StringBuilder. Rezultat așteptat: "avaJ"

6. Scrieți un program în care creați un obiect StringBuffer și un obiect StringBuilder cu textul "Salut lume. Eu programez în Java". Afișați caracterul aflat la poziția pe o anumită poziție folosind metoda charAt() pentru ambele clase.

7. Scrieți un program în care creați un obiect StringBuffer și un obiect StringBuilder cu textul "salut lume". Folosiți metoda setCharAt() pentru a schimba prima literă în majusculă, atât pentru StringBuffer, cât și pentru StringBuilder. Rezultat așteptat: "Salut lume"

8. Scrieți un program în care creați un obiect StringBuffer și un obiect StringBuilder cu textul "Programare Java". Extrageți cu ajutorul metodei substring() doar cuvântul "Java" pentru ambele clase.

9. Scrieți un program în care creați un obiect StringBuffer și un obiect StringBuilder în baza unui text citit de la tastatură. Afișați la ecran, folosind metoda length() câte caractere are textul citit.

10. Scrieți un program în care creați un obiect StringBuffer și un obiect StringBuilder cu textul "Salut". Afișați capacitatea inițială. Apoi adăugați mai multe caractere. Afișați capacitatea după modificarea textului. Observați cum se schimbă capacitatea pentru ambele clase.

11. Scrieți un program în care creați un obiect StringBuffer și un obiect StringBuilder cu textul "Invat programare". Introduceți cuvântul „Java ” după cuvântul „Invat ” folosind metoda insert(). Adăugați punct la final folosind metoda append(). Afișați rezultatul. Încercați să utilizați apelul în lanț al metodelor.

12. Un elev a stocat o listă de teme pentru acasă într-un șir de caractere:

tema1: matematica, tema2: informatica, tema3: fizica

Scrieți un program în care să utilizați StringBuilder sau StringBuffer pentru a obține la afișare:

TEMA1: MATEMATICA | TEMA2: INFORMATICA | TEMA3: FIZICA

Pentru aceasta:
- Transformă fiecare temă în majuscule.
- Înlocuiește virgulele cu simbolul |.
- Afișează rezultatul final.

13. Un magazin online a stocat titlurile comenzilor într-un șir de caractere:

comanda1: telefon, comanda2: laptop, comanda3: tableta

Scrieți un program în care să utilizați fie StringBuilder, sau StringBuffer pentru a obține la afișare:

Comanda3: TABLETA | Comanda2: LAPTOP | Comanda1: TELEFON

Pentru aceasta:
- Eliminați spațiile inutile de la început și sfârșit folosind trim().
- Inversați ordinea comenzilor folosind reverse().
- Transformați numele produselor în majuscule.
- Înlocuiți virgulele cu simbolul |.


Succes!
💓

joi, 5 februarie 2026

Tip de date șir de caracter. Clasa String

String-urile, numite șiruri de caractere, sunt pe larg utilizate în  orice limbaj de programare, și reprezintă o succesiune finită de caractere (litere, cifre, simboluri), tratată ca un singur obiect.

În Java string-urile sunt considerate obiecte, adică sunt de tip referință.
 
Una din clasele Java ce permit prelucrarea șirurilor de caractere este clasa String.

Definiție:
public final class String extends Object
implements Serializable, Comparable<String>, CharSequence


Descriere:
Clasa String se află în pachetul java.lang și este utilizată pentru crearea și prelucrarea șirurilor de caractere. Este o clasă închisă spre modificare (immutable), adică o clasă obiectele căreia nu se modifică. Orice valoare atribuită  obiectului rămâne în sistem creând astfel a mulțime de obiecte neutilizate. 

Pentru a crea un șir de caractere puteți utiliza sintaxa:
String identificator = ”Valoare”;
De exempluString zi = ”Luni”;

Ori de cîte ori compilatorul găsește un literal String în codul sursă acesta crează un obiect de tipul clasei String ce va conține ca valoare literalul.

La fel ca și în cazul celorlalte obiecte, puteți folosi constructorul clasei String pentru a crea o instanță a acestei clase.
De exempluString zi = new String(”Luni”);
 
Metode:
a) char charAt(int index) - returnează caracterul ce se află pe poziția index. Indicele caracterului din șir variază de la 0 la length()-1.

De exemplu:
String s = "Java";
System.out.println(s.charAt(1)); //a

b) public boolean equals(Object unObiect) returnează true dacă obiectul curent este echivalent ca valoare cu string-ul unObiect, în caz contrar returnează false. Se ține cont de litere mari și mici.

De exemplu:
String s = "Java";
String s1 = "Java";
String s2 = "java";
System.out.println(s.equals(s1)); //true
System.out.println(s.equals(s2)); //false

c) public boolean equalsIgnoreCase(String altString) - returnează true dacă obiectul curent este echivalent ca valoare cu string-ul altString, în caz contrar returnează false. Nu se ține cont de litere mari si mici.  

De exemplu:
String s = "Java";
String s1 = "java";
String s2 = "Java";
System.out.println(s.equalsIgnoreCase(s1));
//true
System.out.println(s.equalsIgnoreCase(s2)); //true

Notă!  
Operatorul == aplicat asupra a două șiruri de caractere nu va verifica egalitatea acestora ci identitatea șirurilor, adică se vor compara referințele și se va returna true dacă acestea vor fi egale. Se va  verifica dacă cele două șiruri indică unul și același obiect.

De exemplu:
String s = "Java";
String s1 = "POO";
String s2 = s;
System.out.println(s==s1);
//false
System.out.println(s2==s); //true

d. public int length()- returnează lungimea șirului de caractere.  

De exemplu:
String s = "Java";
System.out.println(s.length()); //4

e. public boolean isEmpty()  - returnează true dacă  și numai dacă length() este 0

De exemplu:
String s = "Java" ;
String s2 = "";
System.out.println(s.isEmpty());
// false
System.out.println(s2.isEmpty()); // true

f. public boolean startsWith(String prefix, int toffset) - verifică dacă substrigul din șirul dat începînd cu poziția toffset începe cu prefixul prefix.

De exemplu:
String s = "Programare" ;
System.out.println(s.startsWith("ram", 3));  //false
System.out.println(s.startsWith("ram", 4));  
//true
System.out.println(s.startsWith("ram", 10)); //false
System.out.println(s.startsWith("ram", -3)); //false

g. public boolean startsWith(String prefix)- verifică dacă șirul dat începe cu prefixul prefix.

De exemplu:
String s = "Programare" ;
System.out.println(s.startsWith("Prog"));
//true
System.out.println(s.startsWith("ram")); //false

h. public boolean endsWith(String suffix)- verifică dacă șirul dat finisează cu sufixul suffix.

De exemplu:
String s = "Programare" ;
System.out.println(s.endsWith("re"));
//true

i. public int indexOf(String ch)- Returnează indicele caracterului ch  în cadrul unui șir de caractere.

De exemplu:
String s = "Programare" ;
System.out.println(s.indexOf("r"));
//1
System.out.println(s.indexOf("b")); //-1
System.out.println(s.indexOf("P")); //0
System.out.println(s.indexOf("p")); //-1

j. public int lastIndexOf(String ch) - Returnează indicele ultimei apariții a caracterului ch în cadrul unui șir de caractere.

De exemplu:
String s = "Programare";
System.out.println(s.lastIndexOf("r"));
//8
System.out.println(s.lastIndexOf("b")); //-1
System.out.println(s.lastIndexOf("o")); //2

k. public String concat(String str)– concatinează două șiruri de caractere.

De exemplu:
String s = "programez in " ;
String s1 = " Java" ;
s.concat(s1);
System.out.println(s);
// programez
String s3 = s.concat(s1);
System.out.println(s3); // programez in Java
System.out.println("Eu ".concat(s3)+" azi"); //Eu programez in Java azi

l. public String replace(char oldChar, char newChar) - returnează un string rezultat din înlocuirea tuturor aparițiilor caracterelor specificate în oldChar prin newChar.   

De exemplu:
String s = "tata";
System.out.println(s.replace("t", "m"));
//mama
System.out.println("Ei pleaca".replace("Ei", "Ele")); //Ele pleaca

m. public boolean contains(CharSequence s)– returnează true daca și numai dacă șirul de caractere conține secvența căutată specificată prin s.

De exemplu:
String s = "Programez in Java";
System.out.println(s.contains("Java"));
//true
System.out.println("Ei pleaca".contains("Ele")); //false

n. public String toLowerCase()- Convertește toate literele șirului de caractere în litere mici.

De exemplu:
String s = "Programez";
System.out.println(s.toLowerCase());
//programez
System.out.println("Ei pleaca".toLowerCase()); //ei pleaca

o. public String toUpperCase()- Convertește toate literele șirului de caractere în litere mari.

De exemplu:
String s = "Programez";
System.out.println(s.toUpperCase());
//PROGRAMEZ
System.out.println("in java".toUpperCase()); //IN JAVA

p. public String substring(int beginIndex)- returnează un subșir din șirul asupra căruia s-a apelat metoda începând cu indexul elementului din șir specificat prin beginIndex.

De exemplu:
String s = "Programez";
System.out.println(s.substring(3)); // gramez
System.out.println(s.substring(-1)); 
// StringIndexOutOfBoundsException
System.out.println(s.substring(9)); // nu se afiseaza nimic

q. substring(int IndexInitial, int IndexFinal)- returnează un subșir din șirul asupra căruia s-a apelat metoda data începând cu  caracterul aflat pe poziția IndexInitial până la caracterul cu indicele IndexFinal.

De exemplu:
String s = "Programez";
System.out.println(s.substring(0,7)); // Program
System.out.println(s.substring(0,10)); //StringIndexOutOfBoundsException
System.out.println(s.substring(1,1)); // nu se afiseaza nimic
System.out.println(s.substring(3,1)); 
// StringIndexOutOfBoundsException

r. public String trim() - întoarce o copie a șirului fără spațiile de la începutul și sfârșitul șirului.  

De exemplu:
String s = " Programez ";
String s1 = "Programez";
System.out.println(s.equals(s1));
//false
System.out.println(s.trim().equals(s1)); //true

s. boolean Character.isDigit(char c)– verifică dacă caracterul c este o cifră (0–9). Returnează true dacă este cifră și false în caz contrar.

De exemplu:
char c = '5';
System.out.println(Character.isDigit(c)); // true
char c = 'A';
System.out.println(Character.isDigit(c)); // false

t. boolean Character.isUpperCase(char c) – verifică dacă caracterul c este o literă mare. Returnează true dacă este literă mare și false în caz contrar.

De exemplu:
char c = 'J';
System.out.println(Character.isUpperCase(c)); // true
char c = 'j';
System.out.println(Character.isUpperCase(c)); // false

u. boolean Character.isLowerCase(char c) – verifică dacă caracterul c este o literă mică. Returnează true dacă este literă mică și false în caz contrar.

De exemplu:
char c = 'a';
System.out.println(Character.isLowerCase(c)); // true
char c = 'A';
System.out.println(Character.isLowerCase(c)); // false

Aceste metode nu aparțin clasei String, ci clasei Character, dar sunt utilizate frecvent împreună cu String.charAt(), atunci când analizăm caracterele unui șir. De exemplu: 
String text = "Java2026";

// parcurgem fiecare caracter din șir
for (int i = 0; i < text.length(); i++) {
    char c = text.charAt(i);

    System.out.print(c + " -> ");

    if (Character.isUpperCase(c)) {
        System.out.println("literă mare");
    } else if (Character.isLowerCase(c)) {
        System.out.println("literă mică");
    } else if (Character.isDigit(c)) {
        System.out.println("cifră");
    } else {
        System.out.println("alt caracter");
    }
}

Deci:
  • charAt() extrage un caracter dintr-un String;
  • Character.isDigit(), isUpperCase(), isLowerCase() analizează caracterul extras.

Rețineți ! 
A se acorda o deosebită atenție atunci când lucrați cu operatorul de concatenare +. Se va ține cont de următoarele reguli:
1. Dacă ambii operanzi sunt numerici operatorul + va efectua operația de adunare.
2. Dacă unul din operanzi este String operatorul + va efectua concatenarea.
3. Expresia este evaluată de la stânga la dreapta.

De exemplu:
String s1 = "Hello";
int a = 3;
String s2 ="4";
String s3 ="4";
System.out.println(a+s1); // 3Hello
System.out.println(s1+a); // Hello3
System.out.println(s2+s3); // 44
System.out.println(1+2); // 3
System.out.println("a"+"b"); // ab
System.out.println("a"+3); // a3
System.out.println("a"+3+4); // a34
System.out.println(3+"a"); // 3a
System.out.println(3+4+"a"+6+1); // 7a61
System.out.println("a"+6+1); // a61
System.out.println(6+1+"a"); // 7a


Restricții impuse de limbaj

Obiectele de tip String sunt imutabile adică conținutul nu poate fi modificat după creare

String s = "abc";
s = s + "d";
// se creează un obiect nou

Accesarea caracterelor se face doar prin metode, nu prin index direct:
char c = s.charAt(0);
 
Metode pentru conversii

String t = String.valueOf(456); - convertește valoarea de tip întreg în șir de caractere

int x = Integer.parseInt("123"); - convertește un șir de caractere în valoare întreagă.

luni, 29 septembrie 2025

Instrucțiuni de decizie în Limbajul Java

 Instrucțiunea if-else

Sintaxă:                                    

if (expresie) {

... lista instrucțiuni }

else  {

... lista instrucțiuni }

Semantică:

Se evaluează expresia dintre paranteze care trebuie sa returneze o valoare booleană. Dacă ea returnează true atunci se execută lista de instrucțiuni din corpul if. Dacă ea returnează false se execută lista de instrucțiuni else.

 

Exemplu:

int x = 4;

if( x % 2 == 0 )

x = 100;

else

x = 1000;             

Instrucțiunea if  poate avea mai multe forme:






Instrucțiunea switch-case

Sintaxă:

switch (expresie) {

   case valoare_particulara1 : < expresie 1 >    break;

   case valoare_particulara2 : < expresie 2 >    break;

    …

   default : < expresie >

  }

Semantică:

Execuţia instrucțiunii switch începe întotdeauna prin evaluarea expresiei dintre parantezele rotunde. Această expresie trebuie să fie de tipul caracter, octet, întreg scurt sau întreg. Selectorul instrucțiunii switch poate fi și de tip String începând cu versiunea Java 7.

 După evaluarea expresiei se trece la compararea valorii rezultate cu valorile particulare specificate în etichetele case din interiorul blocului de instrucțiuni. Dacă una dintre valorile particulare este egală cu valoarea expresiei, se execută instrucțiunile începând de la eticheta case corespunzătoare acelei valori în jos, până la capătul blocului. Dacă nici una dintre valorile particulare specificate nu este egală cu valoarea expresiei, se execută instrucțiunile care încep cu eticheta default, dacă aceasta există.

Este important ca fiecare expresie de tip case să fie terminată cu instrucțiunea break deoarece aceasta asigura ieșirea din structură.

Notă!

1.     Constantele case trebuie să fie de același tip ca și selectorul.

2.     Nu pot exista 2 constante case cu același nume.

3.     Cel mult o constantă poate fi asociată unui selector.

 

Exemplu switch cu selector de tip int:


public class Main{

  public static void main(String[] args) {

   int selector = 2;

    switch(selector){

     case 1:

       System.out.println("Valoarea este egala cu 1");

     break;

     case 2:

       System.out.println("Valoarea este egala cu 2");

     break;

     case 3:

       System.out.println("Valoarea este egala cu 3");

     break;

     case 4:

       System.out.println("Valoarea este egala cu 4");

     break;

   default:

      System.out.println("Valoarea nu aparține intervalului");

    }

}}



Rezultat: 


Exemplu switch cu break omis:


public class Main{

  public static void main(String[] args) {

   int selector = 6;

    switch(selector){

     case 2:

     case 4:

     case 6:

     case 8:

       System.out.println("Numar par");

     break;

   default:

      System.out.println("Numar impar");

    }

}}


Rezultat: 


Notă! Într-un switch, dacă nu pui break, programul continuă să execute și instrucțiunile din cazurile următoare. Acest comportament se numește fall-through.

Poate fi util pentru a grupa cazuri similare, dar dacă uiți break din greșeală, programul poate produce rezultate neașteptate. 



Exemplu switch cu selector de tip String:


public class Main{

  public static void main(String[] args) {

  String luna = "Iunie";

  switch (luna) {

    case "Iunie":

    case "Iulie":

    case "August":

       System.out.println("E vară");

    break;

   default:

    System.out.println("Nu e vară");

}

}} 




Exemplu de expresie cu switch: Începând cu Java 12, instrucțiunea switch a fost extinsă și poate fi folosită nu doar ca o structură de control, ci și ca o expresie care returnează o valoare. 
Asta înseamnă că putem atribui direct rezultatul unui switch unei variabile. 

public class Main{
  public static void main(String[] args) {
   int valoare = 3;
   String rezultat = switch (valoare) {
    case 1 -> "unu";
    case 2 -> "doi";
    case 3, 4 -> "trei sau patru";
    default -> "alt număr";
     };
System.out.println(rezultat);
}}



Să aveți o zi deosebită!
❤️