...
Pregătire interviuri

100 de întrebări de interviu Java, cu răspunsuri

Întrebările despre Java care apar des la interviurile tehnice, fiecare cu un răspuns scurt, explicația pe larg și ce urmărește intervievatorul. Citește-le sau exersează cu răspunsurile ascunse. Înveți de la zero cu Curs Java: primele 15 lecții sunt gratuite.

Pagină coordonată de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la

  • 100întrebări
  • 50junior
  • 35mid
  • 15senior
  • 140 minde citit
Întrebări de interviu Java cu răspunsuri

La un interviu în care se verifică limbajul Java, întrebările vin de obicei în trei forme: teorie scurtă („care e diferența dintre...”), fragmente de cod pe care trebuie să le citești și să spui ce afișează sau unde e bug-ul, și exerciții de scris cod live, în editor sau pe o platformă online. Uneori primești și o temă de casă, iar discuția de după pornește de la deciziile tale din cod. Subiectele recurente sunt tipurile de date și conversiile, String, OOP, contractul equals/hashCode, colecțiile și genericele, excepțiile, lambda și Stream API, concurența, JVM-ul și noutățile din Java 17 și 21.

La nivel de junior, intervievatorul vrea să vadă că știi limbajul corect: că un cod de cinci linii îl citești fără greșeală, că alegi colecția potrivită și că scrii un algoritm simplu curat, cu cazurile limită tratate. La nivel de mid, întrebările merg spre „de ce”: ce garanții oferă un API, ce se întâmplă sub încărcare, cum depanezi o problemă din producție, ce s-a schimbat între versiuni. La senior apar memory model-ul, JIT-ul, migrările și deciziile de design.

Fiecare întrebare are un răspuns scurt, bun de spus în primele secunde, și unul detaliat, cu explicația și codul de care ai nevoie ca să răspunzi la întrebările de continuare. Încearcă întâi să răspunzi singur, mai ales la întrebările cu cod, apoi compară. Rulează exemplele în jshell sau în IDE: diferența dintre „am citit” și „am văzut cum rulează” se simte la interviu. Pentru Spring, SQL, Git și arhitectură, vezi pagina de întrebări pentru meseria de Java Developer.

Tipuri, operatori și conversii

1 Junior

Ce afișează codul următor?

JAVA
int a = 5 / 2;
double b = 5 / 2;
double c = 5 / 2.0;
int d = -7 / 2;
int e = -7 % 2;
System.out.println(a + " " + b + " " + c + " " + d + " " + e);

Răspuns scurt: Afișează 2 2.0 2.5 -3 -1. Când ambii operanzi sunt întregi, împărțirea este întreagă și trunchiază spre zero, iar restul păstrează semnul deîmpărțitului.

Regula de bază: tipul rezultatului unei operații aritmetice se decide după tipurile operanzilor, nu după variabila în care pui rezultatul. 5 / 2 are doi operanzi int, deci se face împărțire întreagă și rezultatul este 2. Abia apoi valoarea 2 este convertită la double pentru atribuire, de aceea b devine 2.0, nu 2.5.

Ca să obții o împărțire reală, cel puțin un operand trebuie să fie double sau float: 5 / 2.0, 5.0 / 2 sau (double) 5 / 2. Atenție la (double) (5 / 2): aici paranteza se calculează întâi, tot întreg, deci rezultatul rămâne 2.0.

În Java, împărțirea întreagă trunchiază spre zero, nu rotunjește în jos. De aceea -7 / 2 dă -3, nu -4. Operatorul % respectă relația (a / b) * b + a % b == a, deci -7 % 2 dă -1. Asta strică verificări de forma n % 2 == 1 pentru numere negative impare:

JAVA
boolean impar = n % 2 != 0;            // corect și pentru negative
int restPozitiv = Math.floorMod(-7, 2); // 1
int catInJos = Math.floorDiv(-7, 2);    // -4

Împărțirea întreagă la zero aruncă ArithmeticException, pe când 5.0 / 0 dă Infinity, iar 0.0 / 0 dă NaN.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi că tipul operanzilor decide operația. Greșeala tipică este să crezi că double b = 5 / 2 dă 2.5 sau că -7 / 2 rotunjește în jos.

Eroarea, în practică:possible lossy conversion from double to int

2 Junior

Ce afișează acest cod și cum ai detecta depășirea?

JAVA
int max = Integer.MAX_VALUE;
System.out.println(max + 1);
System.out.println(Math.abs(Integer.MIN_VALUE));
long gresit = 1_000_000 * 1_000_000;
System.out.println(gresit);

Răspuns scurt: Afișează -2147483648, apoi tot -2147483648, apoi -727379968. Aritmetica pe int și long nu verifică depășirea (overflow): valoarea „se dă peste cap” în tăcere. Pentru detecție folosești Math.addExact, Math.multiplyExact sau long.

Tipul int are 32 de biți în complement față de doi, cu intervalul de la -2147483648 la 2147483647. Când depășești maximul, bitul de semn se setează și rezultatul devine cel mai mic număr negativ. Java nu aruncă nicio excepție, comportamentul este definit de specificație, nu e o eroare la rulare.

Math.abs(Integer.MIN_VALUE) este o capcană clasică: valoarea pozitivă 2147483648 nu încape în int, așa că rezultatul rămâne negativ. De aceea un cod de tipul Math.abs(hash) % n poate produce un index negativ; varianta sigură este Math.floorMod(hash, n).

Al treilea caz: 1_000_000 * 1_000_000 este calculat ca int (ambii literali sunt int), depășește, și abia apoi rezultatul greșit este lărgit la long. Soluția este ca măcar un operand să fie long: 1_000_000L * 1_000_000.

Când depășirea trebuie tratată ca eroare (sume de bani, contoare, dimensiuni), folosești metodele exacte:

JAVA
int total = Math.addExact(a, b);        // ArithmeticException la overflow
long produs = Math.multiplyExact(x, y);
int sigur = Math.toIntExact(valoareLong);

Pentru valori care pot fi oricât de mari există BigInteger. Underscore-ul din literali (1_000_000) există din Java 7 și ajută doar la citire.

Ce urmărește intervievatorul: Se verifică dacă știi limitele tipurilor primitive și că Java nu semnalează overflow-ul. Mulți candidați nu știu de Math.abs(Integer.MIN_VALUE) sau de literalul L lipsă.

Eroarea, în practică:integer number too largeArithmeticException: integer overflow

3 Junior

De ce 0.1 + 0.2 == 0.3 este false în Java? Cum compari corect două valori double?

Răspuns scurt: Pentru că double reprezintă numerele în baza 2, iar 0.1 și 0.2 nu au reprezentare exactă: suma lor este 0.30000000000000004. Compari cu o toleranță (Math.abs(a - b) < eps) sau folosești BigDecimal când contează exactitatea.

double și float urmează standardul IEEE 754: un număr este stocat ca mantisă și exponent în baza 2. Fracțiile care în baza 10 sunt „rotunde” (0.1, 0.2) devin în baza 2 fracții periodice, deci se stochează doar o aproximare. Erorile mici se adună, iar System.out.println(0.1 + 0.2) afișează 0.30000000000000004.

Consecința practică: nu folosești == pe valori calculate în virgulă mobilă. Compari cu o toleranță aleasă după domeniu:

JAVA
static boolean aproapeEgal(double a, double b) {
    return Math.abs(a - b) < 1e-9;
}

Pentru valori foarte mari sau foarte mici, o toleranță absolută nu e potrivită și se folosește una relativă, raportată la mărimea numerelor.

Alte capcane utile la interviu:

  • Double.NaN == Double.NaN este false; verifici cu Double.isNaN(x).
  • 0.0 == -0.0 este true, dar Double.valueOf(0.0).equals(-0.0) este false.
  • (int) 3.99 dă 3, conversia trunchiază; pentru rotunjire folosești Math.round.

Pentru bani, procente aplicate la sume și orice calcul care trebuie să iasă exact în baza 10, alegerea corectă este BigDecimal, construit din String sau cu BigDecimal.valueOf, ori sume întregi în bani (subdiviziuni) stocate în long.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că înțelegi de ce apare eroarea, nu doar că „double nu e precis”. Greșeala tipică este folosirea double pentru prețuri.

4 Junior

De ce prima linie nu compilează, iar a doua da?

JAVA
byte b = 10;
b = b + 1;   // eroare
b += 1;      // compilează

Răspuns scurt: În expresia b + 1, byte este promovat automat la int, iar un int nu poate fi atribuit unui byte fără cast explicit. Operatorii compuși precum += conțin însă un cast implicit înapoi la tipul variabilei.

Java aplică promovarea numerică la operațiile aritmetice: operanzii de tip byte, short și char sunt convertiți la int înainte de calcul. Deci b + 1 are tipul int, iar compilatorul refuză atribuirea int către byte cu mesajul „possible lossy conversion from int to byte”, pentru că valoarea ar putea să nu încapă în 8 biți.

Specificația spune că b += 1 este echivalent cu b = (byte) (b + 1). Cast-ul ascuns face ca linia să compileze, dar te expune la depășire fără avertisment:

JAVA
byte b = 127;
b += 1;            // b devine -128
short s = 10;
s *= 1000;         // compilează, dar 10000 încape; s *= 10000 ar depăși

Regulile generale de conversie:

  • Lărgirea (int la long, long la double) este automată. Atenție, long la double și int la float pot pierde precizie, deși sunt considerate lărgiri.
  • Îngustarea (double la int, int la byte) cere cast explicit și poate pierde date.
  • O constantă care încape este acceptată fără cast: byte x = 10; compilează, byte y = 200; nu.

char este un tip numeric fără semn pe 16 biți, de aceea char c = 'a'; c + 1 este tot int, iar c++ funcționează pentru că operatorii de incrementare au și ei cast implicit.

Ce urmărește intervievatorul: Se verifică cunoașterea promovării numerice și a cast-ului ascuns din operatorii compuși. Mulți candidați nu știu că += poate produce overflow fără nicio eroare.

Eroarea, în practică:possible lossy conversion from double to int

5 Junior

Ce afișează următoarele linii?

JAVA
System.out.println(1 + 2 + "3" + 4 + 5);
System.out.println('a' + 'b');
System.out.println("" + 'a' + 'b');
System.out.println('a' + 1);
System.out.println((char) ('a' + 1));

Răspuns scurt: Afișează 3345, 195, ab, 98 și b. Operatorul + se evaluează de la stânga la dreapta: cât timp ambii operanzi sunt numere sau char, face adunare; din momentul în care unul este String, face concatenare.

+ are două sensuri în Java: adunare numerică și concatenare de String. Decizia se ia pentru fiecare pereche de operanzi, în ordinea de evaluare de la stânga la dreapta.

Pentru 1 + 2 + "3" + 4 + 5: întâi 1 + 2 dă 3 (numere), apoi 3 + "3" dă "33" (apare un String), apoi "33" + 4 dă "334" și "334" + 5 dă "3345". Dacă vrei suma lui 4 și 5 în text, pui paranteze: "3" + (4 + 5) dă "39".

char este un tip numeric (codul UTF-16 al caracterului). 'a' + 'b' înseamnă 97 + 98, deci 195, de tip int. Când începi cu "", prima operație devine concatenare și restul la fel, de aceea obții "ab". Similar, 'a' + 1 dă 98, iar cast-ul la char îl transformă înapoi în caracterul 'b'.

Aceeași logică explică un bug frecvent în mesaje de log:

JAVA
int x = 2, y = 3;
System.out.println("Suma este " + x + y);   // Suma este 23
System.out.println("Suma este " + (x + y)); // Suma este 5

Pentru construirea de text cu multe valori, String.format sau "...".formatted(...) (Java 15) fac intenția mai clară și evită complet această clasă de greșeli.

Ce urmărește intervievatorul: Este o întrebare de atenție la detalii: verifică ordinea de evaluare și faptul că char e numeric. Candidații greșesc de obicei la 'a' + 'b'.

6 Junior

Ce afișează codul următor? Explică diferența dintre i++ și ++i.

JAVA
int i = 5;
i = i++;
System.out.println(i);
int j = 5;
int k = j++ + ++j;
System.out.println(j + " " + k);

Răspuns scurt: Afișează 5, apoi 7 12. i++ întoarce valoarea veche și apoi incrementează, ++i incrementează întâi și întoarce valoarea nouă. La i = i++, valoarea veche (5) suprascrie incrementarea.

Ambii operatori măresc variabila cu 1, diferența este valoarea expresiei:

  • i++ (post-incrementare): expresia valorează cât era i înainte, apoi i crește.
  • ++i (pre-incrementare): i crește întâi, iar expresia valorează noua valoare.

La i = i++ pașii sunt: se reține valoarea veche 5, i devine 6, apoi atribuirea pune în i valoarea reținută, 5. Rezultatul este că incrementarea se pierde. Codul compilează, iar unele IDE-uri îl semnalează ca suspect.

La int k = j++ + ++j, Java evaluează strict de la stânga la dreapta (spre deosebire de C, unde astfel de expresii au comportament nedefinit):

  • j++ valorează 5, iar j devine 6;
  • ++j face j egal cu 7 și valorează 7;
  • k = 5 + 7 = 12.

În cod real, astfel de expresii sunt de evitat. Folosește incrementarea ca instrucțiune separată (i++;) sau în bucla for, unde forma nu contează:

JAVA
for (int x = 0; x < 3; x++) { }  // la fel ca ++x aici

Unde contează: arr[index++] = valoare; pune valoarea pe poziția curentă și abia apoi avansează indexul, un tipar frecvent când construiești un tablou rezultat.

Ce urmărește intervievatorul: Verifică dacă înțelegi valoarea unei expresii versus efectul ei secundar. Mulți răspund greșit „6” la i = i++.

7 Junior

Care este diferența dintre && și &? Ce se întâmplă la rularea codului de mai jos?

JAVA
int x = 0;
if (x != 0 && 10 / x > 1) System.out.println("A");
if (x != 0 & 10 / x > 1) System.out.println("B");

Răspuns scurt: && este „și” logic cu scurtcircuitare: dacă partea stângă e false, nu mai evaluează dreapta. & evaluează mereu ambele părți. Prima condiție e sigură, a doua aruncă ArithmeticException (împărțire la zero).

Pe valori boolean, && și & dau același rezultat logic, dar diferă la evaluare. Scurtcircuitarea (short-circuit evaluation) înseamnă că && se oprește când rezultatul e deja cunoscut: false && orice este false. La fel, || se oprește la primul true. Operatorii & și | evaluează ambii operanzi, întotdeauna.

În exemplu, la prima condiție x != 0 este false, deci 10 / x nu se mai calculează. La a doua, ambele părți se evaluează, iar 10 / 0 aruncă ArithmeticException: / by zero. Precedența este și ea relevantă: & are prioritate mai mică decât != și >, așa că expresia se citește (x != 0) & ((10 / x) > 1).

Scurtcircuitarea este folosită intenționat pentru gărzi:

JAVA
if (nume != null && !nume.isBlank()) { ... }
if (lista.isEmpty() || lista.get(0) == null) { ... }

Ordinea contează: !nume.isBlank() && nume != null aruncă NullPointerException când nume e null.

Când are sens & pe boolean? Rar, când ambele părți au efecte secundare care trebuie executate (de exemplu două validări care raportează fiecare erori). Pe valori întregi, &, | și ^ sunt operatori pe biți, cu alt rol: flags & MASCA.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi scurtcircuitarea și o folosești pentru gărzi de null. Greșeala tipică este ordinea inversată a condițiilor.

Eroarea, în practică:ArithmeticException: / by zero

8 Junior

De ce primul fragment nu compilează, iar al doilea afișează 0 null false?

JAVA
void metoda() {
    int total;
    System.out.println(total);
}
JAVA
class Contor {
    int valoare; String nume; boolean activ;
}
Contor c = new Contor();
System.out.println(c.valoare + " " + c.nume + " " + c.activ);

Răspuns scurt: Variabilele locale nu primesc valoare implicită: compilatorul cere să fie atribuite înainte de citire. Câmpurile unei clase și elementele unui tablou sunt inițializate automat cu 0, false, '\u0000' sau null.

Java tratează diferit variabilele locale și câmpurile.

Variabilele locale (din metode, blocuri, parametri de buclă) nu au valoare implicită. Compilatorul face o analiză numită „definite assignment” și refuză codul dacă există vreun drum prin care variabila e citită înainte de atribuire: „variable total might not have been initialized”. Analiza ține cont și de ramuri:

JAVA
int r;
if (conditie) r = 1;
System.out.println(r);   // eroare: pe ramura else, r nu are valoare

Câmpurile (de instanță sau statice) și elementele tablourilor sunt inițializate automat de JVM cu valoarea „zero” a tipului: 0 pentru numere, 0.0 pentru double, false pentru boolean, caracterul nul pentru char și null pentru orice referință. Așa se explică 0 null false.

Excepție: câmpurile final trebuie atribuite explicit exact o dată, la declarare, într-un bloc de inițializare sau în fiecare constructor, altfel codul nu compilează.

De ce diferența? Pentru variabile locale, compilatorul poate verifica static fluxul. Pentru câmpuri, ordinea apelurilor între metode nu poate fi verificată la compilare, așa că JVM-ul garantează măcar o stare cunoscută. Practic, valorile implicite ascund uneori buguri: un câmp String uitat neinițializat duce mai târziu la NullPointerException, de aceea e bine să inițializezi câmpurile în constructor.

Ce urmărește intervievatorul: Se verifică diferența dintre variabile locale și câmpuri. Candidații spun des că „toate variabilele au valoare implicită”.

Eroarea, în practică:variable might not have been initialized

9 Junior

Unde poți folosi var în Java și unde nu? Care dintre liniile de mai jos compilează?

JAVA
var lista = new ArrayList<String>();
var x;
var y = null;
var numere = {1, 2, 3};
var f = (String s) -> s.length();

Răspuns scurt: Compilează doar prima linie. var (din Java 10) cere o variabilă locală cu inițializator din care compilatorul poate deduce tipul. Nu merge fără inițializare, cu null, cu inițializator de tablou fără new sau cu lambda fără tip țintă.

var înseamnă inferență de tip pentru variabile locale: compilatorul deduce tipul static din expresia din dreapta. Tipul rămâne fix, Java nu devine limbaj dinamic. var lista = new ArrayList<String>(); are tipul ArrayList<String> și nu poți atribui ulterior altceva.

De ce celelalte nu compilează:

  • var x; nu are din ce deduce tipul.
  • var y = null; ar avea tipul null, care nu e util, deci e interzis.
  • var numere = {1, 2, 3}; inițializatorul de tablou are nevoie de tipul declarat; merge var numere = new int[]{1, 2, 3};.
  • Lambda și referințele la metode au nevoie de un tip țintă (interfața funcțională), pe care var nu îl oferă.

Unde e permis: variabile locale cu inițializare, variabila din for și for-each, resursele din try-with-resources și, din Java 11, parametrii unui lambda ((var a, var b) -> a + b, util când vrei adnotări pe parametri). Nu se poate folosi la câmpuri, parametri de metodă sau tip returnat.

var nu e cuvânt rezervat clasic, ci „nume de tip rezervat”, deci o variabilă numită var încă e permisă.

O capcană: var lista = new ArrayList<>(); deduce ArrayList<Object>. Recomandarea uzuală este să folosești var când tipul e evident din dreapta și să-l eviți când ascunde informație, de exemplu var rezultat = serviciu.proceseaza();.

Ce urmărește intervievatorul: Verifică dacă știi că var este inferență statică, nu tipare dinamică, și care sunt limitele ei. Greșeala frecventă: diamondul gol cu var.

Eroarea, în practică:cannot infer type for local variable'var' is not allowed here

10 Mid

Ce afișează codul următor? Cum verifici rapid dacă un număr este putere a lui 2?

JAVA
System.out.println(-8 >> 1);
System.out.println(-8 >>> 1);
System.out.println(5 & 3);
System.out.println(5 | 3);
System.out.println(5 ^ 3);
System.out.println(1 << 33);

Răspuns scurt: Afișează -4, 2147483644, 1, 7, 6 și 2. >> păstrează semnul, >>> umple cu zero. Un n > 0 este putere a lui 2 dacă (n & (n - 1)) == 0.

Operatorii pe biți lucrează pe reprezentarea în complement față de doi:

  • >> este deplasare aritmetică la dreapta: bitul de semn se copiază, deci -8 >> 1 este -4 (echivalent cu împărțirea la 2 rotunjită în jos).
  • >>> este deplasare logică: în stânga intră zerouri. -8 este 0xFFFFFFF8; deplasat cu 1 devine 0x7FFFFFFC, adică 2147483644.
  • 5 & 3: 101 & 011 = 001, adică 1. 5 | 3 = 111 = 7. 5 ^ 3 = 110 = 6.
  • 1 << 33 nu dă 0: pentru int, distanța de deplasare se ia modulo 32, deci e de fapt 1 << 1 = 2. Pentru long, modulo 64.

Verificarea puterii lui 2 se bazează pe faptul că o putere a lui 2 are un singur bit de 1, iar n - 1 are toți biții de sub el setați:

JAVA
static boolean estePutereA2(int n) {
    return n > 0 && (n & (n - 1)) == 0;
}

Alternativa din bibliotecă este Integer.bitCount(n) == 1. Alte utilizări practice: flag-uri combinate într-un int (perm & CITIRE), calculul indexului în tabele de dimensiune putere a lui 2 (hash & (n - 1), folosit de HashMap), extragerea unui octet ((x >>> 8) & 0xFF). Pentru byte, & 0xFF transformă valoarea în interval 0–255, pentru că byte are semn.

În codul de business, preferă EnumSet în locul flag-urilor pe biți: e la fel de eficient și mult mai lizibil.

Ce urmărește intervievatorul: Verifică înțelegerea reprezentării binare și a diferenței dintre >> și >>>. Puțini candidați știu că deplasarea se face modulo 32.

11 Mid

Un client raportează că totalul facturii generate de aplicația voastră diferă cu un ban față de calculul lui. Cum investighezi și cum repari?

Răspuns scurt: Reproduc cazul cu datele exacte, verific tipul folosit pentru sume (de obicei double) și regula de rotunjire: pe fiecare linie sau pe total, HALF_UP sau HALF_EVEN. Repar cu BigDecimal construit din String, cu scală și RoundingMode explicite, plus teste.

Un răspuns structurat urmează pașii unei investigații reale:

  • Reproduc: iau factura exactă (cantități, prețuri, TVA, discount) și o recalculez într-un test unitar, ca să văd unde apare diferența.
  • Verific tipul: dacă sumele sunt double, erorile de reprezentare în baza 2 produc valori ca 2.675 stocat drept 2.67499999..., care se rotunjesc greșit.
  • Verific regula de business: rotunjești TVA-ul pe fiecare linie sau pe total? Folosești rotunjire „comercială” (HALF_UP) sau „bancară” (HALF_EVEN)? Diferențele de un ban vin des de aici, nu doar din tip. Regula trebuie confirmată cu cineva din business sau contabilitate.

Repararea tehnică:

JAVA
BigDecimal pret = new BigDecimal("19.99");
BigDecimal cantitate = BigDecimal.valueOf(3);
BigDecimal cotaTva = new BigDecimal("0.19");
BigDecimal linie = pret.multiply(cantitate);
BigDecimal tva = linie.multiply(cotaTva).setScale(2, RoundingMode.HALF_UP);

Capcane BigDecimal: new BigDecimal(0.1) preia eroarea din double (folosește String sau BigDecimal.valueOf); equals ține cont de scală (2.0 diferit de 2.00), deci compari cu compareTo; divide fără scală aruncă ArithmeticException la rezultate periodice, așa că dai mereu scala și RoundingMode.

La final adaug teste pentru cazurile limită (valori .5, multe linii mici), verific dacă și baza de date folosește DECIMAL, nu FLOAT, și comunic clientului cauza și corecția.

Ce urmărește intervievatorul: Intervievatorul urmărește un proces de depanare ordonat și cunoașterea BigDecimal. Greșeala tipică este să sari direct la „schimb în BigDecimal” fără să clarifici regula de rotunjire.

Eroarea, în practică:BigDecimal: Non-terminating decimal expansion

String și lucrul cu text

12 Junior

Ce afișează codul următor și de ce?

JAVA
String s = "java";
s.toUpperCase();
s.concat(" 21");
s.replace('j', 'J');
System.out.println(s);

Răspuns scurt: Afișează java. Metodele lui String nu modifică obiectul, ci întorc un String nou. Dacă rezultatul nu este atribuit, se pierde. Corect: s = s.toUpperCase();.

String este imuabil: odată creat, conținutul lui nu se mai schimbă. Orice metodă care pare că modifică textul (toUpperCase, concat, replace, trim, substring) construiește un obiect nou și îl întoarce. În exemplu, cele trei rezultate sunt create și imediat aruncate, iar s indică tot spre "java".

Variantele corecte:

JAVA
String s = "java";
s = s.toUpperCase();          // "JAVA"
String t = s.concat(" 21");   // "JAVA 21", s rămâne "JAVA"
String u = "java".replace('j', 'J').concat(" 21"); // "Java 21"

Metodele se pot înlănțui tocmai pentru că fiecare întoarce un String nou.

Aceeași greșeală apare cu alte tipuri imuabile din JDK: BigDecimal, LocalDate, Integer. De exemplu data.plusDays(1); fără atribuire nu schimbă data, iar suma.add(x); nu schimbă suma. Uneltele de analiză statică (SpotBugs, Sonar, avertismentele din IntelliJ) semnalează „return value ignored” tocmai pentru aceste cazuri.

Contrastul util la interviu: StringBuilder este mutabil, deci sb.append("x") modifică obiectul existent și întoarce aceeași instanță (pentru înlănțuire). Dacă cineva tratează un StringBuilder ca pe un String sau invers, apar buguri subtile.

Ce urmărește intervievatorul: Verifică dacă înțelegi imuabilitatea în practică, nu doar ca definiție. Greșeala clasică este apelul fără atribuire.

13 Junior

Ce întorc expresiile de mai jos? Care dintre ele aruncă excepție?

JAVA
String t = "programare";
t.substring(3);
t.substring(3, 6);
t.indexOf('r');
t.lastIndexOf('r');
t.indexOf("z");
t.charAt(10);
t.substring(6, 3);

Răspuns scurt: "gramare", "gra", 1, 8, -1, apoi două excepții: charAt(10) aruncă StringIndexOutOfBoundsException (indicii merg de la 0 la 9), iar substring(6, 3) la fel, pentru că începutul e după sfârșit.

Reguli de reținut pentru metodele de bază:

  • Indicii încep de la 0. Pentru "programare" (10 caractere), ultimul index valid este 9.
  • substring(inceput) ia de la inceput până la final. substring(inceput, sfarsit) include inceput și exclude sfarsit, deci lungimea rezultatului este sfarsit - inceput. substring(3, 6) ia indicii 3, 4, 5: "gra".
  • indexOf întoarce prima poziție, lastIndexOf ultima, iar -1 când nu găsește. Nu aruncă excepție.
  • substring(i, i) întoarce "", valid. substring(10) pe un text de 10 caractere întoarce tot "".
  • Indici negativi, mai mari decât lungimea sau inceput > sfarsit aruncă StringIndexOutOfBoundsException.

Un tipar frecvent la exerciții este extragerea unei părți dintre doi delimitatori, unde trebuie tratat cazul -1:

JAVA
static String domeniu(String email) {
    int at = email.indexOf('@');
    if (at < 0 || at == email.length() - 1) {
        throw new IllegalArgumentException("Email invalid: " + email);
    }
    return email.substring(at + 1);
}

Fără verificare, indexOf întoarce -1 și substring(0) dă tot textul, un bug tăcut. Există și indexOf(ch, deLa) pentru a căuta toate aparițiile într-o buclă, iar contains, startsWith și endsWith sunt mai clare când ai nevoie doar de răspuns da/nu.

Ce urmărește intervievatorul: Se verifică precizia cu indicii, mai ales capătul exclus la substring. Candidații uită să trateze -1 de la indexOf.

Eroarea, în practică:StringIndexOutOfBoundsException

14 Junior

Ce lungimi au tablourile rezultate?

JAVA
"a,b,,c,,".split(",").length;
"a,b,,c,,".split(",", -1).length;
"1.2.3".split(".").length;
"".split(",").length;
"  unu   doi ".trim().split("\\s+").length;

Răspuns scurt: 4, 6, 0, 1 și 2. split elimină șirurile goale de la final (dacă nu dai limită negativă), primește o expresie regulată (deci . înseamnă „orice caracter”) și pe textul gol întoarce un tablou cu un element gol.

split are câteva comportamente care surprind:

  • Golurile de la final dispar. "a,b,,c,,".split(",") dă ["a", "b", "", "c"]: golul din mijloc rămâne, cele două de la final sunt eliminate. Cu limită negativă, split(",", -1), toate se păstrează și obții 6 elemente. Asta contează la parsarea CSV-urilor, unde ultimele coloane pot fi goale.
  • Argumentul este regex. "." înseamnă orice caracter, deci fiecare caracter devine separator, toate bucățile sunt goale și, fiind „de la final”, sunt eliminate: tablou gol. Corect: split("\\.") sau split(Pattern.quote(".")). La fel pentru |, *, +, ?, $.
  • Textul gol produce [""], nu un tablou gol, deci lungime 1.
  • Spații multiple: "\\s+" tratează orice secvență de spații albe ca un singur separator. Fără trim(), un spațiu la început produce un prim element "".

Pentru separatori ficși folosiți des, Pattern.compile o singură dată evită recompilarea regex-ului la fiecare apel:

JAVA
private static final Pattern VIRGULA = Pattern.compile(",");
String[] campuri = VIRGULA.split(linie, -1);

Pentru CSV real (ghilimele, virgule în interiorul valorilor), split nu este suficient și se folosește o bibliotecă dedicată, de exemplu OpenCSV sau Apache Commons CSV.

Ce urmărește intervievatorul: Intervievatorul verifică dacă ai lucrat efectiv cu parsare de text. Greșeala frecventă este split(".") sau pierderea coloanelor goale de la final.

Eroarea, în practică:PatternSyntaxException: Dangling meta characterPatternSyntaxException: trailing backslash

15 Junior

Care este diferența dintre trim() și strip(), și dintre isEmpty() și isBlank()?

Răspuns scurt: trim() elimină de la capete caracterele cu cod până la U+0020, strip() (Java 11) elimină orice spațiu alb Unicode. isEmpty() verifică lungimea zero, isBlank() (Java 11) verifică dacă textul conține doar spații albe.

trim() există de la început și consideră spațiu alb orice caracter cu codul mai mic sau egal cu U+0020 (spațiu, tab, newline și alte caractere de control). strip(), introdus în Java 11, folosește Character.isWhitespace, deci recunoaște și spațiile Unicode, de exemplu em space (U+2003), care apar în texte copiate din documente sau pagini web:

JAVA
String s = " Ana ";
s.trim().length();   // 5, nu s-a eliminat nimic
s.strip().length();  // 3

Există și stripLeading() și stripTrailing() pentru o singură parte. Atenție: spațiul neseparabil (U+00A0,   din HTML) nu este considerat spațiu alb nici de strip(); pentru el ai nevoie de replace(' ', ' ') înainte.

isEmpty() întoarce true doar pentru "". isBlank() (Java 11) întoarce true și pentru " " sau "\n\t". Pentru validarea câmpurilor din formulare, isBlank() este aproape întotdeauna ce vrei:

JAVA
if (nume == null || nume.isBlank()) {
    throw new IllegalArgumentException("Numele este obligatoriu");
}

Ambele metode aruncă NullPointerException pe null, deci verificarea de null vine prima. Tot din Java 11 sunt utile repeat(n) și lines(), care împarte textul pe linii indiferent de tipul de terminator.

Ce urmărește intervievatorul: Verifică dacă știi API-ul modern din Java 11 și diferențele subtile de Unicode. Mulți folosesc isEmpty() unde trebuia isBlank().

16 Junior

Scrie o funcție care verifică dacă un text este palindrom, ignorând majusculele, spațiile și semnele de punctuație. De exemplu, „Ele fac cafele” trebuie să fie palindrom.

Răspuns scurt: Folosești doi indici, unul de la început și unul de la final, sari peste caracterele care nu sunt litere sau cifre și compari restul fără să ții cont de majuscule. Complexitate O(n) în timp și O(1) memorie suplimentară.

Varianta cu doi indici evită construirea unui text nou și se oprește la prima nepotrivire:

JAVA
static boolean estePalindrom(String text) {
    int st = 0, dr = text.length() - 1;
    while (st < dr) {
        char a = text.charAt(st), b = text.charAt(dr);
        if (!Character.isLetterOrDigit(a)) { st++; continue; }
        if (!Character.isLetterOrDigit(b)) { dr--; continue; }
        if (Character.toLowerCase(a) != Character.toLowerCase(b)) {
            return false;
        }
        st++;
        dr--;
    }
    return true;
}

Pentru „Ele fac cafele”, spațiile sunt sărite, iar literele comparate sunt elefaccafele, care se citește la fel în ambele sensuri.

Alternativa scurtă, acceptabilă la interviu dacă spui costul:

JAVA
String curat = text.replaceAll("[^\\p{L}\\p{N}]", "").toLowerCase();
return new StringBuilder(curat).reverse().toString().equals(curat);

Ea creează două texte noi și rulează un regex, deci folosește O(n) memorie suplimentară. \\p{L} înseamnă orice literă Unicode, inclusiv diacriticele, spre deosebire de [a-zA-Z].

Cazuri limită de menționat: textul gol și un singur caracter sunt palindroame; null trebuie tratat explicit (excepție sau false, după contract). Un intervievator poate întreba și despre diacritice: dacă „ă” și „a” trebuie considerate egale, normalizezi cu java.text.Normalizer și elimini semnele diacritice înainte de comparație.

Ce urmărește intervievatorul: Se verifică un algoritm simplu scris corect, cu cazuri limită. Greșeala tipică este să uiți majusculele sau să compari cu == obiecte String în loc de caractere.

17 Junior

Scrie o funcție care verifică dacă două cuvinte sunt anagrame (de exemplu „listen” și „silent”). Ce complexitate are soluția ta?

Răspuns scurt: Fie sortezi caracterele ambelor cuvinte și compari tablourile (O(n log n)), fie numeri frecvența fiecărui caracter într-un tablou sau Map și verifici că toate contoarele ajung la zero (O(n)).

Prima idee, simplă și corectă:

JAVA
static boolean suntAnagrameSortare(String a, String b) {
    if (a.length() != b.length()) return false;
    char[] x = a.toLowerCase().toCharArray();
    char[] y = b.toLowerCase().toCharArray();
    Arrays.sort(x);
    Arrays.sort(y);
    return Arrays.equals(x, y);
}

Sortarea costă O(n log n). Atenție la Arrays.equals: x == y sau x.equals(y) ar compara referințele tablourilor și ar întoarce mereu false.

Varianta liniară numără caracterele. Pentru alfabet restrâns (a–z) ajunge un tablou de 26:

JAVA
static boolean suntAnagrame(String a, String b) {
    if (a.length() != b.length()) return false;
    int[] f = new int[26];
    for (int i = 0; i < a.length(); i++) {
        f[a.charAt(i) - 'a']++;
        f[b.charAt(i) - 'a']--;
    }
    for (int v : f) if (v != 0) return false;
    return true;
}

Dacă textul poate conține diacritice, cifre sau alte caractere, tabloul de 26 nu mai e suficient și treci la Map<Character, Integer> cu merge(c, 1, Integer::sum), tot O(n), dar cu constantă mai mare din cauza boxing-ului.

La interviu merită clarificat întâi contractul: contează majusculele? Spațiile („dormitory” și „dirty room”)? Apoi spui care variantă alegi și de ce, în funcție de setul de caractere.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că pui întrebări de clarificare și cunoști compromisul sortare versus numărare. Mulți uită verificarea lungimii sau compară tablourile cu ==.

18 Junior

Scrie o funcție care întoarce primul caracter care nu se repetă într-un text (de exemplu, pentru „aabccdbe” rezultatul este d).

Răspuns scurt: Faci două treceri: în prima numeri aparițiile fiecărui caracter într-un LinkedHashMap sau într-un tablou de frecvențe, în a doua cauți primul caracter cu frecvența 1. Complexitatea este O(n).

Ideea cheie: ca să știi dacă un caracter se repetă, trebuie să fi văzut tot textul, deci o singură trecere de la stânga la dreapta nu ajunge fără memorie suplimentară. Două treceri liniare rămân O(n).

JAVA
static Optional<Character> primulUnic(String text) {
    Map<Character, Integer> frecv = new LinkedHashMap<>();
    for (char c : text.toCharArray()) {
        frecv.merge(c, 1, Integer::sum);
    }
    for (Map.Entry<Character, Integer> e : frecv.entrySet()) {
        if (e.getValue() == 1) return Optional.of(e.getKey());
    }
    return Optional.empty();
}

LinkedHashMap păstrează ordinea inserării, deci a doua trecere parcurge caracterele în ordinea primei apariții. Cu un HashMap obișnuit ordinea ar fi arbitrară și rezultatul greșit.

Varianta fără colecții, pentru text ASCII, folosește un tablou de 128 sau 256 de contoare și a doua trecere tot pe text:

JAVA
int[] f = new int[128];
for (int i = 0; i < text.length(); i++) f[text.charAt(i)]++;
for (int i = 0; i < text.length(); i++) {
    if (f[text.charAt(i)] == 1) return Optional.of(text.charAt(i));
}

Este mai rapidă (fără boxing) dar presupune un set de caractere limitat.

Întoarcerea unui Optional comunică clar cazul „nu există”, mai bine decât un caracter special sau null. Un detaliu: e.getValue() == 1 funcționează pentru că Integer este dezambalat la comparația cu un int.

Ce urmărește intervievatorul: Verifică alegerea structurii de date potrivite (ordinea contează). Greșeala tipică este HashMap în loc de LinkedHashMap sau o soluție O(n²) cu indexOf și lastIndexOf.

19 Mid

Ce afișează codul următor?

JAVA
String a = "Java";
String b = "Ja" + "va";
String c = "Ja";
String d = c + "va";
final String e = "Ja";
String f = e + "va";
System.out.println((a == b) + " " + (a == d) + " " + (a == f) + " " + (a == d.intern()));

Răspuns scurt: Afișează true false true true. Expresiile formate doar din constante la compilare sunt calculate de compilator și refolosesc literalul din pool. Concatenarea cu o variabilă care nu e constantă se face la rulare și creează un obiect nou; intern() întoarce instanța din pool.

Cheia este noțiunea de constantă la compilare (compile-time constant expression). O expresie formată doar din literali și variabile final de tip primitiv sau String, inițializate cu constante, este evaluată de javac. Rezultatul ajunge în fișierul .class ca un singur literal, iar literalii identici sunt aceeași instanță în pool.

  • "Ja" + "va" devine la compilare "Java", deci b este același obiect ca a: true.
  • c nu este final, deci c + "va" se calculează la rulare și produce un String nou: false.
  • e este final și inițializat cu literal, deci e constantă; e + "va" se calculează la compilare: true.
  • d.intern() caută în pool un șir egal și îl întoarce pe acela, adică a: true.

Detaliu important: dacă e ar fi final String e = metoda();, nu ar mai fi constantă la compilare, iar rezultatul ar fi false.

Aceeași regulă explică un comportament legat de dependențe: constantele public static final de tip String sau primitiv sunt copiate în clasele care le folosesc. Dacă schimbi valoarea în bibliotecă și nu recompilezi și clientul, acesta vede valoarea veche.

Concluzia practică rămâne aceeași: rezultatele lui == pe String depind de detalii de compilare, deci în cod compari conținutul cu equals. intern() are rar sens în aplicații; JVM-ul modern oferă deduplicarea automată a șirurilor la G1 cu -XX:+UseStringDeduplication.

Ce urmărește intervievatorul: Întrebarea separă candidații care știu cum lucrează compilatorul cu literalii de cei care au memorat doar „folosește equals”. Mulți ratează cazul cu final.

20 Mid

Ce sunt text blocks și ce afișează exemplul? Cum formatezi apoi textul cu valori?

JAVA
String json = """
    {
      "nume": "%s",
      "varsta": %d
    }
    """.formatted("Ana", 30);
System.out.print(json);

Răspuns scurt: Text blocks (standard din Java 15) sunt literali pe mai multe linii între """. Indentarea comună este eliminată automat, deci rezultatul începe cu { la coloana 0, conține valorile Ana și 30 și se termină cu newline.

Un text block începe cu """ urmat obligatoriu de un capăt de linie și se termină la următorul """. Compilatorul face trei lucruri:

  • elimină indentarea incidentală: găsește cea mai mică indentare dintre liniile cu conținut (inclusiv linia cu """ de închidere) și o scoate de pe toate liniile;
  • normalizează capetele de linie la \n, indiferent de sistemul pe care a fost scris fișierul;
  • interpretează secvențele escape (\n, \t, \").

În exemplu, liniile au 4 spații comune, care dispar. Pentru că """ de închidere este pe linie separată, textul se termină cu \n. Dacă ai pune """ imediat după }, nu ar exista newline final.

Două escape-uri noi, specifice text blocks: \ la final de linie lipește linia următoare (util pentru texte lungi fără newline), iar \s înseamnă un spațiu care nu e eliminat ca spațiu de final.

formatted(...) (Java 15) este echivalentul String.format(this, args). Specificatori utili: %s text, %d întreg, %.2f zecimal cu două zecimale, %5d aliniere la dreapta pe 5 caractere, %-10s aliniere la stânga, %n newline de platformă.

Atenție la Locale: String.format("%.2f", 3.5) folosește localizarea implicită, deci pe un sistem setat pe română poate afișa 3,50. Pentru JSON, CSV sau loguri parsate de alte programe, folosești String.format(Locale.ROOT, ...). Iar pentru JSON real, un serializator ca Jackson evită problemele de escaping.

Ce urmărește intervievatorul: Verifică dacă folosești facilitățile moderne ale limbajului și cunoști capcana de Locale. Mulți nu știu regula indentării sau a newline-ului final.

21 Mid

Ce afișează codul și de ce length() nu înseamnă întotdeauna „numărul de caractere”?

JAVA
String s = "A𝄞B";
System.out.println(s.length());
System.out.println(s.codePointCount(0, s.length()));
System.out.println(new StringBuilder(s).reverse().length());

Răspuns scurt: Afișează 4, 3 și 4. Java stochează textul în UTF-16, iar caracterele din afara planului de bază (multe simboluri, emoji) ocupă două unități char, o pereche surogat. length() numără unitățile char, nu caracterele vizibile.

char în Java are 16 biți și reprezintă o unitate UTF-16, nu un caracter Unicode complet. Unicode are peste un milion de puncte de cod (code points); cele de peste U+FFFF, de exemplu simbolul muzical U+1D11E din exemplu sau majoritatea emoji, se codifică prin două unități char numite pereche surogat (surrogate pair).

Prin urmare:

  • length() întoarce 4: A, două unități pentru simbol, B;
  • codePointCount întoarce 3, numărul real de puncte de cod;
  • charAt(1) întoarce doar jumătate din simbol, un char fără sens singur.

StringBuilder.reverse() tratează corect perechile surogat și nu le inversează între ele, deci rezultatul rămâne valid. O inversare manuală, caracter cu caracter, ar strica simbolul.

Când textul poate conține astfel de caractere (nume de utilizatori, mesaje, conținut din aplicații mobile), parcurgi pe puncte de cod:

JAVA
s.codePoints().forEach(cp ->
    System.out.println(Character.getName(cp)));
int nr = s.codePointCount(0, s.length());

Mai departe, ce vede utilizatorul ca „un caracter” poate fi format din mai multe puncte de cod (litere cu diacritice combinate, emoji compuse). Pentru tăierea textului la o lungime vizibilă se folosește BreakIterator.getCharacterInstance(). Pentru limitele din baza de date, contează în schimb numărul de octeți în UTF-8, care e alt număr: s.getBytes(StandardCharsets.UTF_8).length.

Ce urmărește intervievatorul: Este o întrebare care arată experiență cu text real, nu doar ASCII. Greșeala tipică este trunchierea cu substring la o lungime fixă, care poate tăia o pereche surogat.

Clase, moștenire și polimorfism

Exersează capitolul cu exerciții reale: Curs Java →
22 Junior

De ce nu compilează codul de mai jos? Propune două soluții.

JAVA
class Produs {
    private String nume;
    Produs(String nume) { this.nume = nume; }
}
class Carte extends Produs {
    Carte() { }
}
Produs p = new Produs();

Răspuns scurt: Compilatorul generează un constructor fără parametri doar dacă clasa nu declară niciun constructor. Produs are unul cu parametru, deci new Produs() nu există, iar Carte() cheamă implicit super(), care nu există nici el.

Regula constructorului implicit: dacă o clasă nu declară niciun constructor, compilatorul adaugă unul public (de fapt, cu același nivel de acces ca clasa), fără parametri și cu corp gol, care apelează super(). Imediat ce scrii orice constructor, acest constructor implicit nu mai este generat.

În exemplu sunt două erori:

  • new Produs() caută un constructor fără parametri, care nu există.
  • Orice constructor care nu începe cu this(...) sau super(...) primește automat ca primă instrucțiune super(). Constructorul Carte() încearcă deci să cheme Produs(), inexistent.

Soluții posibile:

JAVA
// 1. Subclasa transmite explicit parametrul
class Carte extends Produs {
    Carte(String titlu) { super(titlu); }
}

// 2. Adaugi în Produs un constructor fără parametri, dacă are sens
class Produs {
    private String nume;
    Produs() { this("fără nume"); }
    Produs(String nume) { this.nume = nume; }
}

A doua variantă se decide după model: dacă un produs fără nume nu are sens în business, e mai corect să nu oferi constructorul gol și să obligi apelantul să dea numele.

Contextul practic: unele framework-uri (JPA/Hibernate, unele biblioteci de serializare) cer un constructor fără parametri, iar adăugarea unui constructor cu parametri poate strica încărcarea entităților. În astfel de cazuri, constructorul gol poate fi protected, ca să nu fie folosit din codul aplicației.

Ce urmărește intervievatorul: Se verifică înțelegerea regulilor de generare a constructorilor și a apelului implicit super(). Candidații uită că și subclasa este afectată.

Eroarea, în practică:constructor cannot be applied to given typesNoSuchMethodException: <init>()

23 Junior

Unde este bug-ul în clasa de mai jos?

JAVA
public class Client {
    private String nume;
    private int varsta;

    public Client(String nume, int varsta) {
        nume = nume;
        varsta = varsta;
    }
    public String getNume() { return nume; }
}

Răspuns scurt: Parametrii constructorului au aceleași nume ca și câmpurile și le ascund, deci nume = nume atribuie parametrul lui însuși. Câmpurile rămân null și 0. Corect: this.nume = nume; și this.varsta = varsta;.

Fenomenul se numește shadowing (umbrire): o variabilă locală sau un parametru cu același nume ca un câmp îl face invizibil în acel bloc. În constructor, nume se referă la parametru, deci nume = nume nu face nimic util. Codul compilează, iar bugul apare abia la rulare, când getNume() întoarce null.

this este referința către obiectul curent, iar this.nume înseamnă explicit câmpul:

JAVA
public Client(String nume, int varsta) {
    this.nume = nume;
    this.varsta = varsta;
}

Ce te poate proteja de astfel de buguri:

  • Câmpurile final: dacă nume ar fi private final String nume;, compilatorul ar raporta că acesta nu este inițializat, deci bugul ar fi prins imediat. E un motiv în plus să faci câmpurile final când nu se schimbă.
  • Avertismentele IDE-ului: IntelliJ semnalează „variable is assigned to itself”.
  • Un test unitar minimal care verifică getterii după construire.

Alte utilizări ale lui this: apelul altui constructor din aceeași clasă (this(nume, 0), obligatoriu prima instrucțiune), transmiterea obiectului curent către altă metodă (registru.adauga(this)) și returnarea lui pentru înlănțuire, ca în builder-e (return this;). Într-o metodă static nu există this, pentru că nu există obiect curent.

Ce urmărește intervievatorul: Este un bug real și frecvent la începători; intervievatorul verifică dacă îl vezi rapid și știi cum îl previi. Bonus dacă menționezi câmpurile final.

24 Junior

Ce afișează codul următor?

JAVA
class Animal {
    String nume = "animal";
    String getNume() { return nume; }
}
class Caine extends Animal {
    String nume = "câine";
    @Override String getNume() { return nume; }
}
Animal a = new Caine();
System.out.println(a.nume + " " + a.getNume());

Răspuns scurt: Afișează animal câine. Metodele de instanță sunt polimorfice: se alege implementarea după tipul real al obiectului. Câmpurile nu sunt: accesul a.nume se decide la compilare după tipul declarat al variabilei, Animal.

Diferența ține de momentul în care se face legătura:

  • Metodele de instanță suprascrise folosesc legare dinamică (dynamic dispatch): la rulare, JVM-ul se uită la clasa reală a obiectului (Caine) și cheamă Caine.getNume(), care întoarce câmpul din Caine.
  • Câmpurile se rezolvă la compilare după tipul referinței. a are tipul declarat Animal, deci a.nume este câmpul din Animal.

Obiectul Caine conține de fapt două câmpuri numite nume: unul moștenit și unul declarat în subclasă, care îl ascunde pe primul (field hiding). Dacă faci cast, ((Caine) a).nume afișează câine, iar din interiorul lui Caine câmpul părintelui este accesibil cu super.nume.

Același lucru se întâmplă cu metodele static: nu sunt suprascrise, ci ascunse, și se aleg după tipul declarat.

Concluzia practică este una de design: nu declara în subclasă un câmp cu același nume ca în părinte, pentru că obiectul ajunge să aibă două stări paralele și codul devine confuz. Câmpurile ar trebui să fie private și accesate prin metode; astfel comportamentul polimorfic vine din metode, iar subclasa își poate configura starea prin constructorul părintelui:

JAVA
class Animal {
    private final String nume;
    Animal(String nume) { this.nume = nume; }
    String getNume() { return nume; }
}
class Caine extends Animal {
    Caine() { super("câine"); }
}

Ce urmărește intervievatorul: Verifică înțelegerea exactă a polimorfismului: ce e dinamic și ce e static. Mulți răspund câine câine.

25 Junior

Ce face codul de mai jos în Java 16+? Ce excepție poate apărea la conversia obiectelor și cum o eviți?

JAVA
Object o = obtineValoare();
if (o instanceof String s && s.length() > 3) {
    System.out.println(s.toUpperCase());
}
Integer n = (Integer) o;

Răspuns scurt: instanceof cu pattern (Java 16) verifică tipul și declară direct variabila s, fără cast separat. Cast-ul explicit (Integer) o aruncă ClassCastException dacă o nu e Integer; îl eviți verificând întâi tipul cu instanceof.

Înainte de Java 16 scriai:

JAVA
if (o instanceof String) {
    String s = (String) o;
    ...
}

Pattern matching pentru instanceof (standard din Java 16) combină verificarea și conversia: dacă testul reușește, variabila s există deja cu tipul String. Domeniul ei de vizibilitate urmează logica condiției: în o instanceof String s && s.length() > 3, s este sigur inițializată în partea dreaptă a lui &&. Cu || nu ar compila, pentru că pe ramura respectivă s poate să nu existe. Se poate folosi și în negație:

JAVA
if (!(o instanceof String s)) return;
System.out.println(s.length()); // s e vizibilă aici

instanceof întoarce false pentru null, deci nu trebuie verificare separată de null.

Downcast-ul (conversia de la un tip mai general la unul mai specific) este verificat la rulare. Dacă obiectul real nu este de tipul cerut sau un subtip al lui, apare ClassCastException. Upcast-ul (Animal a = caine;) este mereu sigur și implicit. Compilatorul refuză doar cast-urile imposibile, de exemplu între două clase fără relație de moștenire ((Integer) "text").

Recomandare de design: multe instanceof legate de aceeași ierarhie indică de obicei că logica ar trebui mutată într-o metodă polimorfică. Excepție fac ierarhiile sealed cu switch pe tipuri din Java 21, unde compilatorul verifică exhaustivitatea.

Ce urmărește intervievatorul: Se verifică sintaxa modernă și înțelegerea verificării de tip la rulare. Greșeala tipică este cast-ul fără verificare pe un Object venit din exterior.

Eroarea, în practică:ClassCastException: cannot be cast to classObject[] cannot be cast to String[]

26 Junior

Ce poate face un enum în Java în afară de a enumera constante? Scrie un enum pentru statusul unei comenzi care știe dacă se mai poate anula.

Răspuns scurt: Un enum este o clasă completă: poate avea câmpuri, constructor (implicit privat), metode, metode abstracte implementate diferit de fiecare constantă și poate implementa interfețe. Constantele sunt singleton-uri, deci se compară cu ==.

Fiecare constantă dintr-un enum este o instanță unică, creată la încărcarea clasei. Compilatorul adaugă metode utile: values() (toate constantele, în ordinea declarării), valueOf(String) (aruncă IllegalArgumentException pentru un nume inexistent), name() și ordinal().

JAVA
public enum StatusComanda {
    NOUA("Nouă", true),
    PLATITA("Plătită", true),
    EXPEDIATA("Expediată", false),
    LIVRATA("Livrată", false);

    private final String eticheta;
    private final boolean anulabila;

    StatusComanda(String eticheta, boolean anulabila) {
        this.eticheta = eticheta;
        this.anulabila = anulabila;
    }
    public String eticheta() { return eticheta; }
    public boolean poateFiAnulata() { return anulabila; }
}

if (comanda.status().poateFiAnulata()) { ... }

Constructorul unui enum nu poate fi public, iar constantele nu se pot crea cu new. Pentru că există o singură instanță per constantă, status == StatusComanda.NOUA este sigur și chiar evită NullPointerException, spre deosebire de status.equals(...).

Bune practici:

  • Nu persista ordinal() în baza de date: dacă cineva inserează o constantă nouă la mijloc, toate valorile se decalează. Folosește numele sau un cod explicit.
  • Pentru mulțimi și dicționare cu chei enum, EnumSet și EnumMap sunt mult mai eficiente decât HashSet și HashMap.
  • Un enum cu o singură constantă este o implementare de Singleton recomandată de mulți, pentru că e sigură la serializare și reflecție.

În switch, compilatorul poate verifica, la expresiile switch moderne, că ai tratat toate constantele.

Ce urmărește intervievatorul: Verifică dacă folosești enum ca tip bogat, nu doar ca listă de constante. Greșeala frecventă este salvarea lui ordinal() în baza de date.

Eroarea, în practică:enum classes may not be instantiated

27 Junior

Ce reguli trebuie să respecte o metodă care suprascrie (override) o metodă din clasa părinte? Care dintre metodele din B compilează?

JAVA
class A {
    protected Number valoare() throws IOException { return 1; }
}
class B extends A {
    @Override public Integer valoare() { return 2; }
}

Răspuns scurt: Compilează. Metoda suprascrisă are aceeași semnătură, poate întoarce un subtip (tip returnat covariant), poate avea acces mai larg, dar nu mai restrâns, și poate arunca mai puține excepții checked sau unele mai specifice, dar nu mai largi.

Regulile pentru suprascriere:

  • Aceeași semnătură: același nume și aceeași listă de tipuri de parametri. Dacă parametrii diferă, obții supraîncărcare (overloading), nu suprascriere.
  • Tip returnat covariant: poți întoarce același tip sau un subtip. Integer este subtip al lui Number, deci e permis. Pentru tipuri primitive, tipul trebuie să fie identic.
  • Acces cel puțin la fel de larg: de la protected poți trece la public, dar nu la acces de pachet sau private. Altfel, codul care folosește un A ar putea pierde accesul când primește un B.
  • Excepții checked: subclasa poate declara aceleași excepții, subtipuri ale lor sau niciuna, dar nu excepții checked noi sau mai generale. Excepțiile unchecked nu sunt restricționate.
  • Metodele final nu pot fi suprascrise, metodele private nu sunt moștenite (o metodă cu același nume în subclasă e alta), iar metodele static sunt ascunse, nu suprascrise.

@Override nu este obligatoriu, dar cere compilatorului să verifice că metoda chiar suprascrie ceva. Fără ea, o greșeală banală trece neobservată:

JAVA
class Punct {
    public boolean equals(Punct p) { ... } // supraîncărcare, nu override
}

Cu @Override pe această metodă, compilarea ar eșua, pentru că Object.equals primește Object.

Motivul acestor reguli este principiul substituției: oriunde se așteaptă un A, un B trebuie să poată fi folosit fără ca apelantul să aibă surprize.

Ce urmărește intervievatorul: Verifică regulile precise ale suprascrierii și rolul lui @Override. Candidații greșesc des regula excepțiilor checked.

Eroarea, în practică:method cannot override method in superclass

28 Mid

Ce afișează codul următor și de ce?

JAVA
class Baza {
    Baza() { descrie(); }
    void descrie() { System.out.println("Baza"); }
}
class Copil extends Baza {
    private String nume = "Ana";
    private int varsta = 30;
    @Override void descrie() {
        System.out.println(nume + " " + varsta);
    }
}
new Copil();

Răspuns scurt: Afișează null 0. Constructorul Baza rulează înaintea inițializării câmpurilor din Copil, dar apelul descrie() este polimorfic și ajunge în Copil, unde câmpurile au încă valorile implicite.

Ordinea construirii unui Copil este:

  • memoria obiectului se alocă, iar toate câmpurile primesc valori implicite (null, 0);
  • constructorul Copil cheamă implicit super();
  • constructorul Baza rulează și apelează descrie();
  • abia după întoarcerea din super() se execută inițializatorii câmpurilor din Copil (nume = "Ana", varsta = 30) și restul constructorului.

Apelul de metodă este însă dinamic din primul moment: obiectul este deja un Copil, deci se execută Copil.descrie(), care vede câmpuri încă neinițializate. Rezultat: null 0.

Un detaliu care surprinde: dacă varsta ar fi private final int varsta = 30;, s-ar afișa null 30. Un câmp final inițializat cu o constantă la compilare este înlocuit de compilator direct cu valoarea, deci nu mai depinde de ordinea inițializării.

De ce contează în practică: un obiect parțial construit poate arunca NullPointerException din locuri neașteptate, iar bugul e greu de urmărit. Regula recomandată (și în „Effective Java”) este ca un constructor să nu apeleze metode care pot fi suprascrise. Variante sigure:

  • metoda apelată din constructor este private, final sau static;
  • clasa este final;
  • inițializarea care necesită comportament specific se mută într-o metodă factory apelată după construcție.

Aceeași problemă apare când constructorul publică this către alt obiect (un listener, alt thread) înainte de terminare.

Ce urmărește intervievatorul: Întrebarea verifică înțelegerea profundă a ordinii de inițializare și a legării dinamice. Mulți se așteaptă la Ana 30 sau la Baza.

Eroarea, în practică:cannot reference before supertype constructor

29 Mid

Ce se întâmplă când o clasă implementează două interfețe care au aceeași metodă default? Cum rezolvi conflictul?

JAVA
interface Zburator { default String mod() { return "zbor"; } }
interface Inotator { default String mod() { return "înot"; } }
class Rata implements Zburator, Inotator { }

Răspuns scurt: Codul nu compilează: clasa moștenește două implementări implicite cu aceeași semnătură. Trebuie să suprascrii metoda în Rata și, dacă vrei, să alegi explicit una cu Zburator.super.mod().

Metodele default (din Java 8) au adus o formă limitată de moștenire multiplă de comportament. Pentru conflicte, Java aplică trei reguli, în ordine:

  • Clasa câștigă: o metodă declarată în clasă sau moștenită de la o superclasă are prioritate față de orice metodă default din interfețe.
  • Interfața mai specifică câștigă: dacă B extends A și ambele au default mod(), o clasă care le implementează pe amândouă primește versiunea din B.
  • Dacă regulile de mai sus nu decid, conflictul trebuie rezolvat explicit, altfel compilarea eșuează.

Rezolvarea:

JAVA
class Rata implements Zburator, Inotator {
    @Override
    public String mod() {
        return Zburator.super.mod() + " și " + Inotator.super.mod();
    }
}

Sintaxa NumeInterfata.super.metoda() este permisă doar pentru interfețele implementate direct de clasă.

Tot de la interfețe: metodele static din interfețe (Java 8) nu se moștenesc, se apelează doar ca Zburator.metoda(). Din Java 9, interfețele pot avea și metode private, utile pentru cod comun între mai multe metode default.

Context de design: metodele default au fost introduse ca să permită evoluția API-urilor existente fără să strice implementările, de exemplu Collection.stream() sau Iterable.forEach. Nu sunt un înlocuitor pentru clasele abstracte, pentru că interfețele nu pot avea stare de instanță (câmpurile sunt implicit public static final).

Ce urmărește intervievatorul: Verifică dacă știi regulile de rezolvare a conflictelor între metode default. Puțini candidați cunosc sintaxa Interfata.super.metoda().

Eroarea, în practică:types are incompatible; inherits unrelated defaults

30 Mid

Care este diferența dintre o clasă imbricată statică, o clasă internă, o clasă locală și o clasă anonimă? De ce o clasă internă poate produce un memory leak?

Răspuns scurt: Clasa imbricată statică nu are legătură cu o instanță a clasei exterioare. Clasa internă (non-static) păstrează o referință ascunsă la obiectul exterior. Clasele locale sunt declarate într-o metodă, iar cele anonime sunt locale fără nume. Referința ascunsă ține în viață obiectul exterior.

Cele patru tipuri de clase declarate în interiorul altora:

  • Static nested: static class Nod {} în interiorul lui Lista. Se comportă ca o clasă obișnuită plasată în alt namespace, cu acces la membrii privați statici ai clasei exterioare. Se creează cu new Lista.Nod().
  • Inner (internă): class Iterator {} fără static. Fiecare instanță este legată de un obiect exterior și îi poate accesa câmpurile direct. Se creează cu lista.new Iterator(), iar referința către exterior este Lista.this.
  • Locală: declarată într-o metodă, vizibilă doar acolo, poate folosi variabilele locale effectively final.
  • Anonimă: o clasă locală fără nume, creată și instanțiată într-o expresie, de exemplu o implementare rapidă a unei interfețe sau a unei clase abstracte.
JAVA
public class Raport {
    private final byte[] date = new byte[50_000_000];
    class Sarcina implements Runnable {      // ține Raport.this
        public void run() { }
    }
    static class SarcinaSigura implements Runnable {
        public void run() { }
    }
}

Problema: o instanță Sarcina păstrată într-o coadă, un cache sau un listener înregistrat global ține în viață întregul Raport, cu cei 50 MB, chiar dacă nimeni altcineva nu mai folosește raportul. Clasele anonime create în metode de instanță au aceeași referință ascunsă. Lambda-urile capturează this doar dacă îl folosesc.

Regula practică: declară clasele imbricate static dacă nu au nevoie de instanța exterioară. Exemple din JDK: Map.Entry este o interfață imbricată, iar nodurile din HashMap sunt clase statice.

Ce urmărește intervievatorul: Intervievatorul verifică înțelegerea legăturii ascunse cu instanța exterioară. Greșeala frecventă este să declari tot ca inner class din obișnuință.

Eroarea, în practică:an enclosing instance that contains ... is required

31 Mid

Ce sunt clasele și interfețele sealed (Java 17)? Ce problemă rezolvă față de final sau de o ierarhie deschisă?

Răspuns scurt: O clasă sau interfață sealed declară explicit, cu permits, ce subclase are voie să aibă. Fiecare subclasă trebuie să fie final, sealed sau non-sealed. Astfel modelezi o ierarhie închisă, iar compilatorul poate verifica exhaustivitatea în switch.

Până la Java 17 aveai două extreme: o clasă final, pe care nu o poate extinde nimeni, sau o clasă deschisă, pe care o poate extinde oricine. Clasele sealed (JEP 409, standard în Java 17) permit varianta intermediară: „exact aceste subtipuri și nimic altceva”.

JAVA
public sealed interface Plata permits Card, Transfer, Numerar { }

public record Card(String numarMascat) implements Plata { }
public record Transfer(String iban) implements Plata { }
public final class Numerar implements Plata { }

Reguli:

  • Subtipurile permise trebuie să fie în același modul sau, dacă nu folosești module, în același pachet.
  • Fiecare subtip declară cum continuă ierarhia: final (se oprește), sealed (cu propria listă permits) sau non-sealed (redeschide extinderea). Records sunt implicit final.
  • Dacă toate subtipurile sunt în același fișier, permits poate lipsi.

Beneficiul principal apare împreună cu pattern matching în switch (Java 21): compilatorul știe toate cazurile, deci nu mai ai nevoie de default, iar dacă adaugi un subtip nou, fiecare switch netratat devine eroare de compilare.

JAVA
String descriere = switch (plata) {
    case Card c -> "card " + c.numarMascat();
    case Transfer t -> "transfer din " + t.iban();
    case Numerar n -> "numerar";
};

Așa modelezi tipuri algebrice: rezultate de operații (Succes / Eroare), evenimente de domeniu, comenzi. Diferența față de un enum: fiecare variantă poate avea alte câmpuri.

Ce urmărește intervievatorul: Se verifică cunoașterea Java modern și a motivației din spatele lui. Candidații știu sintaxa, dar nu leagă sealed de exhaustivitatea din switch.

Eroarea, în practică:sealed, non-sealed or final modifiers expected

32 Mid

Este un record complet imuabil? Ce problemă are codul de mai jos și cum o repari în constructorul compact?

JAVA
record Echipa(String nume, List<String> membri) { }

List<String> lista = new ArrayList<>(List.of("Ana"));
Echipa e = new Echipa("Backend", lista);
lista.add("Mihai");
e.membri().add("Ioana");

Răspuns scurt: Nu. Un record are câmpuri final, dar imuabilitatea este superficială: lista referită poate fi modificată din exterior. Repari în constructorul compact cu o copie imuabilă, membri = List.copyOf(membri);, iar validările se pun tot acolo.

Un record generează câmpuri private final, constructor canonic, accesori, equals, hashCode și toString. final înseamnă însă doar că referința nu se schimbă, nu că obiectul referit e imuabil. În exemplu, e.membri() întoarce chiar lista originală, deci atât lista.add cât și e.membri().add modifică echipa. În plus, hashCode al recordului se schimbă după modificare, ceea ce strică folosirea lui ca cheie în HashMap.

Constructorul compact este un constructor fără listă de parametri, care rulează înainte de atribuirea câmpurilor. Poți valida și poți reatribui parametrii:

JAVA
record Echipa(String nume, List<String> membri) {
    Echipa {
        Objects.requireNonNull(nume, "nume");
        if (nume.isBlank()) {
            throw new IllegalArgumentException("Numele nu poate fi gol");
        }
        membri = List.copyOf(membri);
    }
}

List.copyOf creează o copie imuabilă (sau întoarce lista dacă e deja imuabilă) și aruncă NullPointerException pentru elemente null. După această schimbare, modificările externe nu mai afectează echipa, iar e.membri().add(...) aruncă UnsupportedOperationException.

Alte detalii de records: nu pot extinde alte clase (extind implicit java.lang.Record), pot implementa interfețe, pot avea metode și câmpuri static, dar nu câmpuri de instanță suplimentare. Pentru tablouri, equals generat compară referințele, nu conținutul, deci records cu tablouri au nevoie de equals scris manual sau, mai bine, de o listă.

Ce urmărește intervievatorul: Verifică dacă înțelegi diferența dintre câmp final și obiect imuabil, și dacă știi constructorul compact. Mulți cred că records sunt imuabile complet.

Eroarea, în practică:field declaration must be static (record)invalid canonical constructor in record

Object, equals, hashCode și comparare

33 Junior

Unde e bug-ul? De ce setul are două elemente?

JAVA
class Punct {
    final int x, y;
    Punct(int x, int y) { this.x = x; this.y = y; }
    public boolean equals(Punct p) {
        return p != null && x == p.x && y == p.y;
    }
    public int hashCode() { return 31 * x + y; }
}
Set<Punct> set = new HashSet<>();
set.add(new Punct(1, 2));
set.add(new Punct(1, 2));
System.out.println(set.size());

Răspuns scurt: Metoda equals(Punct p) nu suprascrie Object.equals(Object), ci o supraîncarcă. HashSet apelează equals(Object), care a rămas comparația de identitate, deci cele două puncte par diferite. Corect: equals(Object o) cu @Override.

Colecțiile lucrează cu Object: HashSet găsește bucket-ul după hashCode() (care aici e corect suprascris) și apoi cheamă equals(Object) pe elementele din bucket. Pentru că metoda scrisă are parametrul Punct, ea este o metodă nouă, cu altă semnătură. Varianta din Object rămâne cea originală, care compară referințele, așa că setul conține două elemente.

Supraîncărcarea se alege la compilare după tipul static al argumentului, de aceea new Punct(1,2).equals(new Punct(1,2)) scris direct întoarce true, iar bugul scapă la un test superficial.

Varianta corectă:

JAVA
@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (!(o instanceof Punct p)) return false;
    return x == p.x && y == p.y;
}

@Override
public int hashCode() {
    return Objects.hash(x, y);
}

@Override ar fi prins greșeala la compilare. Pattern matching-ul (o instanceof Punct p, Java 16) elimină cast-ul și tratează și cazul null, pentru că instanceof întoarce false pe null.

Pentru clase care sunt doar purtătoare de date, un record Punct(int x, int y) generează automat equals și hashCode corecte, deci elimină complet această categorie de buguri.

Ce urmărește intervievatorul: Este un bug clasic, care arată dacă știi diferența dintre overloading și overriding în contextul colecțiilor. Intervievatorul urmărește și menționarea lui @Override.

34 Junior

Ce afișează System.out.println(obj) pentru o clasă care nu suprascrie toString(), de exemplu Client@1b6d3586? Ce înseamnă numărul?

Răspuns scurt: Afișează numele complet al clasei, @ și valoarea hashCode() în hexazecimal. Fără suprascriere, hashCode() este „identity hash code”, un număr asociat obiectului de JVM, nu neapărat adresa lui din memorie.

Implementarea din Object este echivalentă cu:

JAVA
getClass().getName() + "@" + Integer.toHexString(hashCode())

Numele include pachetul (de exemplu ro.magazin.Client). Dacă tabloul afișat e de int, vezi [I@..., unde [I este numele intern al tipului int[].

Identity hash code-ul este generat de JVM la prima cerere și rămâne constant pe durata vieții obiectului, chiar dacă garbage collector-ul îl mută în memorie. Este un mit că ar fi adresa obiectului: JVM-urile moderne îl generează de obicei pseudo-aleator și îl stochează în antetul obiectului. Poți obține valoarea și după ce ai suprascris hashCode(), cu System.identityHashCode(obj).

De ce contează toString():

  • apare în loguri, în mesajele excepțiilor și în debugger;
  • concatenarea "Client: " + client îl apelează implicit, iar String.valueOf(null) întoarce "null" fără excepție.

O implementare bună include câmpurile relevante pentru depanare:

JAVA
@Override
public String toString() {
    return "Client{id=" + id + ", email=" + mascheaza(email) + "}";
}

Atenție la două lucruri: nu include date sensibile (parole, numere de card, CNP), pentru că ajung în loguri; și nu include colecții mari sau referințe ciclice (Comanda care afișează Client, care afișează lista de comenzi), care pot produce StackOverflowError. Records generează automat un toString cu toate câmpurile, deci aceeași grijă se aplică și lor.

Ce urmărește intervievatorul: Verifică înțelegerea implementărilor implicite din Object. Greșeala frecventă: „este adresa din memorie” sau toString cu date sensibile.

35 Junior

Ce fac metodele utilitare din java.util.Objects (equals, hash, requireNonNull, requireNonNullElse, toString) și când le folosești?

Răspuns scurt: Sunt metode statice null-safe pentru operații frecvente: Objects.equals(a, b) compară fără NullPointerException, Objects.hash(...) calculează un hash din mai multe câmpuri, requireNonNull validează argumentele, iar requireNonNullElse (Java 9) oferă o valoare implicită.

Clasa Objects (din Java 7, extinsă în Java 9) elimină multe verificări repetitive de null:

  • Objects.equals(a, b) întoarce true dacă ambele sunt null sau dacă a.equals(b). Este ideală în implementările de equals pentru câmpuri care pot fi null.
  • Objects.hash(x, y, z) combină hash-urile câmpurilor (inclusiv null, tratat ca 0). Atenție: primește varargs, deci alocă un tablou la fiecare apel; pentru clase folosite intens drept chei, un calcul manual 31 * h + ... este mai rapid.
  • Objects.requireNonNull(obj, "mesaj") aruncă NullPointerException cu mesaj clar dacă argumentul e null și întoarce obiectul, deci se poate folosi direct în atribuire.
  • Objects.requireNonNullElse(valoare, implicit) și requireNonNullElseGet(valoare, supplier) (Java 9) întorc valoarea implicită când prima e null.
  • Objects.toString(obj, "-") întoarce textul implicit pentru null.
  • Objects.checkIndex(i, lungime) (Java 9) validează indici.
JAVA
public Comanda(Client client, String observatii) {
    this.client = Objects.requireNonNull(client, "client");
    this.observatii = Objects.requireNonNullElse(observatii, "");
}

Avantajul lui requireNonNull în constructor este principiul fail-fast: eroarea apare la crearea obiectului, cu numele câmpului, nu zece apeluri mai târziu, când cineva folosește câmpul. Stack trace-ul arată direct apelantul vinovat.

Pentru comparații de tablouri sau colecții imbricate există Objects.deepEquals, iar Objects.isNull și Objects.nonNull sunt utile ca referințe de metodă în stream-uri: filter(Objects::nonNull).

Ce urmărește intervievatorul: Verifică dacă scrii cod defensiv concis, cu API-ul standard. Candidații slabi reinventează aceste verificări cu if-uri lungi.

Eroarea, în practică:NullPointerException: Cannot invoke ... is null

36 Junior

Care este diferența dintre o copie superficială (shallow copy) și o copie profundă (deep copy)? De ce se recomandă un constructor de copiere în locul lui clone()?

Răspuns scurt: Copia superficială duplică obiectul, dar câmpurile referință indică spre aceleași obiecte interne. Copia profundă duplică și obiectele interne. clone() este fragil (interfață marker, cast, excepție checked, copie superficială implicită), iar un constructor de copiere este explicit și sigur.

Să luăm un coș de cumpărături cu o listă de produse:

JAVA
class Cos {
    private final List<String> produse;
    Cos(List<String> produse) { this.produse = new ArrayList<>(produse); }
    Cos(Cos altul) { this(altul.produse); }   // constructor de copiere
    void adauga(String p) { produse.add(p); }
}

O copie superficială ar crea un Cos nou care folosește aceeași listă. Adăugarea unui produs într-un coș ar apărea și în celălalt. Atribuirea Cos b = a; nici măcar nu e copie: sunt două referințe spre același obiect. Copia profundă construiește și o listă nouă, ca în constructorul de mai sus. Dacă elementele listei ar fi mutabile (de exemplu obiecte Produs cu preț modificabil), o copie complet profundă le-ar copia și pe ele.

Problemele lui clone():

  • clasa trebuie să implementeze Cloneable, o interfață fără metode care schimbă comportamentul lui Object.clone();
  • Object.clone() este protected și aruncă CloneNotSupportedException (checked);
  • copia este superficială, deci trebuie să clonezi manual câmpurile mutabile;
  • nu funcționează cu câmpuri final care trebuie reatribuite;
  • nu trece prin constructor, deci validările nu rulează.

Alternativele recomandate sunt constructorul de copiere sau o metodă factory (Cos.copieDin(altul)). Excepție: pentru tablouri, arr.clone() este public, simplu și corect pentru tablouri de primitive. Cea mai bună soluție rămâne de multe ori imuabilitatea: obiectele imuabile nu trebuie copiate deloc.

Ce urmărește intervievatorul: Verifică înțelegerea referințelor și a capcanelor lui clone(). Greșeala tipică este să crezi că atribuirea sau clone() fac o copie completă.

Eroarea, în practică:CloneNotSupportedException

37 Mid

În equals e mai bine să folosești instanceof sau getClass()? Ce problemă apare în exemplul de mai jos?

JAVA
class Punct {
    int x, y;
    @Override public boolean equals(Object o) {
        return o instanceof Punct p && x == p.x && y == p.y;
    }
}
class PunctColorat extends Punct {
    String culoare;
    @Override public boolean equals(Object o) {
        return o instanceof PunctColorat p && super.equals(p)
            && culoare.equals(p.culoare);
    }
}

Răspuns scurt: Se încalcă simetria: punct.equals(punctColorat) este true, dar punctColorat.equals(punct) este false. Cu getClass() obiectele de clase diferite nu sunt niciodată egale; cu instanceof subclasele nu trebuie să adauge stare în equals. Soluția curată: compoziție sau clase final.

Contractul lui equals cere reflexivitate, simetrie, tranzitivitate, consistență și x.equals(null) == false. În exemplu, Punct.equals acceptă orice subtip, deci un PunctColorat(1,2,"roșu") este egal cu Punct(1,2). În sens invers, PunctColorat.equals cere PunctColorat, deci răspunde false. Colecțiile pot da rezultate diferite în funcție de ce obiect e deja în ele.

Dacă încerci să repari simetria ignorând culoarea când celălalt e Punct, strici tranzitivitatea: roșu egal cu fără-culoare, fără-culoare egal cu albastru, dar roșu diferit de albastru.

Cele două abordări:

  • getClass() != o.getClass(): egalitatea cere aceeași clasă exactă. Simetria e garantată, dar se încalcă principiul substituției: o subclasă fără câmpuri noi (de exemplu un proxy creat de Hibernate) nu va mai fi egală cu obiectul original.
  • instanceof: păstrează substituția, dar funcționează corect doar dacă subclasele nu redefinesc equals. Ca să impui asta, faci equals final sau clasa final.

Concluzia standard („Effective Java”): nu există o cale de a extinde o clasă instanțiabilă, de a adăuga o componentă de valoare și de a păstra contractul equals. Soluția este compoziția:

JAVA
record PunctColorat(Punct punct, String culoare) { }

Records sunt final, deci problema nu apare. Pentru entități JPA, unde proxy-urile sunt subclase, se folosește de obicei instanceof cu comparație pe identificator.

Ce urmărește intervievatorul: Este o întrebare care testează înțelegerea contractului, nu doar sintaxa. Puțini candidați pot explica de ce ambele variante au compromisuri.

38 Mid

Ce afișează codul următor și de ce?

JAVA
class Cheie {
    String cod;
    Cheie(String cod) { this.cod = cod; }
    @Override public boolean equals(Object o) {
        return o instanceof Cheie c && cod.equals(c.cod);
    }
    @Override public int hashCode() { return cod.hashCode(); }
}
Map<Cheie, Integer> map = new HashMap<>();
Cheie k = new Cheie("A");
map.put(k, 1);
k.cod = "B";
System.out.println(map.get(k) + " " + map.get(new Cheie("A")) + " " + map.size());

Răspuns scurt: Afișează null null 1. După modificare, k are alt hashCode, deci căutarea merge în alt bucket. Căutarea după „A” găsește bucket-ul vechi, dar equals eșuează, pentru că obiectul stocat are acum codul „B”. Intrarea există, dar e de negăsit.

HashMap calculează bucket-ul o singură dată, la put, pe baza hashCode() din acel moment. Dacă un câmp folosit în hashCode se schimbă după inserare, obiectul rămâne în bucket-ul vechi, iar orice căutare ulterioară eșuează:

  • map.get(k): hash-ul lui „B” trimite în alt bucket, gol, deci null.
  • map.get(new Cheie("A")): hash-ul lui „A” trimite în bucket-ul corect, dar acolo se compară cu equals, iar "A".equals("B") este false, deci null.
  • size() rămâne 1: intrarea ocupă memorie, nu poate fi găsită și nici ștearsă prin remove(k). Într-un cache, astfel de intrări se acumulează și produc un memory leak.

Aceeași problemă apare la HashSet, unde contains întoarce false pentru un element care e în set, și la TreeMap/TreeSet dacă se schimbă câmpurile folosite la comparare.

Regula: cheile din colecțiile bazate pe hash sau pe ordonare trebuie să fie imuabile, cel puțin în câmpurile din equals/hashCode. În practică:

JAVA
record Cheie(String cod) { }   // câmpuri final, equals/hashCode corecte

Cheile uzuale din JDK (String, Integer, UUID, LocalDate, enum-uri) sunt imuabile din acest motiv. Pentru entități JPA, care au câmpuri mutabile, se recomandă ca equals/hashCode să se bazeze pe un identificator stabil, iar dacă id-ul e generat la salvare, hashCode să fie constant pentru clasă, ca să nu se schimbe după persist.

Ce urmărește intervievatorul: Verifică înțelegerea funcționării interne a colecțiilor hash dintr-un unghi practic. Mulți nu se gândesc că mutabilitatea cheii strică HashMap.

39 Mid

Vrei să sortezi angajații după departament crescător și, în cadrul departamentului, după salariu descrescător. De ce codul de mai jos e greșit? Mai e o problemă cu comparatorul din a doua linie?

JAVA
lista.sort(Comparator.comparing(Angajat::departament)
        .thenComparing(Angajat::salariu).reversed());
Comparator<Angajat> c = (a, b) -> a.varsta() - b.varsta();

Răspuns scurt: reversed() se aplică întregului comparator compus, deci inversează și ordinea departamentelor. Corect: thenComparing(Angajat::salariu, Comparator.reverseOrder()). Comparatorul prin scădere poate depăși intervalul int și dă rezultate greșite; folosești Integer.compare sau comparingInt.

Metodele din Comparator construiesc comparatoare prin compunere, iar fiecare apel se aplică asupra întregului lanț construit până atunci. comparing(departament).thenComparing(salariu) este un comparator complet; .reversed() îl inversează în întregime, deci departamentele ajung în ordine descrescătoare.

Varianta corectă inversează doar a doua cheie:

JAVA
lista.sort(Comparator.comparing(Angajat::departament)
        .thenComparing(Angajat::salariu, Comparator.reverseOrder()));

Dacă salariul este int sau double, thenComparingInt sau thenComparingDouble evită boxing-ul, dar nu au variantă cu comparator invers. Atunci se poate scrie thenComparing(Comparator.comparingInt(Angajat::salariu).reversed()).

Pentru valori care pot fi null (un departament nesetat), comparatorul simplu aruncă NullPointerException. Soluția: Comparator.comparing(Angajat::departament, Comparator.nullsLast(Comparator.naturalOrder())).

A doua problemă, scăderea: a - b pare să întoarcă semnul corect, dar pentru valori mari de semne opuse depășește intervalul. De exemplu Integer.MAX_VALUE - (-1) devine negativ, iar comparatorul încalcă contractul. TimSort, folosit de List.sort, poate chiar arunca „Comparison method violates its general contract!”. Pentru vârste reale nu se întâmplă, dar pentru id-uri, timestamp-uri sau sume, da. Varianta sigură:

JAVA
Comparator<Angajat> c = Comparator.comparingInt(Angajat::varsta);
// sau (a, b) -> Integer.compare(a.varsta(), b.varsta())

Ce urmărește intervievatorul: Verifică stăpânirea API-ului Comparator dincolo de exemplul de bază. Capcana cu reversed() și cea cu scăderea apar des în cod real.

Eroarea, în practică:Comparison method violates its general contract!

40 Senior

Ce afișează codul și de ce? Ce înseamnă „compareTo consistent cu equals”?

JAVA
BigDecimal a = new BigDecimal("1.0");
BigDecimal b = new BigDecimal("1.00");
Set<BigDecimal> hash = new HashSet<>(List.of(a, b));
Set<BigDecimal> tree = new TreeSet<>(List.of(a, b));
System.out.println(hash.size() + " " + tree.size());

Răspuns scurt: Afișează 2 1. BigDecimal.equals ține cont de scală, deci 1.0 și 1.00 sunt diferite, dar compareTo le consideră egale. HashSet folosește equals, TreeSet folosește compareTo. Ordonarea e consistentă cu equals dacă compareTo == 0 exact când equals e true.

Documentația Comparable recomandă (fără să impună) ca ordonarea naturală să fie consistentă cu equals: a.compareTo(b) == 0 dacă și numai dacă a.equals(b). BigDecimal este exemplul clasic care încalcă recomandarea, intenționat: 1.0 și 1.00 au valoare egală, dar scală diferită, iar scala are sens în calcule (precizia unei măsurători, numărul de zecimale afișate).

Consecința: colecțiile se comportă diferit în funcție de mecanismul de egalitate folosit.

  • HashSet, HashMap, List.contains, List.indexOf folosesc equals.
  • TreeSet, TreeMap și Collections.binarySearch folosesc compareTo sau comparatorul, ignorând complet equals.

Aceeași problemă apare cu un Comparator propriu care compară doar o parte din câmpuri. Un TreeSet<Angajat> sortat doar după nume va elimina tăcut al doilea angajat cu același nume, deși sunt persoane diferite:

JAVA
Set<Angajat> set = new TreeSet<>(Comparator.comparing(Angajat::nume));
set.add(new Angajat(1, "Ana"));
set.add(new Angajat(2, "Ana"));   // ignorat, size() == 1

Soluții: adaugi o cheie de departajare (thenComparing(Angajat::id)), astfel încât comparatorul să deosebească obiectele diferite; pentru BigDecimal, normalizezi scala (setScale(2) sau stripTrailingZeros()) înainte de a folosi valorile drept chei; sau alegi explicit colecția după semantica dorită. La code review, orice TreeSet sau TreeMap cu comparator parțial merită o întrebare.

Ce urmărește intervievatorul: Întrebarea verifică o cunoaștere subtilă a contractelor din JDK, utilă la depanarea unor buguri reale cu date pierdute. Puțini candidați știu că TreeSet ignoră equals.

Tablouri, colecții și generice

41 Junior

Ce afișează codul următor? Cum afli dimensiunea unui tablou, a unui String și a unei liste?

JAVA
int[] note = new int[3];
String[] nume = new String[2];
boolean[] flaguri = new boolean[1];
System.out.println(note[0] + " " + nume[1] + " " + flaguri[0]);
System.out.println(note.length + " " + "abc".length() + " " + List.of(1, 2).size());

Răspuns scurt: Afișează 0 null false, apoi 3 3 2. Elementele unui tablou nou primesc valori implicite. Pentru tablou folosești câmpul length, pentru String metoda length(), iar pentru colecții metoda size().

Un tablou creat cu new are dimensiune fixă, stabilită la creare, iar toate elementele primesc valoarea implicită a tipului: 0 pentru numere, false pentru boolean, null pentru referințe. Un String[] nou nu conține texte goale, ci null, deci nume[1].length() ar arunca NullPointerException.

Cele trei forme de „dimensiune” sunt o confuzie frecventă la început:

  • tablou.length este un câmp final, fără paranteze;
  • text.length() este o metodă a clasei String;
  • lista.size() este metoda din interfața Collection, valabilă pentru liste, seturi și cozi; Map are și el size().

Accesul în afara limitelor aruncă ArrayIndexOutOfBoundsException, iar indicele valid maxim este length - 1. Un tablou poate avea lungime 0 (new int[0]), util ca rezultat gol în loc de null.

Moduri de creare:

JAVA
int[] a = {4, 8, 15};            // doar la declarare
int[] b = new int[]{4, 8, 15};   // oriunde, de exemplu ca argument
int[][] m = new int[3][4];       // matrice 3x4, toate 0
int[][] z = new int[3][];        // rânduri de lungimi diferite, încă null

Tablourile multidimensionale sunt de fapt tablouri de tablouri, deci fiecare rând poate avea altă lungime (m[i].length).

Când ai nevoie de dimensiune variabilă, treci la ArrayList. Tablourile rămân potrivite pentru date de dimensiune fixă, pentru performanță cu primitive (fără boxing) și în algoritmi.

Ce urmărește intervievatorul: Este o întrebare de bază care verifică valorile implicite și API-ul elementar. Greșeala tipică este să crezi că String[] conține texte goale.

Eroarea, în practică:ArrayIndexOutOfBoundsException

42 Junior

Ce afișează codul următor și cum compari sau afișezi corect două tablouri?

JAVA
int[] a = {1, 2, 3};
int[] b = {1, 2, 3};
System.out.println(a == b);
System.out.println(a.equals(b));
System.out.println(Arrays.equals(a, b));
System.out.println(a);
System.out.println(Arrays.toString(a));

Răspuns scurt: Afișează false, false, true, ceva de forma [I@6d06d69c și [1, 2, 3]. Tablourile nu suprascriu equals și toString, deci folosești Arrays.equals și Arrays.toString (sau variantele deep pentru tablouri multidimensionale).

Tablourile sunt obiecte, dar clasa lor nu suprascrie metodele din Object:

  • a == b compară referințele: sunt două obiecte diferite, deci false;
  • a.equals(b) este tot comparația de identitate moștenită din Object, deci false;
  • Arrays.equals(a, b) compară lungimile și elementele pe rând: true;
  • println(a) afișează toString() din Object: [I (numele intern pentru int[]), @ și hash-ul în hexazecimal.

Pentru tablouri multidimensionale ai nevoie de variantele „deep”, pentru că elementele sunt la rândul lor tablouri:

JAVA
int[][] m1 = {{1, 2}, {3, 4}};
int[][] m2 = {{1, 2}, {3, 4}};
Arrays.equals(m1, m2);        // false: compară rândurile cu equals din Object
Arrays.deepEquals(m1, m2);    // true
Arrays.deepToString(m1);      // [[1, 2], [3, 4]]

Această lipsă are urmări practice: un tablou nu e potrivit drept cheie într-un HashMap sau element într-un HashSet, pentru că două tablouri cu același conținut sunt considerate diferite. La fel, un record cu un câmp tablou are equals și hashCode bazate pe identitatea tabloului. În aceste cazuri, folosești List<Integer> sau un String ca cheie, ori Arrays.hashCode și Arrays.equals în propriile metode.

Alte utilitare din Arrays des întâlnite: sort, binarySearch (doar pe tablou sortat), fill, copyOf, copyOfRange, asList, stream, iar din Java 9 Arrays.compare și Arrays.mismatch.

Ce urmărește intervievatorul: Verifică dacă știi că tablourile nu au equals/toString utile. Greșeala clasică este compararea tablourilor cu equals sau folosirea lor drept chei.

43 Junior

Ce afișează codul următor?

JAVA
List<Integer> lista = new ArrayList<>(List.of(10, 20, 30, 1));
lista.remove(1);
System.out.println(lista);
lista.remove(Integer.valueOf(1));
System.out.println(lista);

Răspuns scurt: Afișează [10, 30, 1], apoi [10, 30]. remove(1) cu argument int alege supraîncărcarea remove(int index) și șterge elementul de pe poziția 1. Ca să ștergi valoarea 1, apelezi remove(Object) cu un Integer.

List are două metode remove:

  • E remove(int index) șterge elementul de la poziția dată și îl întoarce;
  • boolean remove(Object o) șterge prima apariție a obiectului și întoarce dacă a găsit ceva.

Când apelezi remove(1), compilatorul alege supraîncărcarea. Regula de rezolvare a supraîncărcării încearcă întâi potrivirile fără boxing: remove(int) se potrivește exact, deci câștigă. Autoboxing-ul la Integer este luat în considerare doar dacă nu există potrivire fără el. Rezultatul: se șterge 20 (indexul 1), nu valoarea 1.

Pentru a șterge valoarea:

JAVA
lista.remove(Integer.valueOf(1));
lista.remove((Integer) 1);
lista.removeIf(x -> x == 1);   // toate aparițiile

Comportamentul diferă și la erori: remove(int) cu index invalid aruncă IndexOutOfBoundsException, pe când remove(Object) pe o valoare inexistentă întoarce false, fără excepție.

Capcana apare doar la List<Integer> (și List<Short>, List<Character> unde există conversii similare). La Set și Collection există doar remove(Object). Un bug real tipic: o listă de id-uri numerice din care se încearcă eliminarea unui id, iar codul șterge alt element sau aruncă excepție când id-ul depășește dimensiunea listei. Testele cu liste mici, în care id-ul se potrivește cu un index valid, nu prind problema.

Ce urmărește intervievatorul: Verifică înțelegerea regulilor de supraîncărcare combinate cu autoboxing. Mulți răspund [10, 20, 30] după primul apel.

Eroarea, în practică:IndexOutOfBoundsException (ArrayList.get)ConcurrentModificationException

44 Junior

Ce clasă folosești pentru o stivă (LIFO) și pentru o coadă (FIFO) în Java modern? De ce nu se mai recomandă Stack?

Răspuns scurt: Pentru ambele, ArrayDeque: push/pop/peek pentru stivă, offer/poll/peek pentru coadă. Stack extinde Vector, are toate metodele sincronizate și expune operații de listă care strică abstracția de stivă.

Deque (double-ended queue) permite inserare și extragere la ambele capete, deci acoperă ambele structuri. ArrayDeque este implementarea pe tablou circular, rapidă și fără alocări pe element.

JAVA
Deque<Character> stiva = new ArrayDeque<>();
stiva.push('(');
char top = stiva.peek();   // fără eliminare
char scos = stiva.pop();   // cu eliminare

Queue<String> coada = new ArrayDeque<>();
coada.offer("client1");
coada.offer("client2");
String urmator = coada.poll();  // "client1"

Metodele vin în perechi: una aruncă excepție când structura e goală (pop, remove, element), cealaltă întoarce null (poll, peek). ArrayDeque nu acceptă elemente null, tocmai ca null să poată semnala „gol”.

De ce nu Stack:

  • extinde Vector, deci fiecare operație e sincronizată, cost inutil într-un singur thread;
  • moștenește get(i), add(i, x), remove(i), deci oricine poate insera la mijloc, iar abstracția de stivă nu e protejată;
  • iterarea unui Stack merge de la bază spre vârf, invers față de ce te-ai aștepta, pe când ArrayDeque iterează de la vârf.

LinkedList implementează și ea Deque, dar alocă un nod pentru fiecare element și are localitate slabă în memorie, deci e de obicei mai lentă. Pentru coadă cu priorități există PriorityQueue, iar pentru acces concurent între thread-uri, implementările BlockingQueue sau ConcurrentLinkedDeque.

Exercițiul clasic de interviu cu stivă este verificarea parantezelor echilibrate: pui deschiderile pe stivă și, la fiecare închidere, verifici că vârful este pereche.

Ce urmărește intervievatorul: Verifică dacă știi alegerile moderne din java.util. Candidații care folosesc Stack sau Vector arată că au învățat din materiale vechi.

Eroarea, în practică:EmptyStackException

45 Junior

Scrie o funcție care primește un tablou de numere și o țintă și întoarce indicii a două elemente a căror sumă este ținta. Ce complexitate are?

Răspuns scurt: Parcurgi tabloul o dată și ții un HashMap de la valoare la index. Pentru fiecare element verifici dacă tinta - element a fost deja văzut. Complexitatea este O(n) timp și O(n) memorie, față de O(n²) la varianta cu două bucle.

Varianta naivă verifică fiecare pereche cu două bucle imbricate, O(n²). E bine să o menționezi ca punct de plecare, apoi să o optimizezi.

Ideea optimizată: pentru elementul curent x, perechea căutată este tinta - x. Dacă ții minte ce valori ai văzut deja și pe ce poziție, găsești perechea cu o singură căutare în HashMap, în medie O(1).

JAVA
static int[] douaSume(int[] numere, int tinta) {
    Map<Integer, Integer> vazute = new HashMap<>();
    for (int i = 0; i < numere.length; i++) {
        int complement = tinta - numere[i];
        Integer j = vazute.get(complement);
        if (j != null) {
            return new int[]{j, i};
        }
        vazute.put(numere[i], i);
    }
    return new int[0];
}

Detalii care contează:

  • Verifici complementul înainte să adaugi elementul curent, ca să nu folosești același element de două ori (de exemplu ținta 6 și elementul 3).
  • Folosești Integer j și compari cu null; dacă ai scrie int j = vazute.get(...), dezambalarea lui null ar arunca NullPointerException.
  • Pentru „nu există”, un tablou gol sau un Optional e mai clar decât null.

Alternativa, dacă tabloul este sortat sau poate fi sortat: doi indici de la capete, care se apropie în funcție de sumă, O(n log n) pentru sortare și O(1) memorie suplimentară. Sortarea pierde însă indicii originali, deci trebuie păstrați separat. La interviu, alegerea între cele două se face după cerință: indici sau valori, memorie disponibilă.

Ce urmărește intervievatorul: Este un exercițiu clasic de live coding care testează folosirea HashMap pentru optimizare. Intervievatorul urmărește cazurile limită și explicarea complexității.

46 Junior

Cum elimini duplicatele dintr-o listă păstrând ordinea primei apariții? Ce diferență este între HashSet, LinkedHashSet și TreeSet aici?

Răspuns scurt: Construiești un LinkedHashSet din listă, care elimină duplicatele și păstrează ordinea inserării: new ArrayList<>(new LinkedHashSet<>(lista)), sau lista.stream().distinct().toList(). HashSet nu garantează nicio ordine, iar TreeSet sortează elementele.

Toate trei implementează Set și folosesc equals (sau comparatorul, la TreeSet) pentru a detecta duplicatele, dar diferă la ordinea de iterare:

  • HashSet: ordine nedefinită, care depinde de hash-uri și de capacitate și se poate schimba la redimensionare. Operații O(1) în medie.
  • LinkedHashSet: ține și o listă dublu înlănțuită între elemente, în ordinea inserării. Reinserarea unui element existent nu îi schimbă poziția. Tot O(1) în medie, cu puțină memorie în plus.
  • TreeSet: arbore roșu-negru, elementele sunt sortate după ordinea naturală sau un comparator. Operații O(log n).
JAVA
List<String> orase = List.of("Iași", "Cluj", "Iași", "Brașov", "Cluj");
List<String> unice = new ArrayList<>(new LinkedHashSet<>(orase));
// [Iași, Cluj, Brașov]

List<String> unice2 = orase.stream().distinct().toList();
// aceeași ordine: distinct păstrează ordinea de întâlnire

Dacă vrei să modifici lista pe loc, fără listă nouă, poți folosi un set auxiliar cu removeIf:

JAVA
Set<String> vazute = new HashSet<>();
lista.removeIf(x -> !vazute.add(x));

Set.add întoarce false când elementul exista deja, deci condiția elimină aparițiile repetate. Lista trebuie să fie mutabilă.

Varianta cu două bucle și contains pe listă funcționează, dar e O(n²). Pentru eliminarea duplicatelor după un câmp (de exemplu clienți cu același email), folosești un Map cu cheia respectivă sau Collectors.toMap cu funcție de îmbinare, nu distinct(), care se bazează pe equals al întregului obiect.

Ce urmărește intervievatorul: Verifică dacă știi garanțiile de ordine ale implementărilor Set. Greșeala tipică este HashSet urmat de surpriza că ordinea s-a schimbat.

Eroarea, în practică:IllegalStateException: Duplicate key (toMap)

47 Junior

Scrie o clasă generică Pereche<A, B> care ține două valori de tipuri diferite și o metodă care întoarce perechea inversată. Cum o folosești?

Răspuns scurt: Declari parametrii de tip după numele clasei, class Pereche<A, B>, și îi folosești pentru câmpuri și metode. Metoda inversata() întoarce Pereche<B, A>. Din Java 16, cea mai scurtă variantă este un record generic.

Parametrii de tip (A, B) sunt înlocuiți la utilizare cu tipuri concrete, iar compilatorul verifică tipurile, deci nu mai ai nevoie de cast-uri:

JAVA
public final class Pereche<A, B> {
    private final A prima;
    private final B adoua;

    public Pereche(A prima, B adoua) {
        this.prima = prima;
        this.adoua = adoua;
    }
    public A prima() { return prima; }
    public B adoua() { return adoua; }

    public Pereche<B, A> inversata() {
        return new Pereche<>(adoua, prima);
    }
    public static <A, B> Pereche<A, B> of(A a, B b) {
        return new Pereche<>(a, b);
    }
}

Pereche<String, Integer> p = Pereche.of("Ana", 30);
Pereche<Integer, String> q = p.inversata();
int varsta = q.prima();   // fără cast

Observații:

  • new Pereche<>(...) folosește operatorul diamant (Java 7): tipurile se deduc din context.
  • Metoda statică of își declară proprii parametri de tip <A, B>, independenți de ai clasei, pentru că metodele statice nu au acces la parametrii de tip ai instanței.
  • Primitivele nu pot fi argumente de tip, deci Pereche<String, int> nu compilează; se folosește Integer, cu autoboxing.

Varianta modernă face același lucru, plus equals, hashCode și toString:

JAVA
public record Pereche<A, B>(A prima, B adoua) {
    public Pereche<B, A> inversata() { return new Pereche<>(adoua, prima); }
}

Pentru cod de producție, o pereche generică e utilă local, dar în API-uri publice un record cu nume de domeniu (NumeVarsta) e mai expresiv decât Pereche<String, Integer>.

Ce urmărește intervievatorul: Verifică sintaxa de bază a genericelor și înțelegerea parametrilor de tip pe clase și metode. Mulți uită că metodele statice își declară propriii parametri.

48 Mid

Ce afișează codul de mai jos și de ce? Cum transformi corect un int[] într-o listă?

JAVA
int[] numere = {3, 1, 2};
List<int[]> l1 = Arrays.asList(numere);
System.out.println(l1.size());
Integer[] boxate = {3, 1, 2};
List<Integer> l2 = Arrays.asList(boxate);
boxate[0] = 99;
System.out.println(l2);

Răspuns scurt: Afișează 1, apoi [99, 1, 2]. Genericele nu acceptă primitive, deci Arrays.asList(int[]) primește tabloul ca un singur element. Pentru Integer[], lista este o vedere peste tablou, deci modificarea tabloului se vede în listă.

Arrays.asList(T... a) are parametru generic varargs. T nu poate fi int, așa că pentru un int[] compilatorul alege T = int[] și construiește o listă cu un singur element, tabloul însuși. Codul compilează fără avertisment, iar contains(3) pe o astfel de listă întoarce false, sursă clasică de buguri.

Pentru Integer[], T = Integer, iar rezultatul este o vedere (view) peste tablou, nu o copie: lista și tabloul împart aceleași elemente. De aici:

  • modificările prin set în listă se văd în tablou și invers;
  • add și remove aruncă UnsupportedOperationException, pentru că dimensiunea tabloului e fixă;
  • elementele null sunt permise.

Conversii corecte de la int[]:

JAVA
List<Integer> lista = Arrays.stream(numere).boxed().toList();   // imuabilă (Java 16)
List<Integer> mutabila = Arrays.stream(numere).boxed()
        .collect(Collectors.toCollection(ArrayList::new));

Pentru o copie mutabilă independentă dintr-un Integer[]: new ArrayList<>(Arrays.asList(boxate)). Iar List.of(boxate) creează o copie imuabilă care nu acceptă null.

În sens invers, de la listă la tablou de primitive: lista.stream().mapToInt(Integer::intValue).toArray(). Pentru tablou de obiecte, lista.toArray(new Integer[0]) sau, din Java 11, lista.toArray(Integer[]::new).

Același fenomen apare și la List.of(numere), care dă tot List<int[]>, și la Stream.of(numere), care dă un stream cu un singur element; pentru primitive folosești IntStream.of sau Arrays.stream.

Ce urmărește intervievatorul: Verifică înțelegerea limitelor genericelor cu primitive și a semanticii de vedere. Mulți presupun că Arrays.asList copiază datele.

Eroarea, în practică:unexpected type (List<int>)UnsupportedOperationException (List.of)

49 Mid

Care este diferența dintre putIfAbsent, computeIfAbsent și merge pe un Map? Ce problemă are prima linie?

JAVA
Map<String, List<String>> grupe = new HashMap<>();
grupe.putIfAbsent("A", new ArrayList<>()).add("Ana");
grupe.computeIfAbsent("B", k -> new ArrayList<>()).add("Bogdan");
Map<String, Integer> contor = new HashMap<>();
contor.merge("x", 1, Integer::sum);

Răspuns scurt: putIfAbsent întoarce valoarea anterioară, deci null la prima inserare, iar .add aruncă NullPointerException; în plus, creează lista chiar dacă nu e nevoie. computeIfAbsent creează valoarea doar la nevoie și întoarce valoarea curentă. merge combină valoarea existentă cu una nouă.

Metodele adăugate în Map în Java 8 elimină tiparul „get, verifică null, put”, dar au semantici diferite:

  • putIfAbsent(k, v): dacă cheia lipsește (sau are valoarea null), pune v. Întoarce valoarea anterioară, adică null când a inserat. Argumentul v se evaluează întotdeauna, deci new ArrayList<>() se creează la fiecare apel.
  • computeIfAbsent(k, f): dacă cheia lipsește, calculează valoarea cu f, o inserează și o întoarce; dacă există, întoarce valoarea existentă. Funcția se apelează doar la nevoie. Dacă f întoarce null, nu se inserează nimic.
  • merge(k, v, f): dacă cheia lipsește, pune v; altfel pune f(vechi, v). Dacă f întoarce null, cheia este ștearsă. Ideal pentru contoare și sume.
  • compute(k, f) și computeIfPresent(k, f): recalculează valoarea pe baza celei vechi.
JAVA
for (String cuvant : cuvinte) {
    grupe.computeIfAbsent(cuvant.substring(0, 1), k -> new ArrayList<>()).add(cuvant);
    contor.merge(cuvant, 1, Integer::sum);
}

Restricții: funcția din computeIfAbsent nu trebuie să modifice același map; la HashMap, din Java 9 asta poate arunca ConcurrentModificationException. Un exemplu periculos este memoizarea recursivă (Fibonacci cu computeIfAbsent care se cheamă pe sine).

În ConcurrentHashMap, computeIfAbsent, compute și merge sunt atomice pentru cheia respectivă, deci înlocuiesc corect secvențele „verifică și apoi pune”, care ar avea race conditions.

Ce urmărește intervievatorul: Verifică stăpânirea API-ului Map modern și a semanticii valorilor întoarse. Bugul cu putIfAbsent(...).add apare des în cod real.

Eroarea, în practică:NPE: Integer.intValue() ... Map.get is null

50 Mid

Ai praguri de reducere: de la 0 lei 0%, de la 500 lei 5%, de la 1000 lei 10%. Cum găsești reducerea pentru o sumă oarecare folosind TreeMap? Ce alte metode de navigare cunoști?

Răspuns scurt: Pui pragurile ca chei într-un TreeMap și folosești floorEntry(suma), care întoarce cea mai mare cheie mai mică sau egală cu suma, în O(log n). TreeMap mai oferă ceilingKey, lowerKey, higherKey, headMap, tailMap, subMap, firstEntry și pollFirstEntry.

TreeMap implementează NavigableMap: cheile sunt ținute sortate într-un arbore roșu-negru, deci pe lângă căutarea exactă poți căuta „cel mai apropiat” în O(log n).

JAVA
NavigableMap<Integer, Integer> reduceri = new TreeMap<>(Map.of(
        0, 0,
        500, 5,
        1000, 10));

static int procent(NavigableMap<Integer, Integer> r, int suma) {
    Map.Entry<Integer, Integer> e = r.floorEntry(suma);
    if (e == null) throw new IllegalArgumentException("Sumă negativă: " + suma);
    return e.getValue();
}
// procent(reduceri, 750) == 5, procent(reduceri, 1000) == 10

Metodele de navigare:

  • floorKey(k): cea mai mare cheie mai mică sau egală cu k; lowerKey(k): strict mai mică;
  • ceilingKey(k): cea mai mică cheie mai mare sau egală; higherKey(k): strict mai mare;
  • toate întorc null dacă nu există o astfel de cheie, iar variantele ...Entry întorc perechea;
  • headMap(k) (chei mai mici decât k, exclusiv), tailMap(k) (de la k, inclusiv), subMap(de, pana): vederi, nu copii, deci reflectă modificările map-ului;
  • firstEntry, lastEntry, pollFirstEntry (extrage și șterge), descendingMap.

Aplicații tipice: tarife pe intervale, căutarea evenimentului cel mai apropiat de un moment dat (TreeMap<Instant, Eveniment>), ferestre de timp, programări libere. Varianta cu un șir de if-uri funcționează pentru trei praguri, dar TreeMap permite încărcarea pragurilor din configurare fără schimbări de cod. TreeSet are metode echivalente: floor, ceiling, lower, higher, headSet, tailSet.

Ce urmărește intervievatorul: Verifică dacă știi API-ul de navigare, care rezolvă elegant probleme frecvente. Mulți candidați folosesc doar get și put și nu știu că există floorEntry.

51 Mid

Scrie o funcție care întoarce cele mai mari k elemente dintr-o listă foarte mare de numere. Ce complexitate are și de ce afișarea directă a unei PriorityQueue nu iese sortată?

Răspuns scurt: Folosești un min-heap (PriorityQueue) de dimensiune k: adaugi fiecare element și, când depășești k, scoți minimul. Complexitatea este O(n log k), cu O(k) memorie. PriorityQueue garantează doar că vârful e minimul; iterarea urmează ordinea internă a heap-ului.

Soluția simplă este sortarea întregii liste și luarea ultimelor k: O(n log n) și o copie a tuturor datelor. Când n este mare și k mic, un heap de dimensiune k e mult mai eficient:

JAVA
static List<Integer> topK(Iterable<Integer> numere, int k) {
    PriorityQueue<Integer> heap = new PriorityQueue<>(k + 1);   // min-heap
    for (int x : numere) {
        heap.offer(x);
        if (heap.size() > k) {
            heap.poll();            // scoate cel mai mic
        }
    }
    List<Integer> rezultat = new ArrayList<>(heap);
    rezultat.sort(Comparator.reverseOrder());
    return rezultat;
}

În heap rămân mereu cele mai mari k elemente văzute până acum; vârful este cel mai mic dintre ele, deci orice element nou mai mic decât vârful este eliminat imediat. Fiecare offer și poll costă O(log k), deci totalul este O(n log k). Funcționează și pe date care vin în flux, fără să le ții pe toate în memorie.

PriorityQueue este un heap binar stocat într-un tablou. Invariantul garantează doar că fiecare părinte este mai mic decât copiii, nu că tabloul e sortat. De aceea System.out.println(heap) sau un for-each afișează elementele într-o ordine care pare aleatoare. Ordinea sortată se obține doar extrăgând repetat cu poll().

Alte detalii: implicit este min-heap după ordinea naturală; pentru max-heap folosești new PriorityQueue<>(Comparator.reverseOrder()). remove(Object) și contains sunt O(n). Nu acceptă null și nu este thread-safe; varianta concurentă este PriorityBlockingQueue.

Ce urmărește intervievatorul: Verifică alegerea structurii potrivite pentru o problemă clasică și înțelegerea heap-ului. Mulți presupun că iterarea unei PriorityQueue e sortată.

52 Mid

De ce primul fragment nu compilează, iar al doilea compilează dar aruncă excepție la rulare?

JAVA
List<String> texte = new ArrayList<>();
List<Object> obiecte = texte;          // eroare de compilare
JAVA
String[] texte = new String[2];
Object[] obiecte = texte;              // compilează
obiecte[0] = 42;                       // ?

Răspuns scurt: Genericele sunt invariante: List<String> nu este subtip al lui List<Object>, altfel ai putea adăuga un Integer într-o listă de texte. Tablourile sunt covariante, deci atribuirea compilează, dar JVM-ul verifică tipul la rulare și aruncă ArrayStoreException.

Dacă Java ar permite List<Object> obiecte = texte;, ai putea scrie obiecte.add(42), iar lista texte ar conține un Integer. Eroarea ar apărea mult mai târziu, la un String s = texte.get(0), cu ClassCastException într-un loc fără legătură cu cauza. De aceea genericele sunt invariante: List<String> și List<Object> sunt tipuri fără relație de subtip, chiar dacă String extinde Object.

Tablourile au fost proiectate înainte de generice și sunt covariante: String[] este subtip al lui Object[]. Ca să compenseze, fiecare tablou își știe tipul real al elementelor la rulare, iar fiecare scriere este verificată. obiecte[0] = 42 aruncă ArrayStoreException: java.lang.Integer. Eroarea se mută deci de la compilare la rulare.

Diferența ține de type erasure: la rulare, un ArrayList<String> este doar un ArrayList, deci JVM-ul nu ar putea face o verificare similară pentru liste. De aceea verificarea trebuie făcută integral de compilator.

Când ai nevoie de flexibilitate, folosești wildcard-uri:

JAVA
static double suma(List<? extends Number> numere) {   // citire
    double s = 0;
    for (Number n : numere) s += n.doubleValue();
    return s;
}
static void adaugaZero(List<? super Integer> lista) {  // scriere
    lista.add(0);
}

List<? extends Number> acceptă List<Integer> și List<Double>, dar nu permite adăugare (cu excepția lui null). Tot din cauza acestei incompatibilități nu poți crea tablouri generice: new List<String>[10] nu compilează, iar combinația dintre varargs și generice produce avertismente de tip „heap pollution”.

Ce urmărește intervievatorul: Întrebarea verifică dacă înțelegi de ce genericele sunt invariante, nu doar regula. Puțini candidați pot explica legătura cu ArrayStoreException și type erasure.

Eroarea, în practică:generic array creationArrayStoreException

53 Senior

Scrie o metodă generică max care întoarce cel mai mare element dintr-o colecție și funcționează și pentru List<Caine>, unde Caine extends Animal și Animal implements Comparable<Animal>. Explică semnătura.

Răspuns scurt: Semnătura este <T extends Comparable<? super T>> T max(Collection<? extends T> c). ? super T permite tipuri comparabile prin superclasă, cum e Caine, care e Comparable<Animal>, nu Comparable<Caine>. ? extends T acceptă colecții de subtipuri.

Prima încercare naturală este <T extends Comparable<T>> T max(Collection<T> c). Ea funcționează pentru List<String>, pentru că String implements Comparable<String>. Pentru List<Caine> însă, Caine implementează Comparable<Animal> (moștenit), nu Comparable<Caine>, deci limita T extends Comparable<T> nu este satisfăcută și codul nu compilează.

Varianta corectă:

JAVA
public static <T extends Comparable<? super T>> T max(Collection<? extends T> elemente) {
    Iterator<? extends T> it = elemente.iterator();
    if (!it.hasNext()) {
        throw new NoSuchElementException("Colecție goală");
    }
    T maxim = it.next();
    while (it.hasNext()) {
        T curent = it.next();
        if (curent.compareTo(maxim) > 0) {
            maxim = curent;
        }
    }
    return maxim;
}

Explicația semnăturii, după regula PECS (Producer Extends, Consumer Super):

  • Comparable<? super T>: un Comparable consumă obiecte (le primește la compareTo), deci e suficient ca T să se poată compara cu un supertip al său. Caine se compară cu orice Animal, inclusiv cu alți câini.
  • Collection<? extends T>: colecția produce elemente de tip T sau subtipuri, pe care le citim.

În JDK, Collections.max are semnătura <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll). Limita suplimentară Object & există din motive de compatibilitate binară: după erasure, tipul returnat devine Object, ca în versiunea de dinainte de generice, nu Comparable.

Decizia de design de discutat: pentru colecție goală poți arunca excepție (ca JDK-ul) sau întoarce Optional<T>, cum face Stream.max.

Ce urmărește intervievatorul: Verifică stăpânirea reală a limitelor și wildcard-urilor, nu doar recitarea PECS. Este o întrebare de nivel avansat, des folosită pentru a separa mid de senior.

Eroarea, în practică:List<Integer> cannot be converted to List<Number>

54 Senior

Când ai folosi EnumMap, EnumSet, IdentityHashMap sau WeakHashMap în loc de HashMap/HashSet? Ce capcane are WeakHashMap?

Răspuns scurt: EnumMap și EnumSet pentru chei enum, fiind rapide și compacte. IdentityHashMap când contează identitatea (==), de exemplu la parcurgeri de grafuri. WeakHashMap pentru metadate care dispar odată cu cheia; nu merge cu chei care rămân mereu accesibile.

Fiecare rezolvă un caz specific:

  • EnumSet stochează un set de constante enum ca vector de biți (un long pentru până la 64 de constante). contains, add și operațiile de mulțime sunt operații pe biți. Înlocuiește elegant flag-urile int: EnumSet.of(Permisiune.CITIRE, Permisiune.SCRIERE), EnumSet.complementOf(...).
  • EnumMap folosește un tablou indexat după ordinal(). Nu calculează hash-uri, iterează în ordinea declarării constantelor și consumă puțină memorie. Exemplu: EnumMap<StatusComanda, Long> pentru statistici.
  • IdentityHashMap încalcă intenționat contractul Map: compară cheile cu == și folosește System.identityHashCode. Este util când contează identitatea obiectelor, nu egalitatea lor: detectarea ciclurilor la parcurgerea unui graf de obiecte, copiere profundă, serializare, proxy-uri.
  • WeakHashMap păstrează cheile prin WeakReference. Când cheia nu mai e referită din altă parte, garbage collector-ul o poate colecta, iar intrarea dispare din map. E folosit pentru metadate asociate unor obiecte a căror viață nu o controlezi.

Capcanele WeakHashMap:

  • cheile care rămân mereu accesibile (literali String, Integer din cache-ul -128..127, constante enum, clase) nu dispar niciodată;
  • dacă valoarea referă cheia, direct sau indirect, intrarea nu se eliberează, pentru că valorile sunt referite puternic;
  • dimensiunea se schimbă imprevizibil, după rularea GC-ului;
  • nu este thread-safe;
  • nu e un cache bun: intrările dispar la primul GC, nu în funcție de memorie sau de vechime.

Pentru cache-uri reale, se folosește o bibliotecă precum Caffeine, cu limită de dimensiune și expirare.

Ce urmărește intervievatorul: Verifică familiaritatea cu colecțiile specializate și cu interacțiunea dintre colecții și garbage collector. Greșeala frecventă: WeakHashMap folosit ca cache general.

Excepții

Exersează capitolul cu exerciții reale: Curs Java →
55 Junior

De ce nu compilează primul bloc? Ce este greșit în al doilea?

JAVA
try {
    Files.readString(Path.of("date.txt"));
} catch (Exception e) {
    System.out.println("Eroare");
} catch (IOException e) {
    System.out.println("Fișier");
}
JAVA
try { ... }
catch (FileNotFoundException | IOException e) { ... }

Răspuns scurt: Blocurile catch se verifică în ordine, iar Exception prinde deja orice IOException, deci al doilea catch ar fi inaccesibil: eroare de compilare. În multi-catch, tipurile nu pot fi în relație de moștenire, iar FileNotFoundException extinde IOException.

La aruncarea unei excepții, JVM-ul parcurge blocurile catch de sus în jos și îl alege pe primul compatibil. Dacă un catch pentru o superclasă stă înaintea unuia pentru o subclasă, al doilea nu poate fi atins niciodată. Compilatorul raportează asta ca eroare: „exception IOException has already been caught”. Regula: de la specific la general.

JAVA
try {
    String continut = Files.readString(Path.of("date.txt"));
} catch (NoSuchFileException e) {
    System.out.println("Fișierul nu există: " + e.getFile());
} catch (IOException e) {
    System.out.println("Eroare de citire: " + e.getMessage());
}

Multi-catch (Java 7) tratează mai multe tipuri în același bloc: catch (IOException | SQLException e). Reguli:

  • tipurile nu pot fi unul subclasa celuilalt, pentru că ar fi redundant; în exemplu ajunge catch (IOException e);
  • variabila e este implicit final, deci nu o poți reatribui;
  • tipul static al lui e este cel mai apropiat supertip comun, deci ai acces doar la metodele acestuia.

Un alt caz de cod inaccesibil: un catch pentru o excepție checked pe care blocul try nu o poate arunca (catch (IOException e) în jurul unui cod care nu face I/O) este tot eroare de compilare. Pentru Exception și excepțiile unchecked, regula nu se aplică, pentru că orice cod le poate arunca.

În practică, catch (Exception e) larg e potrivit doar la granițele aplicației (un handler global, bucla principală a unui worker), unde excepția e logată și transformată într-un răspuns de eroare.

Ce urmărește intervievatorul: Verifică ordinea blocurilor catch și regulile multi-catch. Candidații greșesc des ordinea sau pun în multi-catch o clasă și subclasa ei.

Eroarea, în practică:exception ... has already been caught

56 Junior

Ce afișează metoda următoare? Ce s-ar schimba dacă blocul catch ar prinde NullPointerException în loc de ArithmeticException?

JAVA
static void test() {
    try {
        System.out.println("A");
        int x = 10 / 0;
        System.out.println("B");
    } catch (ArithmeticException e) {
        System.out.println("C");
    } finally {
        System.out.println("D");
    }
    System.out.println("E");
}

Răspuns scurt: Afișează A, C, D, E. După excepție, restul blocului try se sare, se execută catch, apoi finally, apoi codul de după. Dacă catch nu se potrivește, se afișează A și D, iar excepția continuă spre apelant, deci E nu se mai afișează.

Fluxul de execuție cu excepții:

  • În try, instrucțiunile rulează până la prima excepție. 10 / 0 aruncă ArithmeticException, deci B nu se mai afișează.
  • JVM-ul caută primul catch compatibil. Îl găsește, execută C, iar excepția se consideră tratată.
  • finally rulează întotdeauna la ieșirea din try/catch, indiferent dacă a fost excepție sau nu: D.
  • Metoda continuă normal: E.

În varianta cu catch (NullPointerException e), niciun bloc nu se potrivește. finally se execută totuși (D), apoi excepția se propagă către metoda apelantă, iar instrucțiunile de după try nu mai rulează. Dacă nimeni nu o prinde, thread-ul se oprește, iar JVM-ul afișează stack trace-ul.

Cazuri în care finally nu rulează: System.exit() în try, oprirea forțată a procesului, sau un thread daemon oprit la închiderea JVM-ului.

Alte situații utile la interviu:

  • O excepție aruncată din catch se propagă după ce rulează finally.
  • O excepție aruncată din finally o înlocuiește pe cea originală, care se pierde. De aceea codul din finally trebuie să fie cât mai sigur.
  • return în try nu sare peste finally: întâi rulează finally, apoi metoda se întoarce.

În cod modern, finally se folosește mai rar pentru resurse, pentru că try-with-resources închide automat obiectele AutoCloseable. Rămâne util pentru alte operații de curățenie, cum ar fi eliberarea unui Lock.

Ce urmărește intervievatorul: Verifică înțelegerea exactă a fluxului de control. Greșeala frecventă este să crezi că E se afișează și când excepția nu e prinsă.

Eroarea, în practică:ArithmeticException: / by zero'try' without 'catch', 'finally' or resources

57 Junior

Cum citești un stack trace ca acesta? Unde te uiți întâi?

Exception in thread "main" java.lang.IllegalStateException: Comanda nu poate fi procesată
    at ro.shop.ComandaService.proceseaza(ComandaService.java:42)
    at ro.shop.Main.main(Main.java:10)
Caused by: java.lang.NullPointerException: Cannot invoke "ro.shop.Client.email()" because "client" is null
    at ro.shop.Notificari.trimite(Notificari.java:18)
    at ro.shop.ComandaService.proceseaza(ComandaService.java:39)
    ... 1 more

Răspuns scurt: Prima linie spune tipul și mesajul excepției, apoi urmează apelurile de la cel mai recent la cel mai vechi. Cauza reală este de obicei în ultimul Caused by: aici, client este null la linia 18 din Notificari, apelată de la linia 39 din ComandaService.

Structura unui stack trace:

  • Prima linie: thread-ul, tipul excepției și mesajul. Aici, IllegalStateException cu un mesaj de business.
  • Liniile at: stiva de apeluri în momentul creării excepției, de sus (cel mai recent) în jos (cel mai vechi). Fiecare linie are clasa, metoda, fișierul și numărul liniei.
  • Caused by:: excepția originală, atașată ca și cauză când codul a prins o excepție și a aruncat alta. Pot fi mai multe niveluri; cea mai de jos este, de regulă, cauza rădăcină.
  • ... 1 more: cadrele identice cu cele ale excepției de deasupra au fost omise, ca să nu se repete.

Metoda de lucru:

  • Mergi la ultimul Caused by și citește mesajul. Din Java 14, mesajele de NullPointerException spun exact ce era null (aici, variabila client).
  • Caută primul cadru din codul tău, nu din biblioteci sau framework: Notificari.java:18.
  • Urcă pe stivă ca să afli de unde a venit valoarea greșită: ComandaService.java:39 a transmis un client null. Acolo e probabil bugul real, nu la linia 18.
  • Verifică dacă versiunea codului corespunde cu cea care rulează, altfel numerele de linie induc în eroare.

În aplicațiile cu framework-uri, stack trace-urile au zeci de linii de proxy-uri și reflecție. Filtrarea vizuală după pachetul aplicației (ro.shop) economisește timp, iar IDE-urile permit lipirea unui stack trace pentru navigare directă la linii.

Ce urmărește intervievatorul: Intervievatorul verifică o abilitate practică de zi cu zi. Junior-ii slabi se uită doar la prima linie și ignoră Caused by.

Eroarea, în practică:InvocationTargetException

58 Junior

Scrie o metodă care transformă un text introdus de utilizator într-un număr întreg fără să arunce excepție pentru valori invalide. Ce valori fac Integer.parseInt să eșueze?

Răspuns scurt: Integer.parseInt aruncă NumberFormatException pentru text gol, spații, litere, zecimale sau valori în afara intervalului int; pentru null aruncă tot NumberFormatException. Prinzi excepția într-o metodă care întoarce OptionalInt sau o valoare implicită.

Comportamentul lui Integer.parseInt:

  • "42", "-7", "+7" sunt acceptate;
  • "", " 42" (spațiu), "4 2", "12a", "3.5" aruncă NumberFormatException;
  • "3000000000" aruncă tot NumberFormatException, pentru că depășește int;
  • null aruncă NumberFormatException (cu mesajul „Cannot parse null string”), nu NullPointerException.

NumberFormatException este unchecked (extinde IllegalArgumentException), deci compilatorul nu te obligă să o tratezi, iar inputul greșit poate opri programul.

O metodă sigură pentru input de la utilizator:

JAVA
static OptionalInt parseazaInt(String text) {
    if (text == null) return OptionalInt.empty();
    try {
        return OptionalInt.of(Integer.parseInt(text.strip()));
    } catch (NumberFormatException e) {
        return OptionalInt.empty();
    }
}

int varsta = parseazaInt(input).orElse(-1);

Decizii de discutat:

  • strip() elimină spațiile accidentale, o toleranță rezonabilă pentru input uman.
  • OptionalInt comunică clar că rezultatul poate lipsi, mai bine decât o valoare „magică”.
  • Pentru validare în formulare, e mai util să întorci mesajul de eroare către utilizator („Introduceți un număr întreg”) decât să înghiți problema.

Variante înrudite: Long.parseLong, Double.parseDouble (acceptă și "1e3" și "NaN"), Integer.valueOf (întoarce Integer, folosind cache-ul pentru valori mici), new BigDecimal(text) pentru sume. Pentru numere scrise cu virgulă zecimală românească („3,5”), parseDouble eșuează și ai nevoie de NumberFormat.getInstance(Locale.forLanguageTag("ro")).

Ce urmărește intervievatorul: Verifică tratarea inputului nesigur și cunoașterea cazurilor limită. Mulți nu știu că spațiile sau null duc la excepție.

Eroarea, în practică:String cannot be converted to intNumberFormatException: For input string

59 Junior

Ce se întâmplă la rularea metodei de mai jos? Este o idee bună să prinzi StackOverflowError?

JAVA
static long factorial(int n) {
    return n * factorial(n - 1);
}

Răspuns scurt: Metoda nu are caz de bază, deci se apelează la infinit până se umple stiva thread-ului și JVM-ul aruncă StackOverflowError. Este un Error, nu o Exception: semnalează o problemă gravă și nu trebuie prinsă ca mecanism normal, ci reparată în cod.

Fiecare apel de metodă adaugă pe stiva thread-ului un cadru (stack frame) cu parametrii și variabilele locale. Stiva are o dimensiune limitată (configurabilă cu -Xss, de obicei de ordinul sutelor de KB până la câțiva MB). Fără o condiție de oprire, recursivitatea o umple și apare StackOverflowError.

Varianta corectă:

JAVA
static long factorial(int n) {
    if (n < 0) throw new IllegalArgumentException("n negativ: " + n);
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

Chiar și corectă, metoda depășește intervalul long de la n = 21, deci pentru valori mari ai nevoie de BigInteger. Iar pentru adâncimi mari de recursivitate (zeci de mii de niveluri), varianta iterativă e mai sigură, pentru că Java nu face optimizarea apelurilor de coadă (tail call optimization).

Ierarhia: Throwable are doi copii, Exception (situații din care aplicația se poate reveni) și Error (probleme ale mediului de execuție: StackOverflowError, OutOfMemoryError, NoClassDefFoundError). Tehnic poți scrie catch (StackOverflowError e), dar:

  • starea programului poate fi inconsistentă în momentul erorii;
  • prinderea ascunde un bug care trebuie reparat;
  • un catch (Throwable t) larg prinde și erori pe care nu ai cum să le tratezi.

Cazul legitim de a prinde Error este la granița aplicației, pentru logare înainte de oprire. Alte surse tipice de StackOverflowError: toString sau equals cu referințe ciclice între obiecte și relații bidirecționale serializate în JSON.

Ce urmărește intervievatorul: Verifică înțelegerea recursivității, a stivei și a diferenței Error/Exception. Greșeala tipică este tratarea erorii cu catch în loc de reparare.

Eroarea, în practică:StackOverflowError

60 Mid

Ce excepție ajunge la apelant în codul de mai jos? Ce sunt excepțiile suprimate?

JAVA
class Resursa implements AutoCloseable {
    private final String nume;
    Resursa(String nume) { this.nume = nume; }
    @Override public void close() {
        System.out.println("închid " + nume);
        throw new IllegalStateException("close " + nume);
    }
}
try (Resursa a = new Resursa("A"); Resursa b = new Resursa("B")) {
    throw new RuntimeException("corp");
}

Răspuns scurt: Se afișează „închid B”, apoi „închid A”: resursele se închid în ordine inversă. Ajunge RuntimeException("corp"), iar cele două excepții din close() sunt atașate ca excepții suprimate, accesibile cu getSuppressed().

Try-with-resources (Java 7) garantează închiderea fiecărei resurse declarate în paranteze, în ordinea inversă declarării. E logic: b poate depinde de a (de exemplu un PreparedStatement creat dintr-o Connection), deci b se închide primul.

Problema pe care o rezolvă excepțiile suprimate: dacă atât corpul, cât și close() aruncă, care excepție contează? Cu try/finally clasic, excepția din finally o înlocuia pe cea din corp, iar cauza reală se pierdea. Try-with-resources păstrează excepția principală (din corp) și o atașează pe cea din close() cu addSuppressed:

JAVA
try (Resursa a = new Resursa("A"); Resursa b = new Resursa("B")) {
    throw new RuntimeException("corp");
} catch (RuntimeException e) {
    System.out.println(e.getMessage());                  // corp
    for (Throwable s : e.getSuppressed()) {
        System.out.println("suprimată: " + s.getMessage()); // close B, close A
    }
}

Dacă doar close() aruncă (corpul se termină normal), excepția din close() devine excepția principală. Stack trace-ul afișează excepțiile suprimate în secțiuni Suppressed:, deci logurile nu pierd informația.

Detalii suplimentare:

  • Din Java 9, poți folosi în paranteze o variabilă existentă, efectiv final: try (conexiune) { ... }.
  • catch și finally atașate unui try-with-resources rulează după închiderea resurselor.
  • close() din AutoCloseable poate arunca Exception; Closeable (din java.io) restrânge la IOException și cere ca închiderea repetată să nu aibă efect.

Ce urmărește intervievatorul: Verifică înțelegerea detaliată a try-with-resources, dincolo de „închide automat”. Puțini candidați știu de ordinea inversă și de getSuppressed().

Eroarea, în practică:try-with-resources not applicable to variable typeIOException: Stream closed

61 Mid

Ce problemă are codul de mai jos? Cum ar trebui transformată o excepție tehnică într-una de business?

JAVA
public Comanda incarca(long id) {
    try {
        return repository.gaseste(id);
    } catch (SQLException e) {
        throw new ComandaException("Eroare la încărcare: " + e.getMessage());
    }
}

Răspuns scurt: Excepția nouă nu păstrează cauza, deci stack trace-ul original și tipul erorii SQL se pierd. Corect este înlănțuirea: throw new ComandaException("Nu pot încărca comanda " + id, e);, cu un constructor care primește Throwable cause.

Înlănțuirea excepțiilor (exception chaining) înseamnă că excepția nouă păstrează referința către cea originală, accesibilă cu getCause() și afișată în stack trace ca „Caused by:”. În codul dat se păstrează doar mesajul. La depanare vei vedea că încărcarea a eșuat, dar nu și unde: în driverul JDBC, în pool-ul de conexiuni sau într-o constrângere a bazei de date. SQLException are și informații specifice (getSQLState(), getErrorCode()), care se pierd și ele.

Varianta corectă:

JAVA
public class ComandaException extends RuntimeException {
    public ComandaException(String mesaj, Throwable cauza) {
        super(mesaj, cauza);
    }
}

public Comanda incarca(long id) {
    try {
        return repository.gaseste(id);
    } catch (SQLException e) {
        throw new ComandaException("Nu pot încărca comanda " + id, e);
    }
}

Principii de traducere a excepțiilor:

  • Abstracția potrivită: stratul de servicii nu ar trebui să expună SQLException apelanților; o traduce într-o excepție a domeniului său. Spring face asta automat, transformând erorile JDBC în ierarhia DataAccessException.
  • Context util în mesaj: id-ul comenzii, operația încercată. Mesajul cauzei apare oricum în „Caused by”.
  • Logare o singură dată: fie loghezi, fie arunci mai departe, nu ambele la fiecare nivel, ca să nu apară aceeași eroare de cinci ori în loguri.
  • Nu înghiți excepții: un catch gol sau doar cu e.printStackTrace() ascunde problema.

Dacă excepția trebuie doar propagată, fără context nou, nu o împacheta deloc: lasă-o să urce.

Ce urmărește intervievatorul: Verifică bunele practici la propagarea erorilor între straturi. Pierderea cauzei este una dintre cele mai frecvente greșeli la code review.

62 Senior

Un coleg folosește excepții pentru controlul fluxului, de exemplu aruncă o excepție ca să iasă dintr-o buclă de căutare. De ce este costisitor și când poate fi totuși acceptabil? Cum se poate reduce costul unei excepții?

Răspuns scurt: Partea scumpă este capturarea stack trace-ului la construcție (fillInStackTrace), care parcurge toată stiva. În plus, ascunde intenția codului și împiedică optimizările JIT. Costul se reduce cu excepții fără stack trace (constructorul cu writableStackTrace = false), dar soluția corectă e de obicei alt design.

Când creezi un Throwable, constructorul apelează fillInStackTrace(), care parcurge stiva thread-ului și înregistrează cadrele. Cu cât stiva e mai adâncă (aplicații cu framework-uri au ușor peste o sută de cadre), cu atât costul e mai mare. Aruncarea și prinderea propriu-zisă, mai ales când se întâmplă în aceeași metodă după inlining, sunt relativ ieftine.

Problemele folosirii excepțiilor pentru flux normal:

  • Performanță: într-o buclă fierbinte, crearea repetată a stack trace-urilor poate domina timpul de execuție.
  • Lizibilitate: cititorul se așteaptă ca o excepție să semnaleze ceva anormal; un throw ca alternativă la break sau return ascunde logica.
  • Observabilitate: logurile și uneltele de monitorizare raportează excepții, deci fluxul normal produce zgomot.

Pentru o excepție folosită des și intenționat, poți elimina capturarea stivei:

JAVA
public final class ValidareEsuata extends RuntimeException {
    public ValidareEsuata(String mesaj) {
        super(mesaj, null, false, false);   // fără suppressed, fără stack trace
    }
}

Constructorul protected Throwable(String, Throwable, boolean enableSuppression, boolean writableStackTrace) există din Java 7. Dezavantajul: când ceva chiar merge prost, nu știi de unde a venit excepția.

Un detaliu de JVM: HotSpot are optimizarea OmitStackTraceInFastThrow, activă implicit, care, după multe aruncări repetate ale unor excepții implicite (NullPointerException, ArithmeticException) din același loc, refolosește o instanță fără stack trace. În loguri apar atunci NPE-uri fără nicio linie at, iar dezactivarea se face cu -XX:-OmitStackTraceInFastThrow.

Alternativele de design: valori de retur explicite (Optional, un record rezultat, un tip sealed cu Succes și Eroare), metode de verificare prealabilă sau break cu etichetă pentru bucle imbricate.

Ce urmărește intervievatorul: Verifică înțelegerea costului real al excepțiilor și judecata de design. Intervievatorul apreciază când candidatul știe de OmitStackTraceInFastThrow din experiența cu loguri.

Lambda, streams și Optional

63 Junior

De ce nu compilează codul de mai jos? Cum obții corect numărul de elemente care respectă condiția?

JAVA
int contor = 0;
lista.forEach(x -> {
    if (x > 10) contor++;
});

Răspuns scurt: Lambda-urile pot folosi doar variabile locale final sau effectively final (care nu se mai modifică după inițializare). contor++ modifică variabila, deci compilatorul refuză. Corect: long contor = lista.stream().filter(x -> x > 10).count();.

Mesajul compilatorului este „local variables referenced from a lambda expression must be final or effectively final”. O variabilă este effectively final dacă nu e declarată final, dar nu este reatribuită nicăieri după inițializare.

De ce există regula: lambda-ul capturează valoarea variabilei locale, nu variabila însăși. Variabilele locale trăiesc pe stiva metodei, iar lambda-ul poate fi executat mai târziu, după ce metoda s-a terminat, sau pe alt thread. Dacă modificarea ar fi permisă, ar apărea două copii nesincronizate sau acces concurent nesigur. Restricția nu se aplică pentru câmpuri (this.contor++ compilează), tocmai pentru că acestea trăiesc în heap, dar asta nu face codul thread-safe.

Soluții, în ordinea preferinței:

JAVA
long peste10 = lista.stream().filter(x -> x > 10).count();

// dacă chiar ai nevoie de un contor într-un callback:
AtomicInteger contor = new AtomicInteger();
lista.forEach(x -> { if (x > 10) contor.incrementAndGet(); });

// for-each clasic, simplu și lizibil:
int c = 0;
for (int x : lista) if (x > 10) c++;

Trucul cu tablou de un element (int[] contor = {0}; ... contor[0]++) compilează, pentru că referința tabloului rămâne aceeași, dar e considerat un hack: ascunde o stare mutabilă și nu e sigur în stream-uri paralele.

Ideea mai largă: în stilul funcțional, rezultatul se obține prin operații care întorc valori (count, sum, collect), nu prin efecte secundare din lambda. Aceeași regulă de captură se aplică și claselor anonime și locale.

Ce urmărește intervievatorul: Verifică înțelegerea regulii de captură și a motivului ei. Greșeala tipică este ocolirea cu int[] fără a ști de ce e o problemă.

64 Junior

Ce afișează codul de mai jos? Explică andThen, compose și combinarea predicatelor.

JAVA
Function<Integer, Integer> dublu = x -> x * 2;
Function<Integer, Integer> plusTrei = x -> x + 3;
System.out.println(dublu.andThen(plusTrei).apply(5));
System.out.println(dublu.compose(plusTrei).apply(5));

Predicate<String> gol = String::isBlank;
Predicate<String> lung = s -> s.length() > 5;
System.out.println(gol.negate().and(lung).test("Java 21"));

Răspuns scurt: Afișează 13, 16 și true. f.andThen(g) aplică întâi f, apoi g; f.compose(g) aplică întâi g, apoi f. Predicatele se combină cu and, or, negate, iar din Java 11 există și Predicate.not.

Interfețele funcționale din java.util.function au metode default care construiesc funcții noi din funcții existente:

  • dublu.andThen(plusTrei) înseamnă x -> plusTrei(dublu(x)): 5 * 2 = 10, apoi 10 + 3 = 13.
  • dublu.compose(plusTrei) înseamnă x -> dublu(plusTrei(x)): 5 + 3 = 8, apoi 8 * 2 = 16.
  • gol.negate().and(lung) este „nu e gol și are peste 5 caractere”. "Java 21" are 7 caractere, deci true.

and și or au scurtcircuitare, la fel ca && și ||: dacă primul predicat decide rezultatul, al doilea nu se mai evaluează.

Predicate.not (Java 11) face codul mai lizibil în stream-uri, mai ales cu referințe la metode:

JAVA
List<String> completate = campuri.stream()
        .filter(Predicate.not(String::isBlank))
        .toList();

Varianta filter(s -> !s.isBlank()) e echivalentă, dar not(String::isBlank) se citește mai natural.

Compunerea este utilă când regulile se configurează dinamic, de exemplu filtre alese de utilizator într-o interfață de căutare:

JAVA
Predicate<Produs> filtru = p -> true;
if (doarInStoc) filtru = filtru.and(Produs::inStoc);
if (pretMaxim != null) filtru = filtru.and(p -> p.pret() <= pretMaxim);

UnaryOperator<T> este o Function<T, T>, iar Function.identity() întoarce funcția care nu schimbă nimic, utilă ca punct de plecare sau în Collectors.toMap.

Ce urmărește intervievatorul: Verifică dacă știi să construiești comportament prin compunere, nu doar să scrii lambda-uri izolate. Ordinea andThen versus compose este greșită frecvent.

65 Junior

Ce se întâmplă la rularea codului de mai jos și cum îl repari?

JAVA
Stream<String> nume = Stream.of("Ana", "Bogdan", "Cristi");
long lungi = nume.filter(n -> n.length() > 3).count();
List<String> mari = nume.map(String::toUpperCase).toList();

Răspuns scurt: A doua utilizare aruncă IllegalStateException: stream has already been operated upon or closed. Un Stream poate fi consumat o singură dată. Fie creezi un stream nou din sursă de fiecare dată, fie folosești un Supplier<Stream<String>>.

Un Stream nu este o colecție, ci o secvență de operații peste o sursă de date. După ce o operație terminală (count, toList, forEach, collect) a rulat, stream-ul este consumat și închis. Chiar și înlănțuirea unei operații intermediare pe un stream deja folosit (nume.map(...)) aruncă IllegalStateException.

Motivul de design: sursa poate fi una care nu se poate parcurge de două ori, de exemplu liniile unui fișier citit, datele de pe rețea sau un generator. Stream-urile nu memorează elementele.

Soluții:

JAVA
List<String> sursa = List.of("Ana", "Bogdan", "Cristi");
long lungi = sursa.stream().filter(n -> n.length() > 3).count();
List<String> mari = sursa.stream().map(String::toUpperCase).toList();

// dacă vrei să refolosești definiția pipeline-ului:
Supplier<Stream<String>> lungiS = () -> sursa.stream().filter(n -> n.length() > 3);
long c = lungiS.get().count();
List<String> l = lungiS.get().toList();

Dacă ai nevoie de mai multe rezultate și sursa e costisitoare (de exemplu un fișier mare), poți calcula totul într-o singură trecere cu un colector, de exemplu Collectors.teeing (Java 12), care combină doi colectori, sau Collectors.partitioningBy.

Ca regulă practică, nu ține stream-uri în câmpuri și nu le întoarce din metode decât dacă apelantul înțelege că le poate consuma o singură dată. Pentru API-uri, întoarcerea unei List este mai sigură. Stream-urile peste resurse (Files.lines) trebuie închise, deci se folosesc în try-with-resources.

Ce urmărește intervievatorul: Verifică dacă înțelegi că un stream nu e o colecție. Greșeala apare des când cineva salvează un stream într-o variabilă și îl folosește de două ori.

Eroarea, în practică:stream has already been operated upon or closed

66 Junior

Scrie cu Stream API o expresie care calculează suma pătratelor numerelor pare dintr-o listă List<Integer>. Ce s-ar schimba dacă lista ar putea conține și null?

Răspuns scurt: lista.stream().filter(n -> n % 2 == 0).mapToInt(n -> n * n).sum(). Pentru null, adaugi filter(Objects::nonNull) înaintea condiției, altfel dezambalarea aruncă NullPointerException. Pentru valori mari, folosești mapToLong ca să eviți depășirea.

Pașii pipeline-ului:

JAVA
int suma = lista.stream()
        .filter(n -> n % 2 == 0)     // păstrează numerele pare
        .mapToInt(n -> n * n)        // trece la IntStream, fără boxing
        .sum();                      // operație terminală

De ce mapToInt și nu map: map ar produce un Stream<Integer>, care nu are metoda sum(). Ai putea scrie .map(n -> n * n).reduce(0, Integer::sum), dar fiecare rezultat intermediar ar fi un obiect Integer. Stream-urile specializate (IntStream, LongStream, DoubleStream) lucrează direct cu primitive și au sum, average, min, max, summaryStatistics.

Detalii de corectitudine:

  • n % 2 == 0 funcționează și pentru numere negative; n % 2 == 1 ar rata numerele negative impare la verificarea opusă.
  • Dacă lista conține null, condiția n % 2 dezambalează null și aruncă NullPointerException. Soluția: .filter(Objects::nonNull) primul.
  • sum() pe IntStream întoarce int și poate depăși intervalul. Pentru siguranță:
JAVA
long suma = lista.stream()
        .filter(Objects::nonNull)
        .filter(n -> n % 2 == 0)
        .mapToLong(n -> (long) n * n)
        .sum();

Cast-ul (long) n înainte de înmulțire contează: n * n ar fi calculat ca int și ar depăși înainte de conversie.

Pentru comparație, bucla for echivalentă are patru linii și este la fel de corectă. La interviu, stream-ul arată că știi API-ul, iar discuția despre null și overflow arată atenție la detalii.

Ce urmărește intervievatorul: Verifică folosirea fluentă a stream-urilor primitive și atenția la cazurile limită. Mulți uită de mapToInt și încearcă .sum() pe un Stream<Integer>.

Eroarea, în practică:NPE: Integer.intValue() ... Map.get is null

67 Junior

Ce tip întoarce fiecare expresie și ce afișează ultima linie?

JAVA
List<Integer> note = List.of();
var a = note.stream().mapToInt(Integer::intValue).sum();
var b = note.stream().mapToInt(Integer::intValue).average();
var c = note.stream().max(Integer::compare);
System.out.println(a + " " + b.isPresent() + " " + c.orElse(-1));

Răspuns scurt: a este int, b este OptionalDouble, iar c este Optional<Integer>. Afișează 0 false -1. Suma unei liste goale are o valoare naturală (0), dar media și maximul nu există, de aceea sunt întoarse ca Optional.

API-ul face distincție între operațiile care au un rezultat natural pentru o secvență goală și cele care nu au:

  • sum() pe IntStream întoarce int; suma elementelor unei secvențe goale este 0, element neutru al adunării.
  • average() întoarce OptionalDouble; media unei secvențe goale ar însemna împărțire la zero, deci rezultatul lipsește.
  • max(comparator) pe Stream<Integer> întoarce Optional<Integer>; nu există maxim al unei mulțimi goale. Pe IntStream, max() întoarce OptionalInt.

Diferența dintre Stream<Integer> și IntStream merită explicată:

  • Stream<Integer> lucrează cu obiecte, deci are boxing și metode generice (max(Comparator), reduce).
  • IntStream lucrează cu int, are metode numerice (sum, average, summaryStatistics, range) și întoarce OptionalInt/OptionalDouble.
  • Conversiile: mapToInt (de la obiecte la primitive), boxed() sau mapToObj (înapoi).

Când ai nevoie de mai multe statistici, una singură trece prin date:

JAVA
IntSummaryStatistics s = note.stream().mapToInt(Integer::intValue).summaryStatistics();
s.getMin(); s.getMax(); s.getAverage(); s.getCount(); s.getSum();

Pentru o secvență goală, getMin() întoarce Integer.MAX_VALUE, iar getMax() întoarce Integer.MIN_VALUE, deci verifici getCount() înainte.

Greșeala frecventă cu Optional: b.getAsDouble() pe o listă goală aruncă NoSuchElementException. Folosești orElse(0) sau tratezi explicit lipsa valorii, după ce înseamnă în business o medie inexistentă.

Ce urmărește intervievatorul: Verifică înțelegerea tipurilor returnate de operațiile terminale și motivul lor. Candidații presupun des că average() întoarce double.

68 Junior

Scrie o metodă care primește un text și întoarce cuvintele unice, sortate alfabetic, separate prin virgulă. Textul poate conține diacritice și semne de punctuație.

Răspuns scurt: Împarți textul după tot ce nu e literă sau cifră ([^\p{L}\p{N}]+), elimini șirurile goale, transformi în litere mici, apoi distinct(), sorted() și Collectors.joining(", "). Pentru ordine alfabetică corectă în română, folosești un Collator.

O soluție compactă cu Stream API:

JAVA
static String cuvinteUnice(String text) {
    return Arrays.stream(text.toLowerCase(Locale.ROOT).split("[^\\p{L}\\p{N}]+"))
            .filter(s -> !s.isEmpty())
            .distinct()
            .sorted()
            .collect(Collectors.joining(", "));
}
// "Ana are mere. Mere, pere și ana!" -> "ana, are, mere, pere, și"

De ce aceste alegeri:

  • \\p{L} înseamnă orice literă Unicode, deci „și” sau „țară” rămân întregi. Expresia \\W+ ar fi greșită aici: implicit, \W consideră „literă” doar [a-zA-Z0-9_], deci ar tăia cuvintele la diacritice.
  • filter(s -> !s.isEmpty()) elimină primul element gol care apare când textul începe cu punctuație.
  • toLowerCase(Locale.ROOT) evită surprize de localizare (în turcă, de exemplu, I mic nu devine i).
  • distinct() păstrează prima apariție, iar sorted() sortează după ordinea naturală a lui String.

Ordinea naturală compară codurile UTF-16, deci „ș” (U+0219) ajunge după „z”. Pentru ordine alfabetică românească:

JAVA
Collator ro = Collator.getInstance(Locale.forLanguageTag("ro"));
... .sorted(ro) ...

Collator implementează Comparator<Object>, deci se poate da direct lui sorted. Collectors.joining are și varianta cu prefix și sufix: joining(", ", "[", "]"). Dacă textul e foarte mare, TreeSet cu Collator evită stocarea duplicatelor înainte de sortare, iar un Pattern compilat o singură dată evită recompilarea regex-ului.

Ce urmărește intervievatorul: Verifică folosirea fluentă a stream-urilor pe un caz realist și atenția la Unicode. Greșeala tipică este \\W+, care strică textul cu diacritice.

69 Junior

Scrie cu Stream API o metodă care întoarce frecvența fiecărei litere dintr-un text, cu literele ordonate alfabetic.

Răspuns scurt: text.chars() dă un IntStream de caractere; filtrezi literele, le transformi în Character cu mapToObj, apoi grupezi cu Collectors.groupingBy(Function.identity(), TreeMap::new, Collectors.counting()). Rezultatul este un Map<Character, Long> sortat.

JAVA
static Map<Character, Long> frecventaLitere(String text) {
    return text.toLowerCase().chars()
            .filter(Character::isLetter)
            .mapToObj(c -> (char) c)
            .collect(Collectors.groupingBy(
                    Function.identity(),
                    TreeMap::new,
                    Collectors.counting()));
}
// "Abc ab!" -> {a=2, b=2, c=1}

Pas cu pas:

  • chars() întoarce un IntStream, nu un Stream<Character>: fiecare element este codul char ca int.
  • Character.isLetter(int) acceptă direct codul, deci referința de metodă se potrivește cu IntPredicate.
  • mapToObj(c -> (char) c) face cast la char, iar rezultatul este împachetat automat în Character. Fără cast, ai obține un Map<Integer, Long>, cu chei numerice.
  • groupingBy cu trei argumente: funcția de clasificare, fabrica de map (aici TreeMap::new, pentru ordine sortată) și colectorul din aval (downstream), counting(), care întoarce Long.

Dacă preferi Integer ca valoare, folosești Collectors.summingInt(c -> 1) sau, după grupare, alt pas de transformare.

Comparație cu varianta imperativă:

JAVA
int[] f = new int[26];
for (char c : text.toLowerCase().toCharArray())
    if (c >= 'a' && c <= 'z') f[c - 'a']++;

Tabloul este mai rapid, dar acceptă doar literele de bază. Varianta cu stream funcționează și cu diacritice și e mai ușor de adaptat. Ca observație despre chars(): pentru caractere din afara planului de bază Unicode, codePoints() este alegerea corectă, cu Character.toChars sau Character.toString(int) (Java 11) pentru conversie.

Ce urmărește intervievatorul: Verifică stăpânirea chars(), a conversiilor între stream-uri primitive și de obiecte și a variantei cu trei argumente a lui groupingBy. Mulți obțin chei Integer fără să-și dea seama.

70 Junior

Care este diferența dintre findFirst() și findAny()? Ce sunt operațiile de scurtcircuitare și ce afișează codul de mai jos?

JAVA
Stream.iterate(1, x -> x + 1)
      .peek(x -> System.out.print(x + " "))
      .filter(x -> x % 3 == 0)
      .findFirst()
      .ifPresent(x -> System.out.println("-> " + x));

Răspuns scurt: Afișează 1 2 3 -> 3. findFirst întoarce primul element în ordinea de întâlnire, findAny orice element, ceea ce contează doar la stream-uri paralele. Operațiile de scurtcircuitare (findFirst, anyMatch, limit) se opresc fără să parcurgă tot stream-ul, deci funcționează și pe stream-uri infinite.

Stream-urile sunt evaluate leneș și element cu element: fiecare element trece prin tot pipeline-ul înainte să înceapă următorul (nu se aplică întâi peek pe tot, apoi filter pe tot). De aceea în exemplu:

  • 1 trece prin peek (afișat), nu trece de filter;
  • 2 la fel;
  • 3 trece prin peek și filter, iar findFirst îl primește și oprește procesarea.

Stream.iterate(1, x -> x + 1) este infinit, dar findFirst este o operație terminală de scurtcircuitare, deci programul se termină. Alte operații de acest fel: findAny, anyMatch, allMatch, noneMatch (terminale) și limit, takeWhile (intermediare). Fără ele, un stream infinit cu count() sau toList() nu s-ar termina niciodată.

findFirst versus findAny:

  • pe un stream secvențial, ambele întorc în practică primul element;
  • pe un stream paralel, findFirst trebuie să respecte ordinea de întâlnire, ceea ce cere coordonare între thread-uri; findAny poate întoarce primul element găsit de orice thread și este mai rapid;
  • folosești findAny când oricare element care respectă condiția e bun, de exemplu „există vreun produs fără stoc?”.

allMatch pe un stream gol întoarce true (adevăr vid), iar anyMatch întoarce false, un detaliu care poate produce buguri de validare.

peek este gândit pentru depanare. Nu îl folosi pentru logică: unele operații (de exemplu count() pe o sursă cu dimensiune cunoscută, din Java 9) pot sări complet peste pipeline, iar peek nu mai rulează.

Ce urmărește intervievatorul: Verifică înțelegerea evaluării leneșe element cu element și a scurtcircuitării. Candidații care cred că stream-ul procesează „etapă cu etapă” greșesc rezultatul.

71 Mid

Care este diferența dintre stream.toList() (Java 16), collect(Collectors.toList()) și collect(Collectors.toUnmodifiableList())? Ce se întâmplă la rularea codului?

JAVA
List<String> a = Stream.of("x", "y").toList();
List<String> b = Stream.of("x", "y").collect(Collectors.toList());
b.add("z");
a.add("z");

Răspuns scurt: toList() întoarce o listă nemodificabilă care acceptă null. Collectors.toList() nu garantează tipul, dar în practică întoarce un ArrayList mutabil. toUnmodifiableList() (Java 10) e nemodificabilă și respinge null. Codul adaugă în b, apoi a.add aruncă UnsupportedOperationException.

Trei variante cu garanții diferite:

  • Collectors.toList() (Java 8): documentația spune explicit că nu există garanții despre tip, mutabilitate sau thread-safety. Implementarea actuală întoarce un ArrayList, iar mult cod existent se bazează, implicit, pe faptul că lista se poate modifica.
  • Collectors.toUnmodifiableList() (Java 10): listă nemodificabilă, aruncă NullPointerException dacă stream-ul conține null.
  • Stream.toList() (Java 16): listă nemodificabilă, mai scurtă de scris și ușor mai eficientă, dar, spre deosebire de toUnmodifiableList, acceptă null.

Pentru o listă pe care vrei să o modifici ulterior, intenția se exprimă explicit:

JAVA
List<String> mutabila = stream.collect(Collectors.toCollection(ArrayList::new));

De ce contează la migrare: înlocuirea automată a lui collect(Collectors.toList()) cu toList(), sugerată de unele IDE-uri, poate strica un cod care adaugă apoi elemente în listă. Excepția apare doar la rulare, pe drumul de cod care modifică lista, deci uneori abia în producție.

Recomandarea generală: întoarce din metode colecții nemodificabile, ca apelanții să nu poată schimba starea internă a obiectului, și creează explicit o copie mutabilă acolo unde chiar ai nevoie. Aceeași distincție există și la seturi (toSet, toUnmodifiableSet) și map-uri (toMap, toUnmodifiableMap). Din Java 10, List.copyOf, Set.copyOf și Map.copyOf creează copii nemodificabile din colecții existente.

Ce urmărește intervievatorul: Verifică atenția la detaliile de versiune și la contractele API-urilor. Diferența de comportament la null și mutabilitate produce buguri reale la migrare.

Eroarea, în practică:UnsupportedOperationException (List.of)Stream<String> cannot be converted to List<String>

72 Mid

Ce afișează codul de mai jos? Când folosești orElse și când orElseGet?

JAVA
static String numeImplicit() {
    System.out.println("calculez implicit");
    return "Anonim";
}
String a = Optional.of("Ana").orElse(numeImplicit());
String b = Optional.of("Ana").orElseGet(() -> numeImplicit());
System.out.println(a + " " + b);

Răspuns scurt: Afișează „calculez implicit” o singură dată, apoi Ana Ana. Argumentul lui orElse se evaluează întotdeauna, înainte de apel, chiar dacă valoarea există. orElseGet primește un Supplier și îl apelează doar când Optional este gol.

Diferența ține de evaluarea argumentelor în Java: argumentele unei metode se calculează înainte de apel. La orElse(numeImplicit()), metoda numeImplicit() rulează mereu, iar rezultatul ei e aruncat dacă Optional are valoare. La orElseGet(() -> numeImplicit()), se transmite doar o funcție, apelată la nevoie.

Când contează:

  • dacă valoarea implicită e o constantă sau un obiect deja existent (orElse(""), orElse(Collections.emptyList())), orElse e perfect și mai lizibil;
  • dacă valoarea implicită implică un calcul, o interogare în baza de date, un apel HTTP sau creare de obiecte costisitoare, folosești orElseGet;
  • dacă valoarea implicită are efecte secundare (salvează o entitate nouă, incrementează un contor), orElse produce un bug real:
JAVA
Client c = repo.gasesteDupaEmail(email)
        .orElse(repo.salveaza(new Client(email)));   // salvează mereu
Client corect = repo.gasesteDupaEmail(email)
        .orElseGet(() -> repo.salveaza(new Client(email)));

Alte metode utile ale lui Optional:

  • orElseThrow() (Java 10) sau orElseThrow(() -> new NotFoundException(id));
  • map, flatMap și filter pentru transformări fără if;
  • ifPresentOrElse (Java 9) pentru două ramuri;
  • or(() -> altOptional) (Java 9) pentru o sursă alternativă;
  • stream() (Java 9), util în flatMap pentru a elimina valorile lipsă.

Optional.get() fără verificare reintroduce problema pe care Optional trebuia să o rezolve; de aceea orElseThrow() este preferat ca nume explicit.

Ce urmărește intervievatorul: Verifică înțelegerea evaluării argumentelor și a impactului ei practic. Bugul cu orElse care salvează în baza de date apare frecvent în aplicații Spring.

Eroarea, în practică:NoSuchElementException: No value presentOptional<String> cannot be converted to String

73 Mid

Ce afișează codul de mai jos? Care sunt diferențele dintre un lambda și o clasă anonimă, în afară de sintaxă?

JAVA
public class Exemplu {
    @Override public String toString() { return "Exemplu"; }
    void ruleaza() {
        Runnable lambda = () -> System.out.println(this);
        Runnable anonima = new Runnable() {
            @Override public void run() { System.out.println(this); }
            @Override public String toString() { return "Anonima"; }
        };
        lambda.run();
        anonima.run();
    }
}

Răspuns scurt: Afișează Exemplu, apoi Anonima. În lambda, this înseamnă obiectul care conține metoda; în clasa anonimă, this este instanța clasei anonime. Lambda-urile nu creează un nou domeniu de nume, nu au stare proprie și se implementează prin invokedynamic, nu prin fișiere .class separate.

Diferențele importante:

  • this și domeniul de nume: un lambda nu introduce un nou nivel de vizibilitate. this și super se referă la clasa înconjurătoare, iar un parametru al lambda-ului nu poate avea același nume ca o variabilă locală din metodă (eroare de compilare). Clasa anonimă este o clasă nouă, cu propriul this și cu posibilitatea de a ascunde (shadow) variabile.
  • Ce pot implementa: un lambda poate implementa doar o interfață funcțională (o singură metodă abstractă). O clasă anonimă poate extinde o clasă abstractă sau concretă, poate implementa interfețe cu mai multe metode și poate avea câmpuri și stare proprie.
  • Implementarea: compilatorul generează pentru clasa anonimă un fișier separat (Exemplu$1.class). Pentru un lambda, corpul devine o metodă privată în clasa curentă, iar în locul creării apare o instrucțiune invokedynamic. La primul apel, LambdaMetafactory generează la rulare implementarea interfeței. Asta reduce numărul de clase încărcate și permite optimizări ale JVM-ului.
  • Identitate: fiecare new al unei clase anonime creează un obiect nou. Pentru un lambda care nu capturează nimic, JVM-ul poate refolosi aceeași instanță, dar acesta este un detaliu de implementare, pe care nu trebuie să te bazezi (nu compara lambda-uri cu ==).
  • Captura lui this: o clasă anonimă dintr-o metodă de instanță ține mereu o referință spre obiectul exterior; un lambda doar dacă folosește membrii acestuia. Contează la memory leak-uri cu listener-e înregistrate.

În cod modern, lambda-ul este alegerea implicită pentru interfețe funcționale; clasa anonimă rămâne pentru cazurile cu stare sau cu mai multe metode.

Ce urmărește intervievatorul: Verifică înțelegerea semantică a lambda-urilor, nu doar sintaxa lor. Diferența la this este cea pe care o greșesc cei mai mulți candidați.

74 Mid

La code review primești un stream de 15 linii, cu map-uri imbricate, lambda-uri de câte 6 linii și un collect complicat la final. Funcționează și are teste. Cum procedezi?

Răspuns scurt: Înțeleg întâi intenția și verific testele, apoi propun concret: extragerea lambda-urilor lungi în metode cu nume, variabile intermediare pentru pașii logici, colectori dedicați în loc de reduce manual. Explic motivul (lizibilitate, depanare) și accept și varianta cu buclă dacă e mai clară.

Un model de răspuns structurat:

1. Înțeleg ce face codul. Citesc testele, rulez codul local dacă e nevoie și formulez într-o propoziție intenția: „grupează comenzile plătite pe client și calculează totalul pe lună”. Dacă nu reușesc să o formulez ușor, asta e deja feedback util.

2. Separ problemele de corectitudine de cele de stil. Verific întâi lucrurile care pot produce buguri: efecte secundare în map sau peek, Collectors.toMap fără funcție de îmbinare (aruncă IllegalStateException la chei duplicate), Optional.get() fără verificare, comparații de double pentru bani. Acestea sunt cereri de schimbare; restul sunt sugestii.

3. Fac sugestii concrete, nu „e greu de citit”.

JAVA
Map<Long, BigDecimal> totalPeClient = comenzi.stream()
        .filter(Comanda::estePlatita)
        .collect(Collectors.groupingBy(Comanda::clientId,
                Collectors.reducing(BigDecimal.ZERO, Comanda::total, BigDecimal::add)));
  • lambda-urile de mai multe linii devin metode private cu nume de domeniu, folosite prin referință de metodă;
  • un pipeline lung se poate împărți în doi pași cu o variabilă intermediară, cu nume clar;
  • uneori o buclă for simplă este mai lizibilă, și e în regulă să o propui.

4. Ton și context. Formulez întrebări („ce zici dacă extragem...?”), explic motivul (depanare mai ușoară, stack trace-uri mai clare) și, dacă echipa nu are încă o convenție, propun una pentru toată lumea, nu doar pentru acest PR. Dacă discuția se lungește în comentarii, o continui într-un apel scurt.

Ce urmărește intervievatorul: Intervievatorul verifică judecata tehnică și modul de colaborare. Răspunsurile slabe sunt fie „îl rescriu eu”, fie un comentariu vag fără propunere concretă.

75 Senior

Ce problemă au aceste reduceri, mai ales pe un stream paralel? Ce condiții trebuie să respecte argumentele lui reduce?

JAVA
int a = IntStream.rangeClosed(1, 4).parallel().reduce(0, (x, y) -> x - y);
int b = IntStream.rangeClosed(1, 4).parallel().reduce(10, Integer::sum);

Răspuns scurt: Scăderea nu este asociativă, deci rezultatul paralel depinde de cum se împart datele. La a doua, 10 nu este element neutru pentru adunare și se adaugă o dată pentru fiecare bucată. Identitatea trebuie să fie neutră, iar acumulatorul și combinatorul asociative și fără efecte secundare.

reduce(identitate, acumulator) combină elementele două câte două. Pe un stream secvențial, calculul este ((((0 - 1) - 2) - 3) - 4) = -10, iar a doua expresie dă 10 + 1 + 2 + 3 + 4 = 20. Pe un stream paralel, datele se împart în bucăți, fiecare bucată se reduce separat pornind de la identitate, apoi rezultatele parțiale se combină.

Contractul cerut de documentație:

  • identitatea trebuie să fie element neutru: acumulator(identitate, x) == x. 0 pentru adunare, 1 pentru înmulțire, "" pentru concatenare. Valoarea 10 se adaugă o dată pentru fiecare bucată, deci rezultatul paralel crește cu 10 de fiecare dată când datele sunt împărțite.
  • acumulatorul trebuie să fie asociativ: (a op b) op c == a op (b op c). Scăderea nu este, deci (1 - 2) - (3 - 4) diferă de ((1 - 2) - 3) - 4.
  • funcțiile nu trebuie să aibă efecte secundare și nu trebuie să depindă de stare externă.

Rezultatul greșit poate apărea doar pe anumite mașini sau la anumite dimensiuni, deci testele unitare secvențiale nu îl prind.

Varianta cu trei argumente, reduce(identitate, acumulator, combinator), se folosește când tipul rezultatului diferă de tipul elementelor:

JAVA
int lungimeTotala = cuvinte.parallelStream()
        .reduce(0, (suma, c) -> suma + c.length(), Integer::sum);

Combinatorul trebuie să fie compatibil cu acumulatorul. În practică, pentru majoritatea cazurilor există operații dedicate (sum, count, max, Collectors.summingInt, joining), mai clare și mai greu de folosit greșit. Pentru acumularea în structuri mutabile (liste, map-uri), se folosește collect, nu reduce, pentru că reduce presupune valori imuabile.

Ce urmărește intervievatorul: Verifică înțelegerea contractului matematic din spatele reduce și a paralelizării. Este o întrebare care separă candidații care folosesc API-ul de cei care îl înțeleg.

76 Senior

Un coleg afirmă că stream-urile sunt întotdeauna mai lente decât buclele, iar altul vrea să pună parallelStream() peste tot pentru performanță. Cum argumentezi și cum verifici?

Răspuns scurt: Niciuna nu e adevărată în general. Stream-urile au un cost mic, vizibil la colecții mici sau cu boxing. parallelStream ajută doar la volume mari de muncă CPU, pe surse ușor divizibile, fără blocări. Decizia se ia măsurând cu JMH.

Argumentele tehnice:

Stream secvențial versus buclă. Un pipeline creează câteva obiecte și apeluri prin interfețe funcționale. Pentru colecții mici, în bucle foarte fierbinți, costul acesta poate conta. Cel mai mare cost evitabil vine însă din boxing (Stream<Integer> în loc de IntStream). Pentru majoritatea codului de business, unde timpul se duce pe I/O și pe baza de date, diferența e neglijabilă, iar lizibilitatea contează mai mult.

Stream paralel. Folosește implicit ForkJoinPool.commonPool(), cu un număr de thread-uri legat de numărul de procesoare, comun întregii aplicații. Ajută când:

  • volumul de lucru e mare (mult CPU per element sau foarte multe elemente);
  • sursa se împarte ușor: ArrayList, tablouri, IntStream.range; o LinkedList sau Stream.iterate se împart prost;
  • operațiile sunt fără stare și fără efecte secundare;
  • nu există operații de ordonare costisitoare (sorted, findFirst, limit pe stream ordonat).

Strică atunci când lambda-urile fac I/O sau apeluri blocante (blochează pool-ul comun pentru toată aplicația), când volumul e mic (costul de coordonare domină) sau într-un server web, unde thread-urile sunt deja ocupate cu alte cereri.

Verificarea. Măsurătorile cu System.currentTimeMillis() în main sunt nesigure din cauza încălzirii JIT-ului și a eliminării codului mort. Folosesc JMH (Java Microbenchmark Harness):

JAVA
@Benchmark
public long sumaStream(Stare s) {
    return s.numere.stream().mapToLong(Integer::longValue).sum();
}

Apoi confirm cu un profiler pe aplicația reală că acea porțiune contează în timpul total. Concluzia de echipă: lizibilitatea implicit, optimizări doar unde măsurătorile arată nevoia.

Ce urmărește intervievatorul: Verifică maturitatea tehnică: cunoașterea mecanismelor și obiceiul de a măsura înainte de a optimiza. Răspunsurile dogmatice, în orice direcție, sunt semnal negativ.

Concurență

77 Mid

Prin ce stări trece un thread în Java? Care este diferența dintre Thread.sleep() și Object.wait()?

Răspuns scurt: Stările din Thread.State sunt NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING și TERMINATED. sleep pune thread-ul în pauză păstrând lock-urile; wait se apelează doar în interiorul unui bloc synchronized, eliberează monitorul și așteaptă un notify.

Stările, așa cum le vezi într-un thread dump:

  • NEW: obiectul Thread a fost creat, dar start() nu a fost apelat.
  • RUNNABLE: rulează sau e gata să ruleze. Include și thread-urile blocate în I/O nativ, ceea ce poate induce în eroare la analiza unui dump.
  • BLOCKED: așteaptă să intre într-un bloc synchronized al cărui monitor e ținut de alt thread.
  • WAITING: așteaptă fără limită de timp: wait(), join(), LockSupport.park().
  • TIMED_WAITING: așteptare cu limită: sleep(ms), wait(ms), join(ms).
  • TERMINATED: metoda run() s-a terminat.

Diferențele dintre sleep și wait:

  • Thread.sleep este metodă statică, se poate apela oriunde și nu eliberează monitoarele ținute. Dacă dormi în interiorul unui synchronized, celelalte thread-uri rămân blocate.
  • obiect.wait() trebuie apelat ținând monitorul acelui obiect, altfel aruncă IllegalMonitorStateException. Eliberează monitorul și îl reia înainte de a se întoarce.
  • wait se folosește pentru coordonare pe o condiție, iar trezirea vine prin notify/notifyAll sau fără motiv (spurious wakeup), deci se pune întotdeauna într-o buclă:
JAVA
synchronized (coada) {
    while (coada.isEmpty()) {
        coada.wait();
    }
    return coada.remove();
}

Ambele aruncă InterruptedException când thread-ul e întrerupt. Corect este fie să o propagi, fie să restaurezi flag-ul cu Thread.currentThread().interrupt(), nu să o înghiți. În cod modern, wait/notify se folosesc rar direct; BlockingQueue, CountDownLatch sau Condition din java.util.concurrent.locks exprimă aceeași coordonare mai sigur.

Ce urmărește intervievatorul: Verifică înțelegerea mecanismelor de bază de coordonare și citirea unui thread dump. Greșeala tipică: sleep într-un bloc sincronizat sau wait fără buclă.

Eroarea, în practică:IllegalMonitorStateException: not owner

78 Mid

Implementează un model producător–consumator: un thread citește comenzi și le pune într-o coadă, iar alte două thread-uri le procesează. Cum oprești curat consumatorii?

Răspuns scurt: Folosești o BlockingQueue mărginită (de exemplu ArrayBlockingQueue): producătorul apelează put, care așteaptă când coada e plină, iar consumatorii take, care așteaptă când e goală. Pentru oprire, producătorul pune câte un element special („poison pill”) pentru fiecare consumator sau folosești întreruperea thread-urilor.

BlockingQueue rezolvă sincronizarea și așteptarea, deci nu ai nevoie de wait/notify:

JAVA
record Comanda(long id) { }
static final Comanda STOP = new Comanda(-1);

BlockingQueue<Comanda> coada = new ArrayBlockingQueue<>(100);
ExecutorService pool = Executors.newFixedThreadPool(3);

pool.submit(() -> {                       // producător
    for (long id = 1; id <= 1000; id++) coada.put(new Comanda(id));
    coada.put(STOP);
    coada.put(STOP);                      // câte unul pentru fiecare consumator
    return null;
});
for (int i = 0; i < 2; i++) {
    pool.submit(() -> {                   // consumator
        while (true) {
            Comanda c = coada.take();
            if (c == STOP) break;
            proceseaza(c);
        }
        return null;
    });
}
pool.shutdown();
pool.awaitTermination(1, TimeUnit.MINUTES);

Lambda-urile întorc null, deci devin Callable și pot arunca InterruptedException din put și take.

Decizii importante:

  • Coadă mărginită: o coadă nelimitată (LinkedBlockingQueue fără capacitate) ascunde problema unui consumator mai lent decât producătorul, până la OutOfMemoryError. Cu limită, put încetinește producătorul, mecanism numit backpressure.
  • Oprirea: poison pill-ul este simplu și garantează că se procesează tot ce era în coadă. Alternativa este shutdownNow(), care întrerupe thread-urile; take() aruncă atunci InterruptedException, iar elementele rămase se pierd dacă nu le golești explicit.
  • Excepții: o excepție din proceseaza oprește consumatorul. Fie o prinzi în buclă și loghezi, fie verifici Future-urile întoarse de submit.
  • Alte variante: offer(e, timeout, unit) și poll(timeout, unit) pentru așteptare limitată, PriorityBlockingQueue pentru priorități.

În sisteme distribuite, același model apare cu un broker de mesaje (Kafka, RabbitMQ) în locul cozii din memorie.

Ce urmărește intervievatorul: Verifică dacă știi să folosești uneltele din java.util.concurrent pentru un tipar clasic. Intervievatorul urmărește oprirea curată și alegerea unei cozi mărginite.

Eroarea, în practică:IllegalStateException: Queue full

79 Mid

Codul de mai jos folosește ConcurrentHashMap, deci ar trebui să fie thread-safe. Unde este race condition-ul și cum îl repari?

JAVA
private final Map<String, Integer> vizite = new ConcurrentHashMap<>();

void inregistreaza(String pagina) {
    Integer curent = vizite.get(pagina);
    if (curent == null) {
        vizite.put(pagina, 1);
    } else {
        vizite.put(pagina, curent + 1);
    }
}

Răspuns scurt: Fiecare operație în parte e thread-safe, dar secvența „citește, apoi scrie” nu e atomică: două thread-uri pot citi aceeași valoare și una dintre incrementări se pierde. Repari cu o operație atomică: vizite.merge(pagina, 1, Integer::sum);.

Tiparul se numește check-then-act (verifică apoi acționează) sau read-modify-write. O colecție concurentă garantează că un singur apel (get, put) nu îi strică structura internă, dar nu face atomică o succesiune de apeluri. Scenariul:

  • thread-ul A citește curent = 5;
  • thread-ul B citește tot curent = 5;
  • A scrie 6, apoi B scrie tot 6.

Au fost două vizite, dar contorul a crescut cu 1. La prima vizită, ambele thread-uri pot vedea null și ambele pun 1.

ConcurrentHashMap oferă operații compuse atomice per cheie:

JAVA
vizite.merge(pagina, 1, Integer::sum);
vizite.compute(pagina, (k, v) -> v == null ? 1 : v + 1);
vizite.computeIfAbsent(pagina, k -> incarcaDinBaza(k));
vizite.putIfAbsent(pagina, 0);

Pentru contoare foarte solicitate, varianta cu cea mai mică contenție este un LongAdder per cheie:

JAVA
private final Map<String, LongAdder> vizite = new ConcurrentHashMap<>();
vizite.computeIfAbsent(pagina, k -> new LongAdder()).increment();

Atenție la funcțiile din compute și computeIfAbsent: rulează în timp ce o parte a map-ului e blocată, deci trebuie să fie scurte și să nu modifice alte chei ale aceluiași map. Un apel lent la baza de date în computeIfAbsent poate bloca alte thread-uri care lucrează pe chei din același bin.

Aceeași greșeală apare cu Collections.synchronizedList: if (!lista.contains(x)) lista.add(x); nu este atomic decât într-un bloc synchronized (lista). Concluzia: thread-safety ține de operațiile compuse ale aplicației, nu doar de tipul colecției.

Ce urmărește intervievatorul: Verifică dacă înțelegi că o colecție thread-safe nu face automat corect codul care o folosește. Mulți candidați consideră problema rezolvată prin simpla alegere a ConcurrentHashMap.

80 Mid

Un serviciu ține un private static final SimpleDateFormat FORMAT și îl folosește din mai multe thread-uri. Din când în când apar date greșite sau NumberFormatException. De ce și cum repari?

Răspuns scurt: SimpleDateFormat are stare internă mutabilă (un Calendar) și nu este thread-safe, deci apelurile concurente se încurcă. Repari trecând la DateTimeFormatter din java.time, care este imuabil și thread-safe, sau, în cod vechi, cu câte o instanță per apel sau per thread.

SimpleDateFormat.parse și format folosesc un câmp intern Calendar, pe care îl setează și apoi îl citesc. Când două thread-uri lucrează simultan pe aceeași instanță, unul poate suprascrie valorile celuilalt la mijlocul operației. Rezultatul: date amestecate, valori imposibile sau excepții neașteptate, cum ar fi NumberFormatException sau ArrayIndexOutOfBoundsException, din interiorul JDK-ului. Problema apare doar sub încărcare, deci testele unitare nu o prind.

Soluția modernă:

JAVA
private static final DateTimeFormatter FORMAT =
        DateTimeFormatter.ofPattern("dd.MM.yyyy");

LocalDate data = LocalDate.parse("31.10.2026", FORMAT);
String text = data.format(FORMAT);

DateTimeFormatter este imuabil, deci poate fi partajat liber. Același lucru e valabil pentru LocalDate, Instant și celelalte tipuri din java.time.

Variante dacă nu poți migra imediat: o instanță nouă la fiecare apel (simplu, cost mic), ThreadLocal.withInitial(() -> new SimpleDateFormat(...)) (eficient, dar cu grijă la pool-uri de thread-uri) sau sincronizarea accesului (corectă, dar creează contenție).

Lecția generală: un obiect este sigur de partajat între thread-uri dacă este imuabil sau fără stare (stateless). Alte clase din JDK care nu sunt thread-safe și care apar des ca static: StringBuilder, ArrayList, HashMap, MessageDigest, Cipher, DecimalFormat. Clasele thread-safe sunt de obicei documentate ca atare în Javadoc. Un serviciu singleton (de exemplu un bean Spring) cu câmpuri mutabile are exact aceeași problemă.

Ce urmărește intervievatorul: Verifică legătura dintre stare mutabilă și siguranța la concurență, pe un bug real și frecvent. Candidații buni recunosc imediat SimpleDateFormat ca exemplu clasic.

81 Mid

Care este diferența dintre CountDownLatch și CyclicBarrier? Dă un exemplu de folosire pentru fiecare.

Răspuns scurt: CountDownLatch este de unică folosință: unul sau mai multe thread-uri așteaptă până când un contor ajunge la zero, iar contorul îl scad alte thread-uri. CyclicBarrier este reutilizabil: un număr fix de thread-uri se așteaptă reciproc la un punct comun, apoi continuă toate.

CountDownLatch pornește de la un număr N. Orice thread poate apela countDown(), iar thread-urile care apelează await() sunt blocate până când numărul ajunge la zero. Nu se poate reseta.

JAVA
CountDownLatch gata = new CountDownLatch(3);
for (String serviciu : List.of("cache", "db", "config")) {
    pool.submit(() -> {
        try {
            initializeaza(serviciu);
        } finally {
            gata.countDown();     // în finally, ca să nu blocheze la eroare
        }
    });
}
if (!gata.await(30, TimeUnit.SECONDS)) {
    throw new IllegalStateException("Inițializarea nu s-a terminat");
}

Utilizări: aștepți inițializarea mai multor componente, pornești simultan mai multe thread-uri într-un test (un latch de 1 ca „pistol de start”), aștepți terminarea unui set de sarcini.

CyclicBarrier este configurat pentru N participanți. Fiecare apelează await() și rămâne blocat până ajung toți N; atunci toți sunt eliberați, iar bariera se resetează pentru runda următoare. Opțional, o acțiune de barieră rulează o dată pe rundă, de exemplu combinarea rezultatelor parțiale.

JAVA
CyclicBarrier bariera = new CyclicBarrier(4, () -> combinaRezultate());
// fiecare din cele 4 thread-uri, la finalul unei etape:
bariera.await();

Utilizări: simulări sau calcule iterative pe etape, unde fiecare etapă începe după ce toți au terminat-o pe cea precedentă.

Diferențe cheie: la latch, cei care scad contorul nu așteaptă, iar cei care așteaptă nu scad; la barieră, aceleași thread-uri participă și așteaptă. Dacă un participant este întrerupt sau iese cu timeout, bariera devine „broken” și ceilalți primesc BrokenBarrierException. Pentru scenarii cu număr variabil de participanți există Phaser, iar pentru „așteaptă toate sarcinile” în cod modern e adesea mai simplu CompletableFuture.allOf sau invokeAll.

Ce urmărește intervievatorul: Verifică familiaritatea cu sincronizatoarele din java.util.concurrent. Greșeala frecventă: countDown() în afara lui finally, care blochează pentru totdeauna la o excepție.

82 Senior

De ce varianta de mai jos de Singleton (double-checked locking) este greșită fără volatile? Ce alternative mai simple există?

JAVA
public class Config {
    private static Config instanta;
    public static Config get() {
        if (instanta == null) {
            synchronized (Config.class) {
                if (instanta == null) {
                    instanta = new Config();
                }
            }
        }
        return instanta;
    }
}

Răspuns scurt: Fără volatile, scrierea referinței poate deveni vizibilă altui thread înainte ca obiectul să fie complet construit, din cauza reordonării permise de Java Memory Model. Primul if, executat fără lock, poate vedea un obiect parțial inițializat. Alternative: câmpul volatile, idiomul holder sau un enum.

instanta = new Config() nu este o singură operație: se alocă memoria, se rulează constructorul și se scrie referința în câmp. Java Memory Model permite compilatorului și procesorului să reordoneze aceste operații, cât timp thread-ul curent nu poate observa diferența. Un alt thread care execută primul if fără sincronizare nu are nicio relație happens-before cu thread-ul care a construit obiectul. Poate vedea referința nenulă înainte de scrierea câmpurilor din constructor și folosește un obiect cu câmpuri încă implicite.

Bugul este rar, depinde de arhitectura procesorului și de JIT, deci aproape imposibil de reprodus într-un test.

Reparația minimă, corectă din Java 5:

JAVA
private static volatile Config instanta;

Scrierea într-un câmp volatile stabilește happens-before cu orice citire ulterioară a lui, deci cine vede referința vede și obiectul complet construit.

Alternative mai simple și sigure:

JAVA
// idiomul holder: inițializare leneșă, fără sincronizare explicită
public class Config {
    private Config() { }
    private static class Holder {
        static final Config INSTANTA = new Config();
    }
    public static Config get() { return Holder.INSTANTA; }
}

// enum: sigur și la serializare și reflecție
public enum ConfigEnum { INSTANTA; }

Idiomul holder se bazează pe garanția JVM-ului că inițializarea unei clase se face o singură dată, thread-safe; clasa Holder se încarcă abia la primul apel get().

În practică, într-o aplicație cu Spring sau alt container de dependency injection, singletonii se obțin prin container, iar Singleton-ul static e de evitat, pentru că îngreunează testarea. Un câmp static final inițializat direct (eager) e suficient când construcția e ieftină.

Ce urmărește intervievatorul: Este o întrebare clasică despre memory model: verifică înțelegerea reordonării și a vizibilității. Candidații slabi spun că „synchronized rezolvă tot”, fără să observe citirea nesincronizată.

83 Senior

Ce este ThreadLocal și ce probleme apar când îl folosești într-o aplicație web cu pool de thread-uri? Ce alternative are Java 21?

Răspuns scurt: ThreadLocal dă fiecărui thread propria copie a unei valori. Într-un pool, thread-urile sunt refolosite, deci o valoare neștearsă ajunge la următoarea cerere și rămâne în memorie. Apelezi mereu remove() în finally; Java 21 aduce ScopedValue ca preview.

Un ThreadLocal<T> păstrează valorile într-un map atașat fiecărui obiect Thread. E folosit pentru context per cerere (utilizatorul curent, id-ul de corelare pentru loguri, tranzacția curentă) și pentru obiecte costisitoare, care nu sunt thread-safe, refolosite per thread. Spring, Hibernate și bibliotecile de logging (MDC) îl folosesc intern.

Problemele într-un server cu pool de thread-uri:

  • Scurgere de date între cereri: thread-ul care a servit cererea utilizatorului A servește apoi cererea lui B. Dacă contextul lui A nu a fost șters, codul lui B poate rula cu identitatea lui A, o problemă serioasă de securitate.
  • Memory leak: valoarea trăiește cât trăiește thread-ul, adică, într-un pool, cât aplicația. Pe serverele de aplicații cu redeploy, o valoare a cărei clasă vine din aplicație ține în memorie întregul class loader vechi, iar după câteva redeploy-uri apare OutOfMemoryError: Metaspace.
  • Thread-uri create de tine: valoarea nu se propagă automat în sarcinile trimise la un ExecutorService; InheritableThreadLocal copiază doar la crearea thread-ului, deci nu ajută la pool-uri.

Tiparul corect:

JAVA
private static final ThreadLocal<String> UTILIZATOR = new ThreadLocal<>();

void trateaza(Cerere c) {
    UTILIZATOR.set(c.utilizator());
    try {
        proceseaza(c);
    } finally {
        UTILIZATOR.remove();
    }
}

Virtual threads (Java 21) schimbă calculul: pot exista milioane, iar un ThreadLocal cu obiecte mari per thread consumă multă memorie, iar cache-urile per thread nu mai au sens. ScopedValue (preview în Java 21, finalizat într-o versiune ulterioară) oferă o valoare imuabilă, legată de un bloc de cod, curățată automat la ieșire și moștenită de sub-sarcinile din structured concurrency:

JAVA
ScopedValue.where(UTILIZATOR_SV, "ana").run(() -> proceseaza());

Ce urmărește intervievatorul: Verifică experiența cu aplicații de server reale și riscurile de securitate și memorie. Lipsa lui remove() în finally este greșeala cea mai frecventă.

84 Senior

Ai migrat un serviciu la virtual threads (Java 21) și throughput-ul nu a crescut; uneori aplicația pare blocată. Ce cauze verifici?

Răspuns scurt: Verific pinning-ul (în Java 21, blocarea într-un synchronized ține ocupat thread-ul purtător), resursele limitate din aval, cum e pool-ul de conexiuni, munca CPU-bound, ThreadLocal-urile mari și pool-urile de virtual threads create din greșeală.

Virtual threads sunt thread-uri ușoare, gestionate de JVM, montate pe un număr mic de thread-uri de platformă numite carrier threads (implicit, cât numărul de procesoare). Când un virtual thread face o operație blocantă suportată (I/O de rețea, sleep, BlockingQueue.take, ReentrantLock), se demontează, iar carrier-ul preia alt virtual thread. Câștigul apare la aplicații cu multe sarcini care așteaptă I/O.

Ce verific, în ordine:

  • Pinning: în Java 21, blocarea în interiorul unui bloc synchronized sau a unui cadru nativ fixează virtual thread-ul pe carrier. Cu puține carrier-e, câteva astfel de blocări simultane pot opri tot. Diagnosticul: evenimentul JFR jdk.VirtualThreadPinned sau -Djdk.tracePinnedThreads=full în Java 21. Soluția, până la Java 24 (unde JEP 491 elimină pinning-ul pentru synchronized), este înlocuirea cu ReentrantLock în zonele care blochează, inclusiv actualizarea driverelor și bibliotecilor.
  • Resursele din aval: dacă pool-ul de conexiuni JDBC are 20 de conexiuni, 10.000 de virtual threads vor aștepta tot la cele 20. Virtual threads nu măresc capacitatea bazei de date. Limitarea explicită a concurenței se face cu un Semaphore, nu cu un pool de thread-uri.
  • Muncă CPU-bound: pentru calcule, virtual threads nu aduc nimic în plus.
  • Pool-uri de virtual threads: nu se pun în pool; se creează câte unul per sarcină cu Executors.newVirtualThreadPerTaskExecutor().
  • ThreadLocal-uri mari sau cache-uri per thread, care se multiplică cu numărul de thread-uri.
JAVA
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    cereri.forEach(c -> executor.submit(() -> proceseaza(c)));
}

Măsor înainte și după, cu aceeași încărcare, și analizez un thread dump cu jcmd <pid> Thread.dump_to_file, care include și virtual threads.

Ce urmărește intervievatorul: Verifică înțelegerea reală a modelului virtual threads, nu doar entuziasmul pentru ele. Intervievatorul urmărește pinning-ul și limitele din aval.

85 Senior

Ce probleme au Executors.newFixedThreadPool și Executors.newCachedThreadPool în producție? Cum dimensionezi și cum oprești corect un pool de thread-uri?

Răspuns scurt: newFixedThreadPool folosește o coadă nelimitată, deci sub încărcare sarcinile se acumulează până la OutOfMemoryError. newCachedThreadPool creează thread-uri fără limită. În producție construiești un ThreadPoolExecutor cu coadă mărginită și politică de respingere, dimensionat după tipul de muncă, și îl oprești cu shutdown plus awaitTermination.

Metodele din Executors sunt comode, dar ascund decizii importante:

  • newFixedThreadPool(n) are n thread-uri și o LinkedBlockingQueue nemărginită. Dacă sarcinile vin mai repede decât se procesează, coada crește fără limită, latența explodează și, în final, memoria se termină.
  • newCachedThreadPool() creează un thread nou ori de câte ori nu există unul liber, fără limită. Sub încărcare poate crea mii de thread-uri, fiecare cu stiva lui, până la OutOfMemoryError: unable to create native thread.

Varianta explicită:

JAVA
ThreadPoolExecutor pool = new ThreadPoolExecutor(
        8, 8,                                  // core și maxim
        60, TimeUnit.SECONDS,
        new ArrayBlockingQueue<>(500),         // coadă mărginită
        r -> new Thread(r, "rapoarte-worker"), // nume util în thread dump
        new ThreadPoolExecutor.CallerRunsPolicy());

CallerRunsPolicy execută sarcina în thread-ul apelantului când coada e plină, deci încetinește natural producătorul. Alternativa este AbortPolicy, care aruncă RejectedExecutionException, iar apelantul decide.

Dimensionare: pentru muncă CPU-bound, aproximativ numărul de procesoare (Runtime.getRuntime().availableProcessors(), care în containere ține cont de limitele de CPU în versiunile moderne). Pentru muncă cu mult I/O, mai multe thread-uri, estimate din raportul timp de așteptare / timp de calcul și validate prin măsurare, sau virtual threads în Java 21.

Oprirea corectă:

JAVA
pool.shutdown();                                   // nu mai acceptă sarcini noi
if (!pool.awaitTermination(30, TimeUnit.SECONDS)) {
    pool.shutdownNow();                            // întrerupe ce rulează
}

Din Java 19, ExecutorService implementează AutoCloseable, deci poate fi folosit în try-with-resources. Un pool neoprit, cu thread-uri non-daemon, împiedică oprirea JVM-ului, iar excepțiile din sarcinile trimise cu submit se pierd dacă nu citești Future-ul.

Ce urmărește intervievatorul: Verifică experiența de producție cu pool-uri de thread-uri și înțelegerea backpressure-ului. Răspunsul slab se oprește la „folosesc Executors.newFixedThreadPool”.

86 Senior

Un test de integrare pică din când în când, iar în producție apar rar comenzi cu totalul greșit. Suspectezi un race condition. Cum procedezi?

Răspuns scurt: Strâng date din loguri (thread, id de corelare, momente), caut starea mutabilă partajată pe drumul de cod afectat, reproduc cu un test de stres, repar prin eliminarea partajării sau operații atomice, apoi verific cu același test și adaug monitorizare.

Un răspuns structurat, pe etape:

1. Strâng date, nu ghicesc. Verific logurile pentru comenzile afectate: ce thread-uri le-au atins, în ce ordine, cât de aproape în timp. Dacă logurile nu includ numele thread-ului și un id de corelare, le adaug întâi. Notez tiparul: apare doar la vârfuri de trafic? Doar pentru comenzi modificate simultan?

2. Identific starea partajată. Pe drumul de cod al calculului totalului caut: câmpuri mutabile în servicii singleton, colecții nesincronizate (HashMap, ArrayList) folosite din mai multe thread-uri, obiecte care nu sunt thread-safe partajate static (SimpleDateFormat, DecimalFormat), secvențe check-then-act, cache-uri proprii. Un indiciu clasic: un câmp de instanță folosit ca variabilă temporară într-un bean.

3. Reproduc. Scriu un test care pornește multe thread-uri simultan, cu un CountDownLatch ca semnal de start, și repetă operația de mii de ori. Pentru clase mici, jcstress (din OpenJDK) e unealta specializată. La nivel de bază de date, verific dacă două tranzacții pot citi și scrie aceeași comandă (lost update) și dacă lipsește un lock optimist (@Version).

4. Repar la cauză.

  • elimin starea partajată: variabile locale, obiecte imuabile;
  • unde partajarea e necesară, operații atomice (ConcurrentHashMap.merge, AtomicLong) sau o secțiune critică clară;
  • în baza de date, blocare optimistă sau un UPDATE atomic.

5. Verific și previn. Testul de stres trebuie să treacă de multe ori la rând. Adaug o alertă sau o verificare de consistență a totalurilor în producție și discut la retrospectivă reguli de code review pentru cod concurent. Nu „repar” cu un Thread.sleep în test sau cu synchronized pus peste tot.

Ce urmărește intervievatorul: Intervievatorul verifică metoda de lucru pe o problemă grea și nedeterministă. Semnalele negative sunt reparațiile la întâmplare și lipsa reproducerii.

JVM, memorie și I/O

Exersează capitolul cu exerciții reale: Curs Java →
87 Junior

Ce se întâmplă, pas cu pas, când rulezi javac Main.java și apoi java Main? Ce înseamnă eroarea UnsupportedClassVersionError?

Răspuns scurt: javac compilează codul sursă în bytecode, în fișierul Main.class. java pornește JVM-ul, care încarcă clasa, verifică bytecode-ul și execută metoda main. UnsupportedClassVersionError apare când clasa a fost compilată pentru o versiune de Java mai nouă decât JVM-ul care o rulează.

Etapele:

  • Compilarea: javac verifică sintaxa și tipurile și produce câte un fișier .class pentru fiecare clasă (inclusiv clasele imbricate, de exemplu Main$Ajutor.class). Bytecode-ul este un set de instrucțiuni pentru JVM, independent de procesor. Îl poți inspecta cu javap -c Main.
  • Pornirea: java Main pornește JVM-ul și îi cere să încarce clasa Main din classpath (implicit, directorul curent). Argumentul este numele clasei, nu numele fișierului, deci java Main.class dă eroare.
  • Încărcarea și verificarea: class loader-ul citește fișierul, verifier-ul controlează că bytecode-ul este valid și sigur, apoi clasa este inițializată (rulează blocurile static).
  • Execuția: JVM-ul caută public static void main(String[] args). Codul este interpretat la început, iar porțiunile folosite des sunt compilate în cod nativ de JIT.

Din Java 11 poți rula direct un fișier sursă, fără javac explicit: java Main.java. Compilarea se face în memorie, util pentru scripturi și exerciții. Din Java 22 funcționează și cu programe din mai multe fișiere sursă.

Fiecare fișier .class conține o versiune de format: 61 pentru Java 17, 65 pentru Java 21. Un JVM mai vechi refuză clasele mai noi, cu mesajul „compiled by a more recent version of the Java Runtime (class file version 65.0), this version of the Java Runtime only recognizes class file versions up to 61.0”. Soluții: rulezi pe JDK-ul potrivit sau compilezi pentru versiunea țintă cu javac --release 17, care verifică și că nu folosești API-uri inexistente în acea versiune. În Maven, echivalentul este proprietatea maven.compiler.release.

Ce urmărește intervievatorul: Verifică înțelegerea lanțului de compilare și rulare, util la probleme de mediu. Greșeala tipică este confuzia între versiunea JDK-ului de compilare și cea de rulare.

Eroarea, în practică:Main method not found in class Main

88 Junior

De ce, în programul de mai jos, numele nu se mai citește după ce introduci vârsta?

JAVA
Scanner sc = new Scanner(System.in);
System.out.print("Vârsta: ");
int varsta = sc.nextInt();
System.out.print("Nume: ");
String nume = sc.nextLine();
System.out.println(nume + " are " + varsta + " ani");

Răspuns scurt: nextInt() citește doar cifrele și lasă în buffer caracterul de linie nouă (Enter). nextLine() citește apoi până la acel caracter, deci întoarce imediat un text gol. Soluția: un sc.nextLine() suplimentar după nextInt() sau citirea tuturor valorilor cu nextLine() și conversia lor.

Scanner împarte inputul în tokeni separați prin spații albe. Metode precum nextInt(), nextDouble() sau next() consumă doar tokenul, nu și separatorul de după el. Când utilizatorul scrie 30 și apasă Enter, în buffer există 30\n. nextInt() ia 30 și lasă \n. nextLine() are alt comportament: citește tot până la finalul liniei curente și consumă terminatorul. Linia curentă este goală, deci întoarce "" fără să mai aștepte input.

Două soluții:

JAVA
int varsta = sc.nextInt();
sc.nextLine();                       // consumă restul liniei
String nume = sc.nextLine();
JAVA
int varsta = Integer.parseInt(sc.nextLine().strip());
String nume = sc.nextLine();

A doua variantă e de obicei mai robustă: fiecare linie e citită complet, iar erorile de format apar ca NumberFormatException, pe care le poți trata. Cu nextInt(), un input ca „treizeci” aruncă InputMismatchException, iar tokenul invalid rămâne în buffer, deci o buclă de reîncercare fără sc.next() ar intra în ciclu infinit. Poți verifica înainte cu sc.hasNextInt().

Alte detalii: un Scanner peste System.in nu se închide în mijlocul programului, pentru că închide și System.in, iar citirile ulterioare eșuează. Pentru volume mari de input (probleme de algoritmică), Scanner este lent din cauza regex-urilor interne și se folosește BufferedReader cu readLine().

Ce urmărește intervievatorul: Este o problemă pe care o întâlnește aproape orice începător; intervievatorul verifică dacă înțelegi de ce se întâmplă. Bonus pentru cazul InputMismatchException în buclă.

89 Junior

Care sunt modurile moderne de a citi un fișier text în Java? Ce diferență este între Files.readAllLines, Files.lines și BufferedReader?

Răspuns scurt: Files.readString (Java 11) și Files.readAllLines încarcă tot fișierul în memorie, potrivite pentru fișiere mici. Files.lines întoarce un Stream<String> leneș, care trebuie închis cu try-with-resources. BufferedReader citește linie cu linie, cu control complet. Toate folosesc implicit UTF-8.

API-ul java.nio.file (Java 7, completat în Java 8 și 11) oferă variante pentru fiecare caz:

JAVA
Path cale = Path.of("comenzi.csv");

String tot = Files.readString(cale);                 // Java 11, tot textul
List<String> linii = Files.readAllLines(cale);       // listă de linii

try (Stream<String> s = Files.lines(cale)) {         // leneș, pentru fișiere mari
    long anulate = s.filter(l -> l.endsWith(",ANULATA")).count();
}

try (BufferedReader r = Files.newBufferedReader(cale)) {
    String linie;
    while ((linie = r.readLine()) != null) {
        proceseaza(linie);
    }
}

Criterii de alegere:

  • Dimensiunea: readString și readAllLines țin tot conținutul în memorie. Pentru un fișier de câțiva GB, asta înseamnă OutOfMemoryError. Files.lines și BufferedReader citesc progresiv.
  • Închiderea: Files.lines ține fișierul deschis până la închiderea stream-ului. Fără try-with-resources, descriptorul de fișier rămâne deschis, iar într-un server, după multe apeluri, apare „Too many open files”. Metodele readString și readAllLines închid singure fișierul.
  • Control: BufferedReader permite oprirea la mijloc, citirea pe bucăți și tratarea fină a erorilor.

Toate metodele din Files folosesc implicit UTF-8, independent de sistem. Pentru alt encoding, îl dai explicit: Files.readAllLines(cale, Charset.forName("windows-1250")). La un fișier cu alt encoding decât cel așteptat, poate apărea MalformedInputException.

Pentru scriere, echivalentele sunt Files.writeString, Files.write și Files.newBufferedWriter, cu opțiuni precum StandardOpenOption.APPEND. Clasa veche File rămâne în cod existent, dar Path și Files au un API mai bun și erori mai clare.

Ce urmărește intervievatorul: Verifică dacă folosești API-ul modern și te gândești la memorie și închiderea resurselor. Greșeala frecventă este Files.lines fără try-with-resources.

90 Mid

Care este diferența dintre StackOverflowError și diferitele tipuri de OutOfMemoryError? Ce opțiuni ale JVM-ului controlează fiecare zonă de memorie?

Răspuns scurt: StackOverflowError înseamnă că stiva unui thread s-a umplut (-Xss). OutOfMemoryError are mai multe variante, după zona epuizată: Java heap space (-Xmx), Metaspace (-XX:MaxMetaspaceSize), Direct buffer memory, unable to create native thread, GC overhead limit exceeded. Mesajul îți spune unde să cauți.

Memoria unui proces Java are mai multe zone, fiecare cu limita ei:

  • Stiva fiecărui thread: cadrele de apel cu variabile locale. Umplerea ei dă StackOverflowError, de obicei din recursivitate fără sfârșit sau foarte adâncă. Dimensiunea se setează cu -Xss (de exemplu -Xss1m).
  • Heap-ul: obiectele. OutOfMemoryError: Java heap space apare când, după colectare, nu e loc pentru o alocare nouă. Cauze: un leak sau un heap prea mic pentru volumul real. Limita: -Xmx; în containere se folosește des -XX:MaxRAMPercentage.
  • GC overhead limit exceeded: heap-ul nu e chiar plin, dar JVM-ul petrece aproape tot timpul colectând și recuperează foarte puțin (comportament specific Parallel GC). Practic, același diagnostic ca „heap space”.
  • Metaspace: metadatele claselor încărcate. OutOfMemoryError: Metaspace apare la leak-uri de class loader (redeploy repetat) sau la generare masivă de clase (proxy-uri dinamice). Limita: -XX:MaxMetaspaceSize.
  • Direct buffer memory: memorie din afara heap-ului, folosită de NIO și de biblioteci de rețea (Netty). Limita: -XX:MaxDirectMemorySize.
  • unable to create native thread: sistemul de operare refuză un thread nou din cauza limitei de procese sau a memoriei. Cauza tipică: thread-uri create fără limită, nu heap-ul mic. Mărirea lui -Xmx poate chiar agrava problema, pentru că lasă mai puțină memorie pentru stive.
  • Requested array size exceeds VM limit: încercare de a aloca un tablou mai mare decât permite JVM-ul.

Consecința practică: memoria totală a procesului depășește -Xmx, pentru că include metaspace, stivele, memoria directă și codul compilat de JIT, lucru important la limitele unui container.

Ce urmărește intervievatorul: Verifică dacă știi că există mai multe zone de memorie și că mesajul erorii indică direcția. Mulți răspund la orice OutOfMemoryError cu „măresc -Xmx”.

Eroarea, în practică:StackOverflowErrorOutOfMemoryError: Java heap space

91 Mid

O aplicație scrie un fișier CSV cu diacritice. Pe laptopul developerului arată corect, pe serverul Windows al clientului apar caractere stricate. Ce s-a schimbat în Java 18 legat de asta și cum scrii codul corect?

Răspuns scurt: Până la Java 17, multe API-uri foloseau encoding-ul implicit al sistemului (de exemplu windows-1250 sau windows-1252 pe Windows), iar din Java 18 (JEP 400) implicitul este UTF-8 peste tot. Codul corect nu depinde de implicit: specifici mereu StandardCharsets.UTF_8 la citire și scriere.

Textul din memorie (String) este Unicode. Encoding-ul (charset-ul) intervine doar la conversia în octeți și înapoi: la scrierea și citirea fișierelor, la rețea, la getBytes(). Dacă scrii cu un charset și citești cu altul, „ă” sau „ș” devin caractere fără sens.

Până la Java 17, clase precum FileReader, FileWriter, InputStreamReader fără charset, String.getBytes() și new String(bytes) foloseau charset-ul implicit al platformei, care depindea de sistemul de operare și de setările regionale. Pe Linux și macOS era de obicei UTF-8, pe Windows, o pagină de cod regională. Același program producea fișiere diferite pe mașini diferite.

JEP 400 (Java 18) a făcut UTF-8 implicitul pe toate platformele. Excepție: consola (System.out) folosește în continuare encoding-ul terminalului. Comportamentul vechi se poate reactiva cu -Dfile.encoding=COMPAT. Metodele din java.nio.file.Files foloseau deja UTF-8 implicit din Java 7.

Codul robust, indiferent de versiune:

JAVA
try (BufferedWriter w = Files.newBufferedWriter(Path.of("export.csv"),
        StandardCharsets.UTF_8)) {
    w.write("nume,oraș\n");
    w.write("Ana,Iași\n");
}
byte[] octeti = text.getBytes(StandardCharsets.UTF_8);
String inapoi = new String(octeti, StandardCharsets.UTF_8);

Din Java 11, FileReader și FileWriter au constructori cu Charset.

Un detaliu practic pentru CSV-uri deschise în Excel pe Windows: Excel recunoaște UTF-8 sigur doar dacă fișierul începe cu BOM (). Fără el, poate interpreta fișierul cu pagina de cod locală, chiar dacă Java a scris corect. Dacă fișierul e destinat Excel, scrii BOM-ul la început sau convii cu clientul alt format.

Ce urmărește intervievatorul: Verifică înțelegerea diferenței dintre text și octeți și cunoașterea unei schimbări importante de versiune. Codul care depinde de charset-ul implicit este o sursă clasică de buguri între medii.

Eroarea, în practică:MalformedInputException: Input length = 1UnsupportedCharsetException

92 Mid

Cum funcționează serializarea nativă Java (Serializable)? Ce rol au serialVersionUID și transient și de ce este considerată riscantă?

Răspuns scurt: Serializable este o interfață marker care permite ObjectOutputStream să transforme graful de obiecte în octeți. serialVersionUID identifică versiunea clasei, iar transient exclude un câmp. Deserializarea datelor nesigure poate executa cod (gadget chains), de aceea se preferă formate ca JSON și filtre ObjectInputFilter.

Mecanismul de bază:

JAVA
class Sesiune implements Serializable {
    private static final long serialVersionUID = 1L;
    private String utilizator;
    private transient String parola;      // nu se serializează
}
try (var out = new ObjectOutputStream(Files.newOutputStream(Path.of("s.bin")))) {
    out.writeObject(sesiune);
}

ObjectOutputStream scrie clasa, valorile câmpurilor și, recursiv, toate obiectele referite, care trebuie să fie și ele Serializable (altfel NotSerializableException). La deserializare, obiectul este reconstruit fără să ruleze constructorul clasei serializabile, deci validările din constructor sunt ocolite.

  • serialVersionUID: la citire, JVM-ul compară valoarea din flux cu cea a clasei curente. Dacă diferă, apare InvalidClassException. Dacă nu o declari, se calculează automat din structura clasei, deci orice modificare minoră (o metodă nouă) poate face datele vechi ilizibile. De aceea se declară explicit.
  • transient: câmpul e omis și primește la deserializare valoarea implicită (null, 0). Se folosește pentru date sensibile, cache-uri sau obiecte care nu au sens serializate (conexiuni, thread-uri). Câmpurile static nu se serializează oricum.

Riscul de securitate: ObjectInputStream.readObject poate instanția orice clasă serializabilă din classpath și apela metodele ei speciale (readObject, readResolve). Atacatorii combină clase din biblioteci populare în „gadget chains” care duc la execuție de cod la distanță. Au existat vulnerabilități serioase de acest tip în aplicații enterprise. Măsuri: nu deserializezi date din surse nesigure, folosești ObjectInputFilter (Java 9) cu o listă de clase permise și, în general, alegi formate de date (JSON cu Jackson, Protocol Buffers), care nu instanțiază clase arbitrare.

Records se deserializează prin constructorul canonic (Java 16), deci validările lor rulează.

Ce urmărește intervievatorul: Verifică înțelegerea mecanismului și conștientizarea riscurilor de securitate. Candidații care știu doar „implementezi Serializable” nu trec de nivelul de mid.

Eroarea, în practică:NotSerializableExceptionStreamCorruptedException: invalid stream header

93 Senior

Ce face compilatorul JIT? De ce o aplicație Java este mai lentă în primele minute după pornire și ce înseamnă asta pentru benchmark-uri și deploy-uri?

Răspuns scurt: JIT-ul (Just-In-Time) compilează la rulare metodele folosite des în cod nativ optimizat, pe baza profilului observat. La pornire codul e interpretat, apoi compilat treptat (C1, C2), deci performanța crește după încălzire. Benchmark-urile și deploy-urile trebuie să țină cont de asta.

HotSpot folosește compilare pe niveluri (tiered compilation, implicită din Java 8):

  • la început, bytecode-ul este interpretat, iar JVM-ul numără apelurile metodelor și iterațiile buclelor;
  • metodele care devin „fierbinți” sunt compilate rapid de C1, cu optimizări simple și cu instrumentare pentru colectarea profilului;
  • metodele foarte folosite sunt recompilate de C2, cu optimizări agresive bazate pe profilul observat.

Optimizările importante: inlining (corpul metodelor mici e copiat în apelant, ceea ce deblochează alte optimizări), escape analysis (obiectele care nu ies din metodă pot fi eliminate sau puse pe stivă), devirtualizarea apelurilor pentru care s-a observat o singură implementare, eliminarea verificărilor de limită în bucle.

Optimizările se bazează pe presupuneri. Dacă presupunerea devine falsă (se încarcă o nouă implementare a unei interfețe care fusese apelată monomorfic), JVM-ul face deoptimizare: aruncă codul compilat și revine la interpretare, apoi recompilează.

Consecințe practice:

  • Benchmark-uri: o măsurătoare cu System.nanoTime() în jurul unui singur apel măsoară interpretorul. JIT-ul poate și elimina codul al cărui rezultat nu e folosit. JMH rezolvă aceste probleme: iterații de încălzire, mai multe procese, Blackhole pentru rezultate.
  • Deploy-uri și autoscaling: o instanță nouă e mai lentă la primele cereri, iar latențele cresc imediat după deploy. Soluții: trafic de încălzire înainte de intrarea în load balancer, verificări de readiness care așteaptă încălzirea, Class Data Sharing (AppCDS) pentru încărcarea mai rapidă a claselor sau compilare AOT cu GraalVM Native Image, care are pornire foarte rapidă, dar alte compromisuri (reflecție configurată explicit, performanță de vârf diferită).

Pentru diagnostic: -XX:+PrintCompilation arată ce se compilează, iar JFR înregistrează evenimentele de compilare și deoptimizare.

Ce urmărește intervievatorul: Verifică înțelegerea modului în care JVM-ul obține performanța și implicațiile pentru măsurare și operare. Este un subiect care deosebește senior-ii de cei care doar scriu cod Java.

94 Senior

Care este diferența dintre referințele strong, soft, weak și phantom? Ce a înlocuit metoda finalize()?

Răspuns scurt: Strong împiedică colectarea. Soft e eliberată când memoria devine insuficientă, weak la primul GC după ce nu mai există referințe strong, iar phantom doar semnalează printr-o ReferenceQueue că obiectul e inaccesibil. finalize() e depreciată; o înlocuiesc try-with-resources și Cleaner (Java 9).

Garbage collector-ul colectează obiectele care nu mai sunt accesibile. Pachetul java.lang.ref permite niveluri intermediare de accesibilitate:

  • Strong: orice referință obișnuită (Client c = ...). Cât timp există un drum de referințe strong de la un GC root, obiectul rămâne în viață.
  • SoftReference: obiectul poate fi colectat, dar JVM-ul îl păstrează cât are memorie; toate referințele soft sunt garantat eliberate înainte de un OutOfMemoryError. Gândite pentru cache-uri sensibile la memorie, dar în practică dau comportament imprevizibil și presiune mare pe GC, așa că cache-urile moderne folosesc limite explicite de dimensiune.
  • WeakReference: obiectul este colectat la primul ciclu în care nu mai are referințe strong. Folosit pentru metadate asociate unor obiecte (WeakHashMap), listener-e care nu trebuie să țină în viață sursa și canonicalizare.
  • PhantomReference: get() întoarce mereu null. Folosită împreună cu o ReferenceQueue, semnalează că obiectul a devenit inaccesibil, ca să poți elibera resurse externe asociate.
JAVA
ReferenceQueue<Object> coada = new ReferenceQueue<>();
WeakReference<Object> ref = new WeakReference<>(obiect, coada);
// după colectare, ref.get() == null, iar ref apare în coadă

finalize() avea probleme serioase: rularea nu este garantată și nici momentul, încetinește colectarea, poate „reînvia” obiectul, rulează pe un thread intern, unde excepțiile sunt ignorate. A fost depreciată în Java 9 și marcată pentru eliminare în Java 18 (JEP 421).

Înlocuitorii:

  • pentru resurse cu ciclu de viață clar: AutoCloseable și try-with-resources, închidere explicită și deterministă;
  • ca plasă de siguranță pentru resurse native uitate: Cleaner (Java 9), construit pe referințe phantom; acțiunea de curățare nu trebuie să refere obiectul curățat, altfel acesta nu devine niciodată inaccesibil.

Ce urmărește intervievatorul: Verifică înțelegerea legăturii dintre accesibilitate și GC și cunoașterea evoluției API-ului. Folosirea finalize() în cod nou este un semnal negativ clar.

95 Senior

Un serviciu Java din producție consumă brusc 100% CPU și răspunde foarte greu, fără erori în loguri. Cum investighezi?

Răspuns scurt: Identific thread-urile care consumă CPU (top -H), le corelez cu un thread dump (jcmd <pid> Thread.print, după nid), verific dacă vinovatul e GC-ul (jstat -gcutil), apoi înregistrez un profil cu JFR sau async-profiler. Repar cauza și adaug monitorizare.

Un plan de investigație structurat:

1. Stabilizez și confirm. Dacă utilizatorii sunt afectați, scot instanța din load balancer sau adaug capacitate, dar păstrez procesul pornit pentru diagnostic. Verific că procesul Java consumă CPU-ul și corelez momentul cu deploy-uri, schimbări de configurare sau vârfuri de trafic.

2. Găsesc thread-urile fierbinți.

BASH
top -H -p <pid>                    # thread-urile cu cel mai mult CPU
printf '%x\n' <tid>                # id-ul thread-ului în hexazecimal
jcmd <pid> Thread.print > dump.txt # thread dump; caută nid=0x<hex>

Fac două sau trei dump-uri la câteva secunde distanță. Un thread care e în aceeași zonă de cod în toate e un suspect clar.

3. Exclud GC-ul. Dacă thread-urile fierbinți sunt ale garbage collector-ului, problema este memoria: jstat -gcutil <pid> 1000 arată un heap aproape plin și colectări continue. Atunci analiza continuă cu un heap dump, nu cu CPU-ul.

4. Profilez. jcmd <pid> JFR.start duration=60s filename=cpu.jfr înregistrează, cu impact mic, eșantioane de execuție, alocări și blocări, analizate apoi în JDK Mission Control. Async-profiler produce flame graph-uri foarte clare.

5. Cauze frecvente pe care le caut: buclă infinită dintr-o condiție de oprire greșită, o expresie regulată cu backtracking catastrofal pe un input neobișnuit, HashMap modificat concurent, buclă de reîncercare fără pauză (busy-wait), serializare JSON a unor obiecte uriașe, sortări repetate în bucle.

6. Repar și previn. Repar cauza, adaug un test cu inputul care a declanșat problema, configurez alerte pe CPU și pe timpul petrecut în GC și documentez pașii pentru echipă.

Ce urmărește intervievatorul: Verifică experiența practică cu uneltele JDK de diagnostic și o metodă ordonată. Răspunsul slab este „restartez și măresc resursele”.

Noutăți din Java 17 și 21

96 Junior

Ce afișează JVM-ul la rularea codului de mai jos în Java 17? Cum te ajută mesajul la depanare, comparativ cu Java 8?

JAVA
record Adresa(String oras) { }
record Client(String nume, Adresa adresa) { }

Client c = new Client("Ana", null);
System.out.println(c.adresa().oras().toUpperCase());

Răspuns scurt: Aruncă NullPointerException cu un mesaj precis: „Cannot invoke "Adresa.oras()" because the return value of "Client.adresa()" is null”. Din Java 14 (activ implicit din Java 15), mesajele „helpful NullPointerException” spun exact ce expresie a fost null. În Java 8, mesajul lipsea.

Pe o linie cu mai multe apeluri înlănțuite, un NullPointerException din Java 8 îți dădea doar numărul liniei. Nu știai dacă c, c.adresa() sau oras() era null, iar depanarea cerea adăugarea de loguri și reproducere.

Helpful NullPointerExceptions (JEP 358) a fost introdus în Java 14 și este activ implicit din Java 15. JVM-ul analizează bytecode-ul instrucțiunii care a eșuat și generează un mesaj care descrie:

  • ce operație a eșuat: apelul unei metode, citirea sau scrierea unui câmp, accesul într-un tablou, dezambalarea unui Integer, throw pe o valoare null;
  • ce expresie a fost null: o variabilă locală, un câmp, valoarea returnată de o metodă sau un element de tablou.

Exemple de mesaje:

Cannot invoke "String.length()" because "nume" is null
Cannot read field "pret" because "produs" is null
Cannot load from int array because "note" is null
Cannot invoke "java.lang.Integer.intValue()" because the return value of "java.util.Map.get(Object)" is null

Ultimul exemplu este frecvent: int x = map.get(cheie); pentru o cheie inexistentă. Mesajul arată că problema este dezambalarea automată, nu map-ul în sine.

Numele variabilelor locale apar doar dacă codul a fost compilat cu informații de depanare (javac -g, implicit în Maven și Gradle); altfel apar ca <local4>. Mesajul se calculează abia când este cerut, deci nu încetinește aplicația.

Ca practică, mesajul te duce rapid la expresia vinovată, dar întrebarea importantă rămâne de ce valoarea era null și unde ar fi trebuit validată: la crearea obiectului, cu Objects.requireNonNull, sau la marginea sistemului.

Ce urmărește intervievatorul: Verifică familiaritatea cu îmbunătățirile practice ale versiunilor recente. Este și o ocazie să arăți cum depanezi un NPE pe un lanț de apeluri.

Eroarea, în practică:NullPointerException: Cannot invoke ... is null

97 Mid

Ce face codul de mai jos în Java 21? Ce se întâmplă dacă adaugi un nou tip de formă sau dacă inversezi ordinea a două ramuri?

JAVA
sealed interface Forma permits Cerc, Dreptunghi, Triunghi { }
record Cerc(double raza) implements Forma { }
record Dreptunghi(double l, double h) implements Forma { }
record Triunghi(double baza, double inaltime) implements Forma { }

static String descrie(Forma f) {
    return switch (f) {
        case null -> "lipsă";
        case Cerc c when c.raza() > 10 -> "cerc mare";
        case Cerc c -> "cerc";
        case Dreptunghi d -> "dreptunghi " + d.l() + "x" + d.h();
        case Triunghi t -> "triunghi";
    };
}

Răspuns scurt: Este pattern matching pentru switch (Java 21): ramurile testează tipul, iar when adaugă o condiție. Cu Forma sealed, default nu e necesar. Un tip nou netratat dă eroare de compilare, la fel și case Cerc c pus înaintea ramurii cu when, pe care o domină.

Pattern matching for switch (JEP 441, Java 21) extinde switch de la constante (numere, String, enum) la tipuri:

  • case Cerc c testează dacă valoarea este Cerc și o leagă la variabila c;
  • when este o gardă (guard): ramura se alege doar dacă tipul se potrivește și condiția e adevărată;
  • case null tratează explicit null. Fără el, un switch pe o valoare null aruncă NullPointerException, ca până acum.

Exhaustivitatea: o expresie switch trebuie să acopere toate valorile posibile. Pentru că Forma este sealed și are exact trei implementări, compilatorul verifică faptul că toate trei sunt tratate. Dacă adaugi record Romb(...) implements Forma în permits, orice switch care nu tratează Romb nu mai compilează. Acesta este avantajul major față de un default sau față de if/instanceof: compilatorul îți arată toate locurile de actualizat.

Dominanța: ramurile se evaluează în ordine. Dacă case Cerc c -> ar sta înaintea lui case Cerc c when c.raza() > 10, a doua nu ar putea fi atinsă niciodată, iar compilatorul raportează „this case label is dominated by a preceding case label”. Regula e aceeași ca la ordinea blocurilor catch: de la specific la general.

Alte detalii: un switch cu săgeți nu are fall-through, iar o ramură cu bloc folosește yield pentru a întoarce valoarea. Pentru ierarhii care nu sunt sealed (de exemplu Object), ai nevoie de default sau de un caz total, cum ar fi case Object o. Combinația sealed + record + switch cu tipuri permite modelarea datelor și operațiilor separat, fără instanceof în cascadă.

Ce urmărește intervievatorul: Verifică stăpânirea Java modern și a garanțiilor oferite de compilator. Mulți candidați cunosc sintaxa, dar nu exhaustivitatea și dominanța.

Eroarea, în practică:switch expression does not cover all valuescase label is dominated by a preceding case label

98 Mid

Ce sunt record patterns (Java 21)? Rescrie metoda de mai jos folosindu-le.

JAVA
record Punct(int x, int y) { }
record Segment(Punct start, Punct sfarsit) { }

static int lungimeOrizontala(Object o) {
    if (o instanceof Segment) {
        Segment s = (Segment) o;
        if (s.start().y() == s.sfarsit().y()) {
            return Math.abs(s.sfarsit().x() - s.start().x());
        }
    }
    return -1;
}

Răspuns scurt: Record patterns (JEP 440, Java 21) descompun un record direct în componentele lui, inclusiv imbricat: o instanceof Segment(Punct(var x1, var y1), Punct(var x2, var y2)). Variabilele componentelor sunt disponibile imediat, fără accesori și fără cast.

Un record pattern potrivește tipul unui record și, în același timp, extrage componentele lui în variabile. Pattern-urile se pot imbrica, deci poți descompune într-o singură expresie o structură pe mai multe niveluri:

JAVA
static int lungimeOrizontala(Object o) {
    if (o instanceof Segment(Punct(var x1, var y1), Punct(var x2, var y2))
            && y1 == y2) {
        return Math.abs(x2 - x1);
    }
    return -1;
}

Aceleași pattern-uri funcționează în switch, unde se combină cu gărzi:

JAVA
static String clasifica(Object o) {
    return switch (o) {
        case Segment(Punct(var x1, var y1), Punct(var x2, var y2))
                when y1 == y2 -> "orizontal";
        case Segment(Punct(var x1, var y1), Punct(var x2, var y2))
                when x1 == x2 -> "vertical";
        case Segment s -> "oblic";
        default -> "nu e segment";
    };
}

Detalii:

  • Poți scrie tipul explicit (Punct(int x, int y)) sau var; tipul componentelor este deja cunoscut din declarația recordului.
  • Potrivirea apelează accesorii recordului, deci un accesor suprascris cu logică proprie este folosit și aici.
  • Un record pattern nu se potrivește niciodată cu null; un Segment cu start null nu se potrivește cu pattern-ul imbricat Punct(...), deci cazul cade pe ramura următoare.
  • Pentru recorduri generice, argumentele de tip se deduc: case Pereche(var a, var b).

Din Java 22, componentele care nu te interesează se pot înlocui cu _ (unnamed patterns, JEP 456), de exemplu Segment(Punct(var x1, _), _). În Java 21 trebuie să numești fiecare variabilă.

Unde ajută cu adevărat: procesarea de structuri de date imuabile, cum ar fi mesaje, evenimente, arbori de expresii sau rezultate ale validării.

Ce urmărește intervievatorul: Verifică dacă ești la curent cu Java 21 și înțelegi descompunerea structurală. Intervievatorul poate întreba și despre comportamentul cu null.

99 Mid

Ce sunt Sequenced Collections (Java 21)? Cum obțineai înainte primul și ultimul element dintr-o listă, dintr-un LinkedHashSet sau dintr-un Deque, și cum faci acum?

Răspuns scurt: Java 21 (JEP 431) a introdus interfețele SequencedCollection, SequencedSet și SequencedMap pentru colecțiile cu ordine definită. Ele oferă uniform getFirst(), getLast(), addFirst(), addLast(), removeFirst(), removeLast() și reversed(). Înainte, fiecare tip avea alt API.

Înainte de Java 21, colecțiile cu ordine definită nu aveau un tip comun, iar operațiile la capete arătau diferit:

JAVA
lista.get(0);                         lista.get(lista.size() - 1);
deque.getFirst();                     deque.getLast();
linkedHashSet.iterator().next();      // ultimul: parcurgere completă
sortedSet.first();                    sortedSet.last();

Pentru ultimul element dintr-un LinkedHashSet nu exista o metodă directă, iar pentru parcurgerea inversă a unei liste era nevoie de ListIterator sau de o copie inversată.

JEP 431 a adăugat în ierarhie:

  • SequencedCollection<E>: getFirst, getLast, addFirst, addLast, removeFirst, removeLast și reversed(). Implementată de List, Deque, LinkedHashSet, SortedSet.
  • SequencedSet<E>: o colecție secvențială fără duplicate.
  • SequencedMap<K, V>: firstEntry, lastEntry, pollFirstEntry, putFirst, putLast, sequencedKeySet() și reversed(). Implementată de LinkedHashMap și SortedMap.
JAVA
List<String> pasi = new ArrayList<>(List.of("a", "b", "c"));
pasi.getFirst();                          // "a"
pasi.getLast();                           // "c"
for (String p : pasi.reversed()) { }      // c, b, a, fără copie

LinkedHashMap<String, Integer> m = new LinkedHashMap<>();
m.putLast("x", 1);
m.firstEntry();

Detalii:

  • reversed() întoarce o vedere, nu o copie: modificările se văd în ambele sensuri.
  • Pe o colecție goală, getFirst() aruncă NoSuchElementException.
  • Pe colecții nemodificabile (List.of), metodele care modifică aruncă UnsupportedOperationException. La colecții sortate, addFirst și addLast aruncă tot UnsupportedOperationException, pentru că poziția e dată de ordinea de sortare.
  • HashSet și HashMap nu sunt secvențiale, pentru că nu au ordine definită.

Atenție la compatibilitate: dacă o clasă proprie care implementa List avea deja o metodă reversed() sau getFirst() cu alt tip returnat, poate să nu mai compileze după trecerea la Java 21.

Ce urmărește intervievatorul: Verifică dacă urmărești evoluția API-ului de colecții. O întrebare bună pentru a vedea cine a lucrat efectiv cu Java 21.

100 Senior

Echipa ta trebuie să migreze o aplicație mare de la Java 8 la Java 21. Cum planifici migrarea și ce probleme te aștepți să întâlnești?

Răspuns scurt: Fac inventarul dependențelor și al API-urilor interne folosite (jdeps), actualizez uneltele și bibliotecile, migrez în pași, cu teste și rulare în paralel, apoi adopt noutățile. Probleme tipice: modulele Java EE eliminate în Java 11, încapsularea strictă din Java 17, biblioteci vechi de bytecode.

Un plan structurat:

1. Inventar și riscuri. Listez dependențele și versiunile lor, plugin-urile Maven sau Gradle, agenții JVM (monitorizare, APM), opțiunile JVM din scripturile de pornire. Rulez jdeps --jdk-internals pe artefacte, ca să găsesc utilizări de API-uri interne (sun.misc.*, com.sun.*).

2. Probleme cunoscute pe care le caut:

  • Java 11 (JEP 320) a eliminat modulele Java EE și CORBA din JDK: JAXB, JAX-WS, javax.annotation. Se adaugă ca dependențe explicite.
  • Java 16–17 (JEP 396, JEP 403): API-urile interne ale JDK-ului sunt încapsulate strict, iar opțiunea --illegal-access nu mai există. Bibliotecile vechi care folosesc reflecție adâncă aruncă InaccessibleObjectException. Soluția corectă este actualizarea bibliotecii; --add-opens e o soluție temporară.
  • Biblioteci care manipulează bytecode (Lombok, Mockito, ByteBuddy, ASM, Hibernate) trebuie aduse la versiuni care suportă Java 21.
  • Unele opțiuni JVM au fost eliminate (de exemplu opțiunile pentru PermGen sau CMS), iar JVM-ul refuză să pornească cu ele. G1 este GC-ul implicit din Java 9.
  • Dacă migrarea include Spring Boot 3, aceasta cere Java 17 și trecerea de la javax.* la jakarta.*, o schimbare separată de cea a limbajului.

3. Execuție în pași. Întâi build-ul rulează pe JDK 21 cu --release 8, apoi trec ținta la 11, 17 și 21, cu suita de teste completă la fiecare pas. Rulez în paralel, în staging, versiunea veche și cea nouă și compar metricile: latență, memorie, pauze de GC.

4. Abia la final, adoptarea noutăților: records, switch cu pattern-uri, text blocks, virtual threads, în cod nou și prin refactorizări treptate.

Pentru fiecare pas există un plan de rollback, comunicat echipei.

Ce urmărește intervievatorul: Verifică experiența cu proiecte reale și cunoașterea schimbărilor incompatibile dintre versiunile LTS. Răspunsul slab este „schimb versiunea în pom.xml și rulez testele”.

Eroarea, în practică:InaccessibleObjectException: does not "opens"package ... is not visible

Întrebări de interviu pe meserie

Alte tehnologii

← Toate întrebările de interviu

Tudor Andrei Dumitrescu
Cine coordonează pregătirea de interviu

Tudor Andrei Dumitrescu

Senior Software Developer · fondatorul Academiei Programatorilor

LinkedIn
  1. 2019 Junior JavaCognizant Softvision
  2. 2021 Mid JavaCognizant Softvision
  3. 2022 Team LeaderEndava
  4. 2023 Senior Software DeveloperUniCredit
  5. Acum Senior Software DeveloperHCLTech
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu

Certificat de formator autorizat · Ministerul Muncii și Ministerul Educației · 2022

Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Întrebările de aici urmăresc ce se cere la interviurile de Java, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

Algoritmi și structuri de date, explicați gratuit

Fiecare subiect are o animație pas cu pas, codul în Python, C++ și Java și întrebările care apar la interviuri și la BAC.

  1. Recursivitate
  2. Backtracking
  3. Metoda bulelor
  4. Căutarea binară
  5. Stiva și coada
  6. Arbori binari
  7. BFS și DFS
  8. Algoritmul lui Dijkstra
  9. Programare dinamică

Pe scurt, toate într-un loc: algoritmi explicați și structuri de date.

Învață Java scriind cod, nu doar citind

Curs Java: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.