...
Pregătire interviuri

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

Întrebările care apar des la interviurile de Java Developer, 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.

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

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

Un proces de angajare pentru un post de Java Developer în România are de obicei trei sau patru etape: o discuție cu cineva de la HR sau un recruiter (motivație, așteptări, disponibilitate), un interviu tehnic cu unul sau doi programatori din echipă, uneori o temă de casă sau un exercițiu de live coding, iar la final o discuție cu managerul echipei. Interviul tehnic pornește aproape mereu de la fundamentele limbajului (OOP, colecții, excepții), trece prin Java 8+ și ajunge la Spring Boot, baze de date și uneltele de zi cu zi: Git, SQL, Linux, Docker.

La nivel de junior, intervievatorul vrea să vadă că înțelegi bine bazele și că poți explica de ce funcționează lucrurile așa, nu doar definiții învățate pe de rost. La mid, întrebările se mută spre cum se comportă codul în producție: HashMap pe interior, tranzacții, problema N+1, concurență, depanarea unui OutOfMemoryError. La senior contează compromisurile de design, experiența cu incidente reale și felul în care ridici nivelul echipei.

Folosește pagina așa: citește întâi întrebarea și încearcă să răspunzi cu voce tare, ca la interviu. Apoi compară cu răspunsul scurt (versiunea pe care o poți da în primele 20 de secunde) și cu explicația detaliată. Rulează exemplele de cod pe calculatorul tău și modifică-le. Partea „De ce se întreabă” îți arată ce verifică de fapt intervievatorul și unde greșesc cei mai mulți candidați.

Fundamentele limbajului Java

1 Junior

Care este diferența dintre JDK, JRE și JVM?

Răspuns scurt: JVM rulează bytecode-ul Java. JRE înseamnă JVM plus bibliotecile standard necesare la rulare. JDK conține JRE-ul plus uneltele de dezvoltare: compilatorul javac, jar, javadoc, jshell, jdb.

JVM (Java Virtual Machine) este mașina virtuală care încarcă fișierele .class, verifică bytecode-ul și îl execută, interpretându-l la început și compilându-l apoi în cod nativ cu JIT-ul (Just-In-Time compiler) pentru porțiunile folosite des. Datorită ei, același .jar rulează pe Linux, Windows sau macOS: compilezi o dată, iar JVM-ul specific fiecărui sistem de operare se ocupă de restul.

JRE (Java Runtime Environment) este JVM-ul plus bibliotecile standard (java.lang, java.util, java.io etc.). E tot ce îți trebuie ca să rulezi o aplicație deja compilată.

JDK (Java Development Kit) include tot ce are JRE-ul, plus unelte pentru dezvoltare: javac (compilatorul), jar, javadoc, jshell, jdb, jcmd, jstack.

BASH
javac Salut.java   # produce Salut.class (bytecode)
java Salut         # JVM-ul încarcă și execută clasa

Un detaliu de versiune: începând cu Java 11, Oracle nu mai distribuie un JRE separat, iar practica uzuală e să instalezi un JDK (Temurin, Corretto, Oracle JDK) sau să construiești un runtime minimal cu jlink. În imaginile Docker vei întâlni însă și variante „jre”, care conțin doar ce trebuie la rulare și sunt mai mici.

Ce urmărește intervievatorul: Verifică dacă înțelegi lanțul cod sursă, bytecode, execuție. Greșeala tipică e să spui că JVM-ul compilează codul sursă Java, când de fapt el lucrează cu bytecode.

2 Junior

Care este diferența dintre tipurile primitive și tipurile referință? Ce este autoboxing-ul?

Răspuns scurt: Primitivele (int, long, double, boolean etc.) stochează direct valoarea și nu pot fi null. Tipurile referință indică spre un obiect din heap. Autoboxing-ul este conversia automată dintre un primitiv și clasa lui wrapper, de exemplu din int în Integer.

Java are opt tipuri primitive: byte, short, int, long, float, double, char, boolean. O variabilă primitivă conține chiar valoarea, are o valoare implicită (0, false) când e câmp și nu poate fi null. Orice altceva e un tip referință: variabila conține o referință (un fel de adresă) spre un obiect aflat în heap.

Colecțiile și genericele lucrează doar cu obiecte, așa că fiecare primitiv are o clasă wrapper: Integer, Long, Double, Boolean... Compilatorul face conversia automat:

JAVA
List<Integer> numere = new ArrayList<>();
numere.add(5);            // autoboxing: Integer.valueOf(5)
int x = numere.get(0);    // unboxing: intValue()

Integer gol = null;
int y = gol;              // NullPointerException la unboxing

Capcanele de reținut:

  • unboxing-ul unui null aruncă NullPointerException, o eroare frecventă când un câmp Integer dintr-o entitate vine gol din baza de date;
  • boxing-ul repetat în bucle (de exemplu o sumă ținută într-un Long) creează multe obiecte inutile și încetinește codul;
  • compararea a doi wrapperi cu == compară referințe, nu valori.

Regula practică: folosește primitive pentru calcule și câmpuri care nu pot lipsi, wrapperi când ai nevoie de null (valoare absentă) sau de colecții.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că știi unde stă valoarea și că știi capcanele: NPE la unboxing și comparația cu ==.

3 Junior

De ce nu e bine să compari String-uri cu ==? Ce este String pool-ul?

Răspuns scurt: Operatorul == compară referințele, adică verifică dacă e același obiect, iar equals() compară conținutul. String pool-ul este o zonă în care JVM-ul păstrează o singură copie pentru fiecare literal String, de aceea == pare uneori să funcționeze.

Pentru obiecte, == răspunde la întrebarea „sunt aceeași instanță?”. equals() din String compară caracter cu caracter. Confuzia apare din cauza String pool-ului: literalii identici din cod sunt internalizați, adică JVM-ul păstrează un singur obiect pentru ei.

JAVA
String a = "java";
String b = "java";
String c = new String("java");
String d = c.intern();

System.out.println(a == b);       // true: același literal din pool
System.out.println(a == c);       // false: new creează alt obiect
System.out.println(a.equals(c));  // true: același conținut
System.out.println(a == d);       // true: intern() întoarce instanța din pool

În cod real, String-urile vin din request-uri HTTP, din baza de date sau din concatenări făcute la rulare, deci nu sunt în pool, iar == dă false chiar dacă textul e identic. De aici apar bug-uri care trec de testele locale cu literali și apar abia în producție.

Folosește mereu equals(), iar când una dintre valori poate fi null, pune constanta în stânga ("ADMIN".equals(rol)) sau folosește Objects.equals(a, b). Pentru comparații fără a ține cont de majuscule există equalsIgnoreCase(). Din Java 7, pool-ul stă în heap, nu în PermGen, așa că poate fi colectat de garbage collector.

Ce urmărește intervievatorul: E o întrebare clasică de filtrare pentru junior. Greșeala tipică: candidatul spune că == merge pentru String-uri pentru că a văzut că merge cu literali.

4 Junior

De ce este String imuabil în Java și când folosești StringBuilder?

Răspuns scurt: String este imuabil ca să poată fi partajat în siguranță (pool, thread-uri, chei în HashMap) și pentru securitate. Orice modificare creează un obiect nou, de aceea pentru concatenări repetate, de exemplu în bucle, folosești StringBuilder.

Un obiect String nu se mai poate schimba după creare: toUpperCase(), replace() sau + întorc un obiect nou. Motivele acestui design:

  • partajare sigură: pool-ul poate refolosi aceeași instanță pentru toți cei care folosesc literalul, fără riscul ca cineva să o modifice;
  • thread safety: un obiect imuabil poate fi citit din mai multe thread-uri fără sincronizare;
  • chei de hash stabile: hashCode() e calculat o singură dată și pus în cache, iar cheia nu se poate „muta” într-un HashMap;
  • securitate: căi de fișiere, URL-uri sau nume de clase nu pot fi schimbate după ce au fost validate.

Costul imuabilității se vede la concatenarea în buclă:

JAVA
String s = "";
for (int i = 0; i < 10_000; i++) {
    s += i;              // creează un String nou la fiecare pas: O(n^2)
}

StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10_000; i++) {
    sb.append(i);        // modifică același buffer
}
String rezultat = sb.toString();

Pentru o concatenare simplă pe o singură linie ("Salut, " + nume), compilatorul o optimizează singur (din Java 9 prin invokedynamic și StringConcatFactory), deci nu ai nevoie de StringBuilder. StringBuffer e varianta veche, cu metode synchronized; aproape niciodată nu ai nevoie de ea.

Ce urmărește intervievatorul: Se verifică dacă știi motivele designului, nu doar faptul în sine. Mulți candidați nu știu că pentru concatenarea simplă compilatorul se descurcă singur.

5 Junior

Java transmite parametrii prin valoare sau prin referință?

Răspuns scurt: Java transmite întotdeauna prin valoare. Pentru obiecte, valoarea copiată este referința, așa că metoda poate modifica starea obiectului, dar nu poate face variabila apelantului să indice spre alt obiect.

Toți parametrii sunt copiați la apel. Pentru un int se copiază numărul; pentru un obiect se copiază referința. De aici două comportamente care par contradictorii:

JAVA
static void modifica(StringBuilder sb) {
    sb.append(" lume");      // modifică obiectul spre care indică ambele referințe
}

static void reasigneaza(StringBuilder sb) {
    sb = new StringBuilder("altceva"); // schimbă doar copia locală
}

public static void main(String[] args) {
    StringBuilder text = new StringBuilder("salut");
    modifica(text);
    reasigneaza(text);
    System.out.println(text);   // salut lume
}

În modifica, ambele referințe (cea din main și parametrul) indică spre același obiect, deci modificarea se vede. În reasigneaza, parametrul primește o referință nouă, dar variabila text din main rămâne neatinsă. Dacă Java ar transmite prin referință, ca ref din C# sau & din C++, după reasigneaza am fi văzut „altceva”.

Consecința practică: o metodă nu poate „întoarce” un rezultat prin reasignarea parametrului. Dacă vrei să produci o valoare nouă, o returnezi. Și invers: dacă primești o listă sau un obiect mutabil, ai grijă că orice modificare făcută în metodă se vede la apelant, ceea ce poate surprinde. De aceea multe echipe preferă obiecte imuabile sau copii defensive.

Ce urmărește intervievatorul: Întrebarea verifică modelul mental despre referințe. Răspunsul „obiectele prin referință, primitivele prin valoare” e considerat greșit de majoritatea intervievatorilor.

6 Junior

Ce înseamnă cuvântul cheie static? Dă exemple de câmpuri, metode și blocuri statice.

Răspuns scurt: Un membru static aparține clasei, nu unei instanțe: există o singură copie, accesibilă fără obiect. Metodele statice nu au acces la this, iar blocurile statice rulează o singură dată, când clasa este inițializată.

static mută un membru de la nivel de obiect la nivel de clasă.

JAVA
public class Contor {
    private static int instante = 0;          // o singură copie pentru toată clasa
    public static final double TVA = 0.19;    // constantă

    static {                                   // rulează o dată, la inițializarea clasei
        System.out.println("Clasa Contor a fost încărcată");
    }

    public Contor() { instante++; }

    public static int getInstante() {          // se apelează Contor.getInstante()
        return instante;                       // nu poate folosi this sau câmpuri non-static
    }
}

Unde se folosește în practică:

  • constante: static final (de exemplu limite, chei de configurare);
  • metode utilitare fără stare: Math.max, Collections.sort, List.of;
  • metode factory: LocalDate.of(2024, 1, 15), Optional.of(x);
  • clase interne statice, cum e un Builder, care nu au nevoie de o referință spre instanța exterioară.

Capcanele: o metodă statică nu poate fi suprascrisă (doar ascunsă, deci nu are polimorfism), iar starea statică mutabilă e practic o variabilă globală. Ea complică testarea, e partajată între thread-uri (deci are nevoie de sincronizare) și poate produce memory leak-uri dacă ții în ea colecții care tot cresc. Într-o aplicație Spring, preferă un bean singleton injectat în locul unui câmp static mutabil.

Ce urmărește intervievatorul: Se verifică diferența clasă/instanță. Greșeala frecventă e folosirea câmpurilor statice mutabile ca o scurtătură și necunoașterea problemelor pe care le aduc.

7 Junior

Care este diferența dintre final, finally și finalize?

Răspuns scurt: final face ca o variabilă să nu poată fi reasignată, o metodă să nu poată fi suprascrisă și o clasă să nu poată fi extinsă. finally este blocul care rulează după try/catch. finalize() era o metodă apelată de GC, depreciată din Java 9.

Sunt trei lucruri fără legătură între ele, care doar sună la fel.

final este un modificator:

  • pe o variabilă: poate fi atribuită o singură dată. Atenție, pentru obiecte, referința e finală, nu și conținutul: final List<String> l = new ArrayList<>(); l.add("x"); e perfect valid;
  • pe o metodă: nu poate fi suprascrisă în subclase;
  • pe o clasă: nu poate fi extinsă (String, Integer sunt finale).

finally e un bloc care se execută după try și eventualul catch, indiferent dacă a apărut o excepție sau s-a ieșit cu return. Se folosea pentru eliberarea resurselor; azi, pentru resurse AutoCloseable preferi try-with-resources.

JAVA
try {
    proceseaza();
} catch (IOException e) {
    log.error("Eroare", e);
} finally {
    System.out.println("rulează mereu"); // excepții: System.exit(), JVM-ul se oprește brusc
}

finalize() era o metodă din Object pe care GC-ul o putea apela înainte de a colecta obiectul. Nu se știa când (sau dacă) rulează, încetinea colectarea și putea „reînvia” obiecte. Este depreciată din Java 9 și marcată pentru eliminare din Java 18 (JEP 421). Alternativele moderne sunt try-with-resources și java.lang.ref.Cleaner.

Ce urmărește intervievatorul: E o întrebare de vocabular. Intervievatorul urmărește mai ales nuanța „referință finală, nu obiect imuabil” și dacă știi că finalize nu se mai folosește.

8 Junior

Ce afișează codul următor: Integer a = 127, b = 127; Integer c = 128, d = 128; System.out.println(a == b); System.out.println(c == d);

Răspuns scurt: Afișează true și apoi false. Integer.valueOf, folosit la autoboxing, întoarce instanțe din cache pentru valorile între -128 și 127, deci a și b sunt același obiect, iar c și d sunt obiecte diferite.

Autoboxing-ul Integer a = 127 este compilat ca Integer.valueOf(127). Specificația cere ca valueOf să refolosească instanțe pentru valorile din intervalul -128 ... 127, păstrate într-un cache intern (IntegerCache). Pentru 128, valueOf creează în mod implicit un obiect nou la fiecare apel.

JAVA
Integer a = 127, b = 127;
Integer c = 128, d = 128;
System.out.println(a == b);        // true  (aceeași instanță din cache)
System.out.println(c == d);        // false (două obiecte diferite)
System.out.println(c.equals(d));   // true
System.out.println(c.intValue() == d); // true: d face unboxing, se compară valori

Limita superioară a cache-ului poate fi mărită cu -XX:AutoBoxCacheMax=<n>, deci rezultatul pentru 128 depinde chiar și de configurarea JVM-ului. Încă un motiv să nu te bazezi pe ==. Cache-uri asemănătoare există pentru Short, Long și Byte (-128 ... 127) și pentru Character (0 ... 127), iar Boolean.valueOf întoarce mereu TRUE sau FALSE.

Bug-ul apare des în practică: compari două ID-uri de tip Long venite din entități cu ==, testele cu ID-uri mici trec, iar în producție, cu ID-uri mari, comparația dă brusc false. Soluția: equals(), Objects.equals() sau conversia explicită la primitiv.

Ce urmărește intervievatorul: Este o întrebare-capcană care verifică dacă înțelegi autoboxing-ul și diferența dintre identitate și egalitate. Mulți răspund true/true sau false/false.

9 Mid

Ce sunt records în Java și când le folosești?

Răspuns scurt: Un record (stabil din Java 16) este o clasă imuabilă pentru date: declari componentele, iar compilatorul generează constructorul, accesorii, equals(), hashCode() și toString(). Se potrivește pentru DTO-uri, rezultate de query și chei compuse.

Înainte de records, o clasă simplă de date cerea zeci de linii de boilerplate sau Lombok. Un record declară doar componentele:

JAVA
public record Produs(String nume, BigDecimal pret) {
    public Produs {                         // constructor compact, pentru validare
        Objects.requireNonNull(nume);
        if (pret.signum() < 0) throw new IllegalArgumentException("preț negativ");
    }
    public Produs cuReducere(int procent) { // poți adăuga metode
        BigDecimal factor = BigDecimal.valueOf(100 - procent).movePointLeft(2);
        return new Produs(nume, pret.multiply(factor));
    }
}

Produs p = new Produs("Carte", new BigDecimal("50"));
System.out.println(p.nume());  // accesorul nu are prefixul get

Ce primești automat: câmpuri private final, constructor canonic, accesori nume() și pret(), equals() și hashCode() bazate pe toate componentele și un toString() lizibil. Un record e implicit final, nu poate extinde altă clasă (extinde deja java.lang.Record), dar poate implementa interfețe.

Unde se potrivește: DTO-uri pentru request-uri și răspunsuri REST (Jackson le suportă), proiecții din Spring Data JPA, chei compuse în Map, rezultate întoarse de metode. Unde nu se potrivește: entitățile JPA, pentru că Hibernate are nevoie de un constructor fără argumente, de câmpuri mutabile și de proxy-uri, lucruri pe care un record nu le permite. Reține și că imuabilitatea e „superficială”: dacă o componentă e o List mutabilă, conținutul ei se poate schimba.

Ce urmărește intervievatorul: Arată dacă ești la curent cu Java modern. Greșeala tipică: propunerea de a face entitățile JPA records.

10 Mid

Ce s-a schimbat important în limbaj între Java 8 și Java 21?

Răspuns scurt: Pe lângă records, cele mai folosite noutăți sunt var (10), switch expressions (14), text blocks (15), pattern matching pentru instanceof (16), sealed classes (17), iar în Java 21 pattern matching în switch, record patterns și virtual threads.

Java 11, 17 și 21 sunt versiuni LTS (cu suport pe termen lung), deci cele pe care le vei întâlni cel mai des în proiecte. Iată ce merită să știi la interviu:

  • var (Java 10): inferența tipului pentru variabile locale, var lista = new ArrayList<String>();. Tipul rămâne static, doar nu îl mai scrii.
  • HttpClient standard (11), plus metode noi pe String: isBlank(), strip(), lines(), repeat().
  • switch expressions (14): switch întoarce o valoare și, cu sintaxa ->, nu mai are fall-through.
  • text blocks (15): String-uri pe mai multe linii, utile pentru SQL sau JSON.
  • pattern matching pentru instanceof (16): if (obj instanceof String s) { s.length(); }, fără cast explicit.
  • records (16) și sealed classes (17): ierarhii închise, sealed interface Forma permits Cerc, Patrat.
  • Helpful NullPointerExceptions (14, active implicit din 15): mesajul NPE spune exact ce referință era null.
  • În Java 21: pattern matching în switch, record patterns, virtual threads, sequenced collections (getFirst(), getLast()).
JAVA
sealed interface Forma permits Cerc, Patrat {}
record Cerc(double raza) implements Forma {}
record Patrat(double latura) implements Forma {}

static double arie(Forma f) {
    return switch (f) {                    // Java 21
        case Cerc c -> Math.PI * c.raza() * c.raza();
        case Patrat p -> p.latura() * p.latura();
    };                                     // fără default: compilatorul știe că e complet
}

Spring Boot 3 cere minim Java 17, motiv pentru care multe proiecte au migrat de la 8 sau 11.

Ce urmărește intervievatorul: Intervievatorul vrea să știe dacă ai lucrat cu Java modern sau doar cu Java 8. E suficient să explici bine 4–5 noutăți și să știi care sunt versiunile LTS.

11 Mid

Ce metodă se apelează la overloading când există mai mulți candidați? Ce afișează print(5) dacă există print(long) și print(Integer)?

Răspuns scurt: Afișează varianta long. Compilatorul alege metoda în trei faze: întâi fără boxing și varargs (permite lărgirea int în long), apoi cu boxing, apoi cu varargs. Lărgirea primitivă câștigă în fața autoboxing-ului.

Alegerea metodei supraîncărcate se face la compilare, după tipul static al argumentelor, în trei faze stabilite de specificația limbajului (JLS 15.12.2):

  • faza 1: potrivire exactă sau prin lărgire primitivă (int în long, float în double), fără boxing și fără varargs;
  • faza 2: permite boxing și unboxing;
  • faza 3: permite varargs.

Prima fază care găsește un candidat câștigă.

JAVA
static void print(long x)      { System.out.println("long"); }
static void print(Integer x)   { System.out.println("Integer"); }
static void print(int... x)    { System.out.println("varargs"); }
static void print(Object x)    { System.out.println("Object"); }

print(5);           // long: lărgirea e acceptată din faza 1
print((Integer) 5); // Integer
print();            // varargs
print("text");      // Object

Dacă ștergi print(long), apelul print(5) ajunge la Integer (faza 2). Dacă ștergi și pe aceea, ajunge la Object (tot faza 2: boxing la Integer, apoi lărgire de referință la Object). Varargs vine mereu ultimul.

Două detalii care se cer des: tipul de retur nu contează la overloading (două metode care diferă doar prin tipul de retur nu compilează), iar alegerea depinde de tipul declarat, nu de cel real. Dacă ai Object o = "text"; print(o);, se apelează varianta cu Object chiar dacă există una cu String. Asta e diferența fundamentală față de overriding, unde decizia se ia la rulare.

Ce urmărește intervievatorul: E o întrebare de tip „ce afișează” care verifică diferența dintre rezolvarea la compilare și polimorfismul de la rulare. Mulți aleg Integer pentru că sună „mai exact”.

Programare orientată pe obiecte

12 Junior

Care sunt cei patru piloni ai programării orientate pe obiecte? Explică-i cu exemple din Java.

Răspuns scurt: Încapsulare (ascunderea stării în spatele metodelor), moștenire (o clasă preia comportamentul alteia), polimorfism (același apel, comportament diferit după tipul real) și abstractizare (expui ce face un obiect, nu cum face).

Răspunsul bun nu e doar lista, ci câte un exemplu pentru fiecare.

  • Încapsulare: câmpurile sunt private, iar starea se schimbă doar prin metode care păstrează regulile. Un ContBancar nu are setSold(), ci depune() și retrage(), care verifică dacă suma e pozitivă și dacă există fonduri.
  • Moștenire: class Manager extends Angajat refolosește câmpurile și metodele lui Angajat. Java permite moștenire simplă între clase, dar o clasă poate implementa oricâte interfețe.
  • Polimorfism: o referință de tip părinte poate indica spre orice subtip, iar metoda apelată se alege la rulare.
  • Abstractizare: definești contractul (o interfață sau o clasă abstractă) și ascunzi detaliile implementării.
JAVA
interface Plata { void proceseaza(BigDecimal suma); }       // abstractizare

class PlataCard implements Plata {
    public void proceseaza(BigDecimal suma) { /* apel procesator card */ }
}
class PlataTransfer implements Plata {
    public void proceseaza(BigDecimal suma) { /* generează ordin de plată */ }
}

List<Plata> plati = List.of(new PlataCard(), new PlataTransfer());
for (Plata p : plati) {
    p.proceseaza(new BigDecimal("100"));   // polimorfism: se alege la rulare
}

Codul care folosește Plata nu se schimbă când adaugi o nouă metodă de plată. Acesta e beneficiul practic al OOP: schimbările rămân localizate. Exemplele cu animale care fac „ham” sunt acceptate, dar un exemplu de business arată că ai și scris cod real.

Ce urmărește intervievatorul: Este întrebarea de deschidere pentru OOP. Intervievatorul caută exemple concrete, nu definiții recitate, și dacă știi de ce contează fiecare principiu.

13 Junior

Care este diferența dintre o clasă abstractă și o interfață? Când o alegi pe fiecare?

Răspuns scurt: O clasă abstractă poate avea stare (câmpuri de instanță), constructori și metode cu implementare, dar poate fi extinsă doar una. O interfață definește un contract, poate avea metode default și static (din Java 8), iar o clasă poate implementa mai multe.

De la Java 8 diferența s-a micșorat, pentru că interfețele pot avea metode default (cu implementare) și static, iar din Java 9 și metode private. Diferențele care rămân:

  • stare: o interfață nu are câmpuri de instanță, doar constante (public static final). Clasa abstractă poate avea câmpuri protected sau private;
  • constructori: doar clasa abstractă are;
  • moștenire multiplă: o clasă extinde o singură clasă, dar implementează oricâte interfețe;
  • modificatori: metodele abstracte din interfață sunt implicit public.
JAVA
interface Notificator {
    void trimite(String mesaj);
    default void trimiteToate(List<String> mesaje) { mesaje.forEach(this::trimite); }
}

abstract class NotificatorCuRetry implements Notificator {
    protected final int maxIncercari;                 // stare comună
    protected NotificatorCuRetry(int max) { this.maxIncercari = max; }

    public final void trimite(String mesaj) {         // template method
        for (int i = 1; i <= maxIncercari; i++) {
            if (incearca(mesaj)) return;
        }
        throw new IllegalStateException("Nu s-a putut trimite");
    }
    protected abstract boolean incearca(String mesaj);
}

Regula practică: începe cu o interfață pentru contract, pentru că e mai flexibilă și ușor de înlocuit cu un mock în teste. Folosește o clasă abstractă când mai multe implementări au cu adevărat stare și logică comună, ca în exemplul cu retry (șablonul Template Method). Dacă două interfețe au aceeași metodă default, clasa care le implementează pe amândouă trebuie să o suprascrie explicit, altfel nu compilează.

Ce urmărește intervievatorul: Verifică dacă știi ce s-a schimbat la interfețe în Java 8 și dacă poți justifica alegerea. Răspunsul „interfața nu are implementare” e depășit.

14 Junior

Care este diferența dintre overloading și overriding?

Răspuns scurt: Overloading înseamnă mai multe metode cu același nume, dar parametri diferiți, alese la compilare. Overriding înseamnă că o subclasă redefinește o metodă moștenită cu aceeași semnătură, iar alegerea se face la rulare, după tipul real al obiectului.

Overloading (supraîncărcare) ține de compilator: metodele au același nume, dar listă de parametri diferită (număr, tip sau ordine). Tipul de retur singur nu contează. Exemple: println(int), println(String), constructori multipli.

Overriding (suprascriere) ține de polimorfism: subclasa oferă propria implementare pentru o metodă moștenită, iar JVM-ul alege versiunea după tipul real al obiectului (dynamic dispatch).

JAVA
class Forma {
    double arie() { return 0; }
    void descrie(String prefix) { System.out.println(prefix + arie()); }
    void descrie() { descrie("Arie: "); }        // overloading
}

class Cerc extends Forma {
    private final double r;
    Cerc(double r) { this.r = r; }
    @Override
    double arie() { return Math.PI * r * r; }    // overriding
}

Forma f = new Cerc(1);
f.descrie();   // Arie: 3.141592653589793, apelează arie() din Cerc

Regulile pentru overriding:

  • aceeași semnătură; tipul de retur poate fi un subtip (covariant return);
  • accesul nu poate fi mai restrictiv (o metodă public nu devine protected);
  • nu poți declara excepții checked noi sau mai largi;
  • metodele static, private și final nu se suprascriu.

Pune mereu @Override: dacă greșești semnătura (de exemplu scrii equals(Produs p) în loc de equals(Object o)), compilatorul te oprește, în loc să creezi fără să vrei un overload care nu e apelat niciodată de colecții.

Ce urmărește intervievatorul: Este o întrebare de bază, dar intervievatorul urmărește regulile de overriding și rostul lui @Override. Greșeala clasică e equals cu parametru de alt tip.

15 Junior

Ce sunt modificatorii de acces în Java și cum ajută la încapsulare?

Răspuns scurt: Sunt patru niveluri: public (oriunde), protected (pachet plus subclase), package-private, fără cuvânt cheie (doar în același pachet), și private (doar în clasă). Încapsularea înseamnă să ții starea private și să expui doar operațiile care păstrează obiectul valid.

Nivelurile, de la cel mai restrictiv la cel mai deschis:

  • private: vizibil doar în clasa respectivă;
  • fără modificator (package-private): vizibil în același pachet;
  • protected: în același pachet plus în subclase din alte pachete;
  • public: oriunde.

Încapsularea nu înseamnă să pui getter și setter pe fiecare câmp. Asta doar mută problema. Înseamnă ca obiectul să-și protejeze singur regulile:

JAVA
public class Comanda {
    private final List<Linie> linii = new ArrayList<>();
    private Status status = Status.NOUA;

    public void adaugaLinie(Produs p, int cantitate) {
        if (status != Status.NOUA) throw new IllegalStateException("Comanda e trimisă");
        if (cantitate <= 0) throw new IllegalArgumentException("cantitate invalidă");
        linii.add(new Linie(p, cantitate));
    }

    public List<Linie> getLinii() {
        return Collections.unmodifiableList(linii);   // nu expui lista internă
    }
}

Dacă getLinii() ar întoarce lista internă, orice apelant ar putea adăuga linii într-o comandă deja trimisă, ocolind regula. Folosește cel mai restrictiv nivel care funcționează: clasele de implementare dintr-un modul pot fi package-private, iar câmpurile aproape mereu private. Din Java 9, sistemul de module (JPMS) adaugă un nivel în plus: pachetele neexportate nu sunt vizibile în afara modulului nici dacă au clase public.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi diferența dintre protected și package-private și dacă înțelegi încapsularea dincolo de getteri și setteri.

16 Junior

În ce ordine se execută inițializarea unui obiect când există moștenire? Ce fac this() și super()?

Răspuns scurt: Întâi se inițializează clasele (blocurile statice, părinte apoi copil, o singură dată). Pentru fiecare obiect rulează constructorul părintelui, apoi câmpurile și blocurile de instanță ale copilului, apoi corpul constructorului copilului. super() apelează constructorul părintelui, this() alt constructor din aceeași clasă.

JAVA
class Parinte {
    static { System.out.println("1. static Parinte"); }
    { System.out.println("3. instanță Parinte"); }
    Parinte() { System.out.println("4. constructor Parinte"); }
}

class Copil extends Parinte {
    static { System.out.println("2. static Copil"); }
    private String nume = initNume();
    { System.out.println("6. instanță Copil"); }

    Copil() {
        this("anonim");                       // trebuie să fie prima instrucțiune
        System.out.println("8. Copil()");
    }
    Copil(String n) {
        super();                              // implicit, chiar dacă nu îl scrii
        System.out.println("7. Copil(String)");
    }
    private String initNume() { System.out.println("5. câmp nume"); return "x"; }
}

new Copil();

Ordinea afișată este exact cea numerotată. Blocurile statice rulează o singură dată, la prima utilizare a clasei; dacă mai creezi un Copil, apar doar pașii 3–8. Inițializatorii de câmpuri și blocurile de instanță rulează în ordinea în care apar în cod, după ce constructorul părintelui s-a terminat.

Reguli despre this() și super(): oricare dintre ele trebuie să fie prima instrucțiune din constructor, nu pot apărea amândouă, iar dacă nu scrii nimic, compilatorul pune super(). Dacă părintele nu are constructor fără argumente, trebuie să apelezi explicit super(...), altfel codul nu compilează.

O capcană reală: dacă din constructorul părintelui apelezi o metodă suprascrisă în copil, ea rulează înainte ca câmpurile copilului să fie inițializate și le vede cu valori implicite (null, 0). De aceea nu se apelează metode suprascriibile din constructori.

Ce urmărește intervievatorul: Verifică dacă înțelegi ciclul de viață al unui obiect. Partea care diferențiază candidații e capcana apelului unei metode suprascrise din constructor.

17 Junior

Care este contractul dintre equals() și hashCode()? Ce se întâmplă dacă îl încalci?

Răspuns scurt: Dacă două obiecte sunt egale după equals(), trebuie să aibă același hashCode(). Dacă suprascrii equals() fără hashCode(), obiectele egale ajung de regulă în bucket-uri diferite din HashMap sau HashSet și nu mai sunt găsite.

Contractul din documentația lui Object:

  • equals e reflexiv, simetric, tranzitiv, consecvent, iar x.equals(null) întoarce false;
  • obiectele egale au obligatoriu același hashCode;
  • obiectele diferite pot avea același hash (coliziune), dar e bine să fie rar.

HashMap și HashSet caută întâi bucket-ul după hashCode, apoi compară cu equals. Dacă ai doar equals suprascris, două obiecte „egale” au hash-uri diferite (moștenite din Object) și practic nu se întâlnesc niciodată.

JAVA
public final class Email {
    private final String adresa;
    public Email(String adresa) { this.adresa = adresa.toLowerCase(); }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Email other)) return false;   // Java 16+
        return adresa.equals(other.adresa);
    }

    @Override
    public int hashCode() { return Objects.hash(adresa); }
}

Set<Email> set = new HashSet<>();
set.add(new Email("Ana@x.ro"));
System.out.println(set.contains(new Email("ana@x.ro")));  // true; fără hashCode: de regulă false

Două greșeli frecvente:

  • folosești câmpuri mutabile în hashCode, apoi modifici obiectul după ce l-ai pus într-un HashSet. Obiectul rămâne în bucket-ul vechi și nu mai poate fi găsit sau șters;
  • la entitățile JPA, un equals bazat pe un ID generat de baza de date se schimbă după persist. O soluție uzuală e un hashCode constant pe clasă și un equals pe ID doar când acesta nu e null, sau folosirea unei chei naturale.

Pentru clase de date, records generează corect ambele metode.

Ce urmărește intervievatorul: Este una dintre cele mai puse întrebări la Java. Intervievatorul vrea să audă legătura cu HashMap și, ideal, problema cheilor mutabile.

18 Junior

Ce afișează codul în care Parinte și Copil au fiecare o metodă statică salut() și o metodă de instanță nume(), iar tu apelezi Parinte p = new Copil(); p.salut(); p.nume();?

Răspuns scurt: p.salut() afișează varianta din Parinte, pentru că metodele statice nu sunt polimorfice și se aleg după tipul declarat. p.nume() afișează varianta din Copil, pentru că metodele de instanță se aleg la rulare, după tipul real.

JAVA
class Parinte {
    static void salut() { System.out.println("salut din Parinte"); }
    void nume()         { System.out.println("nume din Parinte"); }
    String eticheta = "Parinte";
}

class Copil extends Parinte {
    static void salut() { System.out.println("salut din Copil"); }   // hiding
    @Override
    void nume()         { System.out.println("nume din Copil"); }    // overriding
    String eticheta = "Copil";                                       // câmp ascuns
}

Parinte p = new Copil();
p.salut();                      // salut din Parinte
p.nume();                       // nume din Copil
System.out.println(p.eticheta); // Parinte

Metoda statică din Copil nu suprascrie metoda din Parinte, ci o ascunde (method hiding). Compilatorul transformă p.salut() în Parinte.salut() pe baza tipului declarat al variabilei, deci tipul real nu contează. De aceea IDE-urile avertizează când apelezi o metodă statică printr-o instanță: codul arată ca un apel polimorfic, dar nu este. Dacă ai încerca să pui @Override pe salut() din Copil, codul nu ar compila.

La fel se comportă câmpurile: nu sunt polimorfice. p.eticheta citește câmpul declarat în Parinte. Obiectul Copil are de fapt două câmpuri eticheta, unul ascuns de celălalt, o sursă sigură de confuzie.

Doar metodele de instanță care nu sunt private, static sau final participă la dynamic dispatch. Ca regulă: apelează metodele statice prin numele clasei și nu redeclara în subclase câmpuri cu același nume.

Ce urmărește intervievatorul: Este o întrebare „ce afișează” care verifică dacă înțelegi exact ce e polimorfic în Java. Mulți presupun că și metodele statice și câmpurile se aleg la rulare.

19 Mid

De ce se spune „preferă compoziția în locul moștenirii”? Dă un exemplu.

Răspuns scurt: Moștenirea leagă strâns subclasa de detaliile de implementare ale părintelui și e fixată la compilare. Compoziția înseamnă că o clasă conține și deleagă către alte obiecte, deci poți schimba comportamentul, testa izolat și evita ierarhii fragile.

Moștenirea exprimă o relație „este un” și expune subclasei detaliile interne ale părintelui. Problema clasică e clasa de bază fragilă: o schimbare în părinte strică subclase la care nu te gândeai. Exemplul celebru, din cartea „Effective Java”, este un HashSet extins ca să numere elementele adăugate:

JAVA
class ContorSet<E> extends HashSet<E> {
    int adaugate = 0;
    @Override public boolean add(E e) { adaugate++; return super.add(e); }
    @Override public boolean addAll(Collection<? extends E> c) {
        adaugate += c.size();
        return super.addAll(c);   // addAll moștenit apelează intern add()
    }
}
// addAll(List.of("a","b","c")) => adaugate == 6, nu 3

Rezultatul depinde de un detaliu intern al lui HashSet, pe care nu îl controlezi. Varianta prin compoziție nu are problema:

JAVA
class ContorSet<E> {
    private final Set<E> set = new HashSet<>();
    private int adaugate = 0;
    public boolean add(E e) { adaugate++; return set.add(e); }
    public boolean addAll(Collection<? extends E> c) {
        adaugate += c.size();
        return set.addAll(c);
    }
}

Alte avantaje ale compoziției: poți injecta dependențe diferite (exact ce face Spring cu constructor injection), poți înlocui comportamentul la rulare (șablonul Strategy) și poți testa cu mock-uri. Moștenirea rămâne potrivită când relația „este un” e reală și stabilă, iar părintele a fost proiectat pentru extindere, cum sunt clasele abstracte din framework-uri.

Ce urmărește intervievatorul: Intervievatorul verifică maturitatea în design. Un candidat bun dă un exemplu concret de problemă cauzată de moștenire.

20 Mid

Explică principiile SOLID cu exemple din Java.

Răspuns scurt: SOLID înseamnă Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation și Dependency Inversion. Sunt reguli de design care fac codul mai ușor de modificat și de testat, mai ales într-o aplicație Spring cu servicii și interfețe.

  • S, Single Responsibility: o clasă are un singur motiv să se schimbe. Un FacturaService care calculează, generează PDF și trimite email are trei motive; împarte-l în CalculFactura, GeneratorPdf, EmailSender.
  • O, Open/Closed: deschis pentru extindere, închis pentru modificare. În loc de un switch pe tipul de plată, care se modifică la fiecare tip nou, definești interfața Plata și adaugi implementări noi.
  • L, Liskov Substitution: un subtip trebuie să poată înlocui tipul de bază fără surprize. Exemplul clasic: Patrat extends Dreptunghi încalcă principiul, pentru că setLatime() pe un pătrat schimbă și lungimea, iar codul scris pentru dreptunghiuri nu mai funcționează.
  • I, Interface Segregation: mai multe interfețe mici în loc de una mare. O clasă care implementează doar citirea nu ar trebui să fie forțată să implementeze și sterge(), aruncând UnsupportedOperationException.
  • D, Dependency Inversion: modulele de nivel înalt depind de abstracții, nu de implementări concrete.
JAVA
public interface NotificareSender { void trimite(String catre, String text); }

@Service
public class ComandaService {
    private final NotificareSender sender;          // depinde de abstracție
    public ComandaService(NotificareSender sender) { this.sender = sender; }

    public void plaseaza(Comanda c) {
        // ... logică
        sender.trimite(c.email(), "Comanda a fost plasată");
    }
}

ComandaService nu știe dacă notificarea pleacă prin email, SMS sau un mock din test. Nu aplica SOLID mecanic, cu o interfață pentru fiecare clasă. Scopul e codul ușor de schimbat, nu numărul de abstracții.

Ce urmărește intervievatorul: Se verifică dacă poți lega principiile de cod real. Mulți candidați recită acronimul, dar nu pot explica Liskov sau Dependency Inversion cu un exemplu.

21 Mid

Cum scrii o clasă imuabilă în Java?

Răspuns scurt: Faci clasa final, toate câmpurile private final, le inițializezi doar în constructor, nu oferi setteri și faci copii defensive pentru câmpurile mutabile (liste, obiecte Date), atât la intrare, cât și la ieșire.

Un obiect imuabil nu își schimbă starea după construcție. Asta îl face sigur între thread-uri fără sincronizare, potrivit drept cheie în HashMap și ușor de înțeles. Pașii:

  • clasa este final (sau constructorul e privat), ca să nu poată fi extinsă de o subclasă mutabilă;
  • toate câmpurile sunt private final;
  • nu există setteri; „modificările” întorc obiecte noi;
  • câmpurile mutabile primite din exterior sunt copiate, iar cele expuse sunt copiate sau învelite read-only.
JAVA
public final class Rezervare {
    private final String client;
    private final LocalDate data;            // LocalDate e deja imuabil
    private final List<String> camere;

    public Rezervare(String client, LocalDate data, List<String> camere) {
        this.client = Objects.requireNonNull(client);
        this.data = Objects.requireNonNull(data);
        this.camere = List.copyOf(camere);   // copie defensivă, imuabilă (Java 10+)
    }

    public List<String> getCamere() { return camere; }   // deja imuabilă

    public Rezervare cuData(LocalDate nouaData) {
        return new Rezervare(client, nouaData, camere);  // obiect nou
    }
}

Fără List.copyOf, apelantul ar putea păstra referința la lista originală și ar putea modifica rezervarea din exterior. Pentru java.util.Date, care e mutabil, ar trebui new Date(d.getTime()); mai simplu e să folosești java.time, unde toate clasele sunt imuabile.

Exemple din JDK: String, wrapperii (Integer), BigDecimal, LocalDate. Records te scutesc de o bună parte din muncă, dar copiile defensive pentru liste tot trebuie făcute în constructorul compact.

Ce urmărește intervievatorul: Verifică dacă știi detaliul copiilor defensive. Răspunsul „pun final pe câmpuri” e incomplet dacă unul dintre câmpuri e o listă.

22 Senior

Ce design patterns ai folosit în Java și unde le întâlnești în Spring sau în JDK?

Răspuns scurt: Cele mai întâlnite sunt Singleton (bean-urile Spring), Factory, Builder, Strategy, Template Method (JdbcTemplate), Proxy (@Transactional) și Observer (evenimentele Spring). Contează să explici problema rezolvată, nu doar numele șablonului.

Un răspuns bun pornește din cod real. Iată șabloanele pe care le vei întâlni cel mai des:

  • Singleton: o singură instanță. În Spring, bean-urile sunt singleton implicit, deci rar scrii unul de mână. Dacă trebuie, varianta sigură între thread-uri este un enum sau idiomul „holder”, cu o clasă internă statică.
  • Builder: construiești obiecte cu mulți parametri opționali (HttpRequest.newBuilder(), @Builder din Lombok).
  • Factory: creare ascunsă în spatele unei metode (List.of(), LocalDate.of(), BeanFactory).
  • Strategy: algoritmi interschimbabili în spatele unei interfețe (Comparator; în Spring, injectezi un Map<String, Plata> și alegi implementarea după cheie).
  • Template Method: scheletul algoritmului fix, pașii variabili (JdbcTemplate, AbstractList).
  • Proxy: un obiect care învelește altul și adaugă comportament. Așa funcționează @Transactional, @Cacheable și @Async.
  • Observer: ApplicationEventPublisher cu @EventListener.
  • Decorator: BufferedInputStream peste FileInputStream.
JAVA
public enum ConfigGlobal {             // singleton sigur, inclusiv la serializare
    INSTANCE;
    private final Properties props = new Properties();
    public String get(String cheie) { return props.getProperty(cheie); }
}

@Service
class ProcesatorPlati {
    private final Map<String, Plata> strategii;   // Spring injectează bean-urile după nume
    ProcesatorPlati(Map<String, Plata> strategii) { this.strategii = strategii; }
    void plateste(String tip, BigDecimal suma) { strategii.get(tip).proceseaza(suma); }
}

La nivel senior se așteaptă să spui și când un șablon e exagerat: o ierarhie de fabrici pentru o singură implementare doar adaugă complexitate.

Ce urmărește intervievatorul: La senior, intervievatorul vrea legătura dintre șabloane și framework-urile folosite zilnic, plus judecata despre când nu le folosești.

Colecții și generice

23 Junior

Descrie ierarhia principală a colecțiilor din Java: List, Set, Queue și Map.

Răspuns scurt: List păstrează ordinea și permite duplicate, Set nu permite duplicate, Queue și Deque scot elementele într-o ordine definită (FIFO, LIFO sau prioritate), iar Map ține perechi cheie-valoare. Map nu extinde Collection.

Interfața de bază e Collection (care extinde Iterable), cu trei ramuri principale, plus Map separat:

  • List: secvență ordonată, cu acces după index și duplicate permise. Implementări: ArrayList (cea mai folosită), LinkedList, CopyOnWriteArrayList.
  • Set: elemente unice. HashSet (fără ordine garantată), LinkedHashSet (ordinea inserării), TreeSet (sortat, implementează SortedSet și NavigableSet).
  • Queue / Deque: cozi. ArrayDeque (stivă sau coadă rapidă, preferată în locul vechii clase Stack), PriorityQueue (heap după prioritate), plus cozile blocante din java.util.concurrent.
  • Map: chei unice asociate cu valori. HashMap, LinkedHashMap, TreeMap, ConcurrentHashMap.
JAVA
List<String> lista = new ArrayList<>(List.of("b", "a", "b"));   // [b, a, b]
Set<String> unice = new TreeSet<>(lista);                        // [a, b]
Deque<Integer> stiva = new ArrayDeque<>();
stiva.push(1); stiva.push(2);
System.out.println(stiva.pop());                                 // 2
Map<String, Integer> varste = new HashMap<>();
varste.put("Ana", 30);
varste.getOrDefault("Ion", 0);                                   // 0

Alegerea pornește de la întrebarea de business: am nevoie de ordine, de unicitate sau de căutare după cheie? Declară variabilele cu tipul interfeței (List<String> x = new ArrayList<>()), ca să poți schimba implementarea fără să modifici restul codului. Java 21 a adăugat SequencedCollection, cu getFirst(), getLast() și reversed() pentru colecțiile care au o ordine definită.

Ce urmărește intervievatorul: Verifică dacă ai o hartă mentală a colecțiilor și dacă alegi structura după nevoie. Faptul că Map nu e o Collection e un detaliu cerut des.

24 Junior

Care este diferența dintre ArrayList și LinkedList? Pe care o folosești de obicei?

Răspuns scurt: ArrayList folosește un array redimensionabil: acces după index în O(1) și adăugare la final în O(1) amortizat. LinkedList e o listă dublu înlănțuită: inserări O(1) doar dacă ești deja pe poziție. În practică, ArrayList e aproape mereu mai rapidă.

ArrayList ține elementele într-un array. Când se umple, alocă unul mai mare (cu aproximativ 50% mai mare) și copiază elementele.

  • get(i): O(1);
  • add(e) la final: O(1) amortizat;
  • add(0, e) sau remove(0): O(n), pentru că mută elementele.

LinkedList are noduri cu legături prev și next.

  • get(i): O(n), pentru că parcurge lista de la un capăt;
  • inserare sau ștergere la capete: O(1);
  • inserare la mijloc: O(1) doar dacă ai deja un ListIterator pe poziție; altfel O(n) pentru a ajunge acolo.

Teoria pare să favorizeze LinkedList la inserări, dar în practică ArrayList câștigă aproape mereu. Elementele unui array stau unul lângă altul în memorie și profită de cache-ul procesorului, iar System.arraycopy e foarte rapid. Fiecare nod din LinkedList e un obiect separat, cu două referințe în plus, deci consumă mai multă memorie și produce mai multe cache miss-uri.

JAVA
List<Integer> a = new ArrayList<>(10_000);   // capacitate inițială, evită redimensionări
for (int i = 0; i < 10_000; i++) a.add(i);
int x = a.get(5_000);                         // instant

Deque<Integer> coada = new ArrayDeque<>();     // pentru coadă sau stivă
coada.offerLast(1);
coada.pollFirst();

Ca regulă: ArrayList implicit, ArrayDeque când ai nevoie de o coadă sau o stivă. LinkedList rămâne justificată rar, de exemplu când ștergi multe elemente în timpul parcurgerii cu un iterator.

Ce urmărește intervievatorul: Intervievatorul vrea complexitățile, dar și realismul: candidații care spun că LinkedList e mai bună pentru inserări fără nicio nuanță pierd puncte.

25 Junior

Cum detectează un HashSet că un element este duplicat?

Răspuns scurt: HashSet este construit peste un HashMap: elementele sunt cheile. La add(), calculează hashCode() ca să găsească bucket-ul, apoi compară cu equals() elementele din acel bucket. Dacă un element egal există deja, add() întoarce false.

Intern, HashSet ține un HashMap<E, Object>, în care elementele sunt cheile și valoarea e un obiect fix (PRESENT). Așa că add(e) este de fapt map.put(e, PRESENT) == null.

Pașii la adăugare:

  • se calculează e.hashCode(), apoi indexul bucket-ului;
  • dacă bucket-ul e gol, elementul se adaugă;
  • dacă nu, se compară cu elementele din bucket: întâi hash-ul, apoi referința (==), apoi equals();
  • dacă unul dintre ele e egal, add întoarce false și setul rămâne neschimbat.
JAVA
record Punct(int x, int y) {}             // equals și hashCode generate

Set<Punct> puncte = new HashSet<>();
System.out.println(puncte.add(new Punct(1, 2)));  // true
System.out.println(puncte.add(new Punct(1, 2)));  // false, duplicat
System.out.println(puncte.size());                // 1

class PunctVechi { int x, y; PunctVechi(int x, int y) { this.x = x; this.y = y; } }
Set<PunctVechi> s2 = new HashSet<>();
s2.add(new PunctVechi(1, 2));
s2.add(new PunctVechi(1, 2));
System.out.println(s2.size());                    // 2: equals/hashCode din Object

Consecințe practice: dacă clasa ta nu suprascrie equals și hashCode, setul consideră diferite oricare două instanțe. Dacă un element se modifică după ce a fost pus în set, hash-ul lui se schimbă și elementul devine „pierdut”: contains dă false, iar remove nu îl mai găsește. TreeSet funcționează altfel: decide unicitatea prin compareTo sau prin Comparator, nu prin equals.

Ce urmărește intervievatorul: Verifică legătura dintre colecții și contractul equals/hashCode. Detaliul despre TreeSet care folosește compareTo e un bonus.

26 Junior

De ce apare ConcurrentModificationException când ștergi elemente dintr-o listă într-un for-each? Cum ștergi corect?

Răspuns scurt: For-each folosește un Iterator, care verifică un contor intern de modificări (modCount). Dacă modifici lista direct în timpul parcurgerii, iteratorul detectează schimbarea și aruncă excepția. Șterge prin iterator.remove() sau, din Java 8, cu removeIf().

Bucla for (String s : lista) este compilată într-un Iterator. Colecțiile din java.util sunt fail-fast: țin un contor modCount care crește la fiecare modificare structurală. Iteratorul își notează valoarea la creare și o compară la fiecare next(). Dacă a fost modificată lista direct, nu prin iterator, aruncă ConcurrentModificationException. Numele induce în eroare: nu e nevoie de mai multe thread-uri ca să apară.

JAVA
List<String> nume = new ArrayList<>(List.of("Ana", "Ion", "Ioana", "Dan"));

// GREȘIT: aruncă ConcurrentModificationException
// for (String n : nume) { if (n.startsWith("I")) nume.remove(n); }

// Corect 1: prin iterator
Iterator<String> it = nume.iterator();
while (it.hasNext()) {
    if (it.next().startsWith("I")) it.remove();
}

// Corect 2: Java 8+
nume.removeIf(n -> n.startsWith("I"));

// Corect 3: construiești o listă nouă
List<String> filtrate = nume.stream().filter(n -> !n.startsWith("I")).toList(); // Java 16+

Un detaliu care apare la întrebările „ce afișează”: dacă ștergi penultimul element, uneori excepția nu apare, pentru că hasNext() întoarce false înainte ca next() să facă verificarea. Comportamentul fail-fast este „best effort”, nu o garanție, deci nu te baza pe el ca pe un mecanism de corectitudine.

Colecțiile din java.util.concurrent (CopyOnWriteArrayList, ConcurrentHashMap) au iteratori weakly consistent: nu aruncă excepția, dar pot să nu reflecte modificările făcute în timpul parcurgerii.

Ce urmărește intervievatorul: Este o greșeală pe care aproape orice junior o face o dată. Intervievatorul vrea mecanismul (modCount) și cel puțin o soluție corectă.

27 Junior

Care este diferența dintre Comparable și Comparator?

Răspuns scurt: Comparable definește ordinea naturală a unei clase, prin metoda compareTo() implementată în clasa însăși. Comparator este un obiect separat, cu metoda compare(), care definește o ordine externă. Poți avea mai mulți comparatori pentru aceeași clasă.

Comparable se implementează în clasă când există o singură ordine evidentă: String (alfabetic), Integer (numeric), LocalDate (cronologic). TreeSet, TreeMap și Collections.sort() o folosesc implicit.

Comparator e util când vrei mai multe criterii sau nu poți modifica clasa. Din Java 8, comparatorii se compun ușor:

JAVA
record Angajat(String nume, String departament, int salariu) implements Comparable<Angajat> {
    @Override
    public int compareTo(Angajat o) {
        return nume.compareTo(o.nume);           // ordinea naturală: după nume
    }
}

List<Angajat> lista = new ArrayList<>(List.of(
    new Angajat("Ion", "IT", 9000),
    new Angajat("Ana", "HR", 7000),
    new Angajat("Dan", "IT", 9000)));

Collections.sort(lista);                          // după nume

lista.sort(Comparator.comparing(Angajat::departament)
        .thenComparing(Angajat::salariu, Comparator.reverseOrder())
        .thenComparing(Angajat::nume));           // departament, salariu desc, nume

Reguli de bun-simț:

  • compareTo întoarce negativ, zero sau pozitiv. Nu scrie return this.salariu - o.salariu, pentru că scăderea poate da overflow la valori mari; folosește Integer.compare(a, b);
  • e recomandat ca compareTo să fie consecvent cu equals. TreeSet consideră duplicate elementele cu compareTo == 0, chiar dacă equals spune că sunt diferite, deci poți pierde elemente fără să-ți dai seama;
  • pentru valori null, folosește Comparator.nullsFirst(...) sau nullsLast(...).

Ce urmărește intervievatorul: Verifică dacă știi când folosești fiecare și dacă scrii comparatori moderni. Bug-ul cu scăderea și overflow-ul e un detaliu care impresionează.

28 Junior

Scrie o funcție care primește un text și întoarce de câte ori apare fiecare cuvânt.

Răspuns scurt: Împarți textul în cuvinte, normalizezi (litere mici, fără punctuație) și numeri într-un Map<String, Integer> cu merge(), sau cu streams și Collectors.groupingBy(..., counting()). Complexitatea este O(n) în numărul de cuvinte.

Varianta clasică, ușor de explicat la tablă:

JAVA
import java.util.*;

public class Frecventa {
    public static Map<String, Integer> numaraCuvinte(String text) {
        Map<String, Integer> frecvente = new HashMap<>();
        if (text == null || text.isBlank()) return frecvente;

        for (String cuvant : text.toLowerCase().split("[^\\p{L}\\p{N}]+")) {
            if (cuvant.isEmpty()) continue;
            frecvente.merge(cuvant, 1, Integer::sum);   // pune 1 sau adună 1
        }
        return frecvente;
    }

    public static void main(String[] args) {
        System.out.println(numaraCuvinte("Ana are mere. Ana are și pere!"));
        // {ana=2, are=2, mere=1, și=1, pere=1} (ordinea din HashMap nu e garantată)
    }
}

Expresia regulată [^\p{L}\p{N}]+ separă după orice nu e literă sau cifră Unicode, deci funcționează și cu diacritice. Un \W+ simplu ar tăia cuvintele la „ș” sau „ț”, pentru că implicit \w acoperă doar ASCII. merge evită clasicul if (map.containsKey(...)).

Varianta cu streams:

JAVA
Map<String, Long> f = Arrays.stream(text.toLowerCase().split("[^\\p{L}\\p{N}]+"))
        .filter(w -> !w.isEmpty())
        .collect(Collectors.groupingBy(w -> w, Collectors.counting()));

Ce mai poți discuta ca să arăți maturitate: pentru rezultat sortat după frecvență, sortezi entrySet() cu Map.Entry.comparingByValue().reversed(); pentru ordinea apariției, folosești LinkedHashMap; pentru fișiere foarte mari, citești linie cu linie cu Files.lines() în loc să încarci tot textul în memorie. Complexitatea e O(n) timp și O(k) memorie, unde k e numărul de cuvinte distincte.

Ce urmărește intervievatorul: Este un exercițiu de live coding foarte comun. Se urmăresc cazurile limită (null, punctuație, majuscule) și folosirea idiomatică a lui Map.

29 Mid

Cum funcționează intern un HashMap?

Răspuns scurt: HashMap ține un array de bucket-uri. Indexul se calculează din hashCode-ul cheii. Coliziunile se țin într-o listă înlănțuită, transformată din Java 8 în arbore roșu-negru când depășește 8 elemente. La depășirea pragului de încărcare (0,75), array-ul se dublează și elementele se redistribuie.

Structura de bază este un array Node<K,V>[] table, cu capacitate putere a lui 2 (implicit 16).

La put(k, v):

  • se calculează hash = h ^ (h >>> 16), unde h = k.hashCode(). Amestecarea biților de sus cu cei de jos reduce coliziunile;
  • indexul este hash & (n - 1), echivalentul unui modulo, pentru că n e putere a lui 2;
  • dacă bucket-ul e gol, se pune nodul; dacă nu, se parcurge lanțul și se compară hash-ul și equals(). Cheie existentă înseamnă că se înlocuiește valoarea; altfel nodul se adaugă la final;
  • dacă un lanț ajunge la 8 noduri și tabela are cel puțin 64 de bucket-uri, lanțul devine un arbore roșu-negru (treeify, din Java 8), deci căutarea în cel mai rău caz scade de la O(n) la O(log n). Dacă tabela e mai mică, se face întâi resize;
  • când size > capacitate * loadFactor (implicit 0,75), tabela se dublează (resize) și nodurile se redistribuie.
JAVA
Map<String, Integer> m = new HashMap<>(64);   // capacitate inițială dacă știi volumul
m.put("a", 1);
m.put(null, 0);          // HashMap acceptă o cheie null (bucket 0)
m.get("a");              // O(1) în medie

Ce trebuie să știi pentru interviu:

  • operațiile sunt O(1) în medie, cu condiția unui hashCode bine distribuit. Un hashCode care întoarce mereu aceeași valoare transformă totul într-un singur bucket;
  • resize-ul e costisitor, de aceea setezi capacitatea inițială când știi câte elemente vei avea;
  • ordinea de iterare nu e garantată și se poate schimba după resize;
  • HashMap nu e thread-safe; pentru acces concurent folosești ConcurrentHashMap.

Ce urmărește intervievatorul: Este întrebarea de mid prin excelență. Intervievatorul urmărește bucket-uri, coliziuni, rolul lui equals, resize și treeify din Java 8.

30 Mid

Când alegi HashMap, LinkedHashMap sau TreeMap? Cum implementezi un cache LRU simplu?

Răspuns scurt: HashMap nu garantează ordinea și e cel mai rapid. LinkedHashMap păstrează ordinea inserării sau a accesului. TreeMap ține cheile sortate, cu operații O(log n). Un cache LRU simplu se face cu LinkedHashMap în modul access-order, suprascriind removeEldestEntry().

  • HashMap: O(1) în medie, fără ordine. Alegerea implicită.
  • LinkedHashMap: aproape la fel de rapid, dar ține o listă dublu înlănțuită prin intrări. Iterarea respectă ordinea inserării sau, cu accessOrder = true, ordinea ultimei accesări. Util când răspunsul JSON trebuie să păstreze ordinea cheilor.
  • TreeMap: arbore roșu-negru, O(log n), chei sortate natural sau după un Comparator. Are metode de navigare: firstKey(), floorKey(), headMap(), subMap(). Nu acceptă cheie null cu ordinea naturală.

Exemplu pentru TreeMap: găsești tariful valabil la o anumită dată.

JAVA
TreeMap<LocalDate, BigDecimal> tarife = new TreeMap<>();
tarife.put(LocalDate.of(2024, 1, 1), new BigDecimal("10"));
tarife.put(LocalDate.of(2024, 7, 1), new BigDecimal("12"));
BigDecimal t = tarife.floorEntry(LocalDate.of(2024, 9, 15)).getValue(); // 12

Cache-ul LRU (Least Recently Used) elimină elementul folosit cel mai demult:

JAVA
class LruCache<K, V> extends LinkedHashMap<K, V> {
    private final int capacitate;
    LruCache(int capacitate) {
        super(16, 0.75f, true);           // true = ordine după acces
        this.capacitate = capacitate;
    }
    @Override
    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
        return size() > capacitate;       // se apelează după fiecare put
    }
}

Fiecare get mută intrarea la final, iar removeEldestEntry elimină capul listei când depășești capacitatea. Clasa nu e thread-safe. În producție, pentru un cache real, ai folosi o bibliotecă precum Caffeine, cu expirare și statistici, eventual prin abstracția @Cacheable din Spring.

Ce urmărește intervievatorul: Se verifică dacă alegi structura după cerințe. Implementarea LRU cu LinkedHashMap e un exercițiu clasic la interviurile de mid.

31 Mid

Ce este type erasure la generice și ce înseamnă PECS (? extends și ? super)?

Răspuns scurt: Genericele sunt verificate doar la compilare. La rulare, informația de tip este ștearsă (type erasure), deci List<String> și List<Integer> sunt aceeași clasă. PECS înseamnă Producer Extends, Consumer Super: ? extends T pentru surse din care citești, ? super T pentru destinații în care scrii.

Type erasure: genericele au apărut în Java 5 și au fost proiectate compatibile cu codul vechi. Compilatorul verifică tipurile, inserează cast-uri și apoi șterge parametrii de tip. Consecințe:

  • nu poți scrie new T(), new T[10] sau obj instanceof List<String>;
  • nu poți avea două overload-uri m(List<String>) și m(List<Integer>), pentru că au aceeași semnătură după ștergere;
  • dacă ai nevoie de tip la rulare, îl transmiți explicit, de exemplu Class<T> tip (cum face Jackson cu TypeReference).

Wildcard-uri și PECS. List<Integer> nu este un subtip al lui List<Number>, altfel ai putea adăuga un Double într-o listă de Integer. Wildcard-urile rezolvă flexibilitatea:

JAVA
static double suma(List<? extends Number> numere) {   // producer: doar citești
    double s = 0;
    for (Number n : numere) s += n.doubleValue();
    // numere.add(1);  // nu compilează: nu știi exact tipul elementelor
    return s;
}

static void adaugaNumere(List<? super Integer> dest) { // consumer: doar scrii
    dest.add(1);
    dest.add(2);
    // Integer x = dest.get(0); // nu compilează, primești doar Object
}

suma(List.of(1, 2, 3));                  // List<Integer>
suma(List.of(1.5, 2.5));                 // List<Double>
adaugaNumere(new ArrayList<Number>());
adaugaNumere(new ArrayList<Object>());

Exemplul din JDK: Collections.copy(List<? super T> dest, List<? extends T> src). Dacă un parametru e și sursă, și destinație, nu folosești wildcard, ci List<T>. Wildcard-urile se pun pe parametri, nu pe tipurile returnate.

Ce urmărește intervievatorul: Este o întrebare de mid care separă candidații care au scris API-uri generice de cei care doar le-au folosit. Greșeala frecventă: crezi că List<Integer> e un List<Number>.

32 Mid

Care este diferența dintre List.of(), Arrays.asList() și Collections.unmodifiableList()?

Răspuns scurt: List.of() (Java 9) creează o listă complet imuabilă, care nu acceptă null. Arrays.asList() întoarce o listă de dimensiune fixă, legată de array: set() merge, add() nu. Collections.unmodifiableList() e o vedere read-only peste o listă care se poate schimba în continuare.

Toate trei par „liste care nu se modifică”, dar se comportă diferit.

JAVA
String[] arr = {"a", "b"};
List<String> fixa = Arrays.asList(arr);
fixa.set(0, "x");              // OK, modifică și array-ul: arr[0] e acum "x"
// fixa.add("c");              // UnsupportedOperationException

List<String> imuabila = List.of("a", "b");
// imuabila.set(0, "x");       // UnsupportedOperationException
// List.of("a", null);         // NullPointerException
// imuabila.contains(null);    // NullPointerException

List<String> sursa = new ArrayList<>(List.of("a"));
List<String> vedere = Collections.unmodifiableList(sursa);
sursa.add("b");
System.out.println(vedere);    // [a, b]: vederea reflectă modificările
// vedere.add("c");            // UnsupportedOperationException

List<String> copie = List.copyOf(sursa);   // Java 10: copie imuabilă, independentă

Rezumat:

  • Arrays.asList: dimensiune fixă, permite set și null, partajează memoria cu array-ul. Atenție la Arrays.asList(new int[]{1,2}): întoarce o List<int[]> cu un singur element;
  • List.of și List.copyOf: imuabile, interzic null, potrivite pentru constante și valori returnate;
  • Collections.unmodifiableList: protejează lista internă de apelanți, dar nu de proprietarul ei;
  • Stream.toList() (Java 16) întoarce o listă nemodificabilă, care acceptă null, spre deosebire de List.of.

Când ai nevoie de o listă modificabilă pornind de la valori fixe: new ArrayList<>(List.of(...)).

Ce urmărește intervievatorul: Verifică atenția la detalii. Bug-urile cu UnsupportedOperationException în producție apar exact din confuzia dintre aceste metode.

33 Senior

Care este diferența dintre HashMap, Hashtable, Collections.synchronizedMap() și ConcurrentHashMap în context multithreading?

Răspuns scurt: HashMap nu e thread-safe. Hashtable și synchronizedMap pun un singur lacăt pe toată mapa, deci thread-urile se blochează reciproc. ConcurrentHashMap permite citiri fără lacăt și scrieri sincronizate la nivel de bucket, plus operații atomice precum computeIfAbsent și merge.

Folosit din mai multe thread-uri fără sincronizare, un HashMap poate pierde intrări sau poate ajunge într-o stare inconsistentă. În Java 7 și mai vechi, un resize concurent putea chiar crea un ciclu în lista unui bucket și bloca un thread într-o buclă infinită.

  • Hashtable: clasă veche, toate metodele synchronized. Nu acceptă null. Nu se mai folosește în cod nou.
  • Collections.synchronizedMap(map): un wrapper cu un singur lacăt. E corect pentru operații individuale, dar iterarea și operațiile compuse cer sincronizare manuală pe obiectul map.
  • ConcurrentHashMap: în Java 8+, citirile nu iau lacăt, iar scrierile folosesc CAS (compare-and-swap) pe bucket-urile goale și synchronized doar pe primul nod al bucket-ului afectat. Nu acceptă chei sau valori null. Iteratorii sunt weakly consistent și nu aruncă ConcurrentModificationException.

Partea cea mai importantă e atomicitatea operațiilor compuse:

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

// GREȘIT: două operații separate, race condition între get și put
Integer v = vizite.get("home");
vizite.put("home", v == null ? 1 : v + 1);

// CORECT: atomic
vizite.merge("home", 1, Integer::sum);

Map<String, List<String>> grupuri = new ConcurrentHashMap<>();
grupuri.computeIfAbsent("admin", k -> new CopyOnWriteArrayList<>()).add("ana");

Chiar și cu o colecție thread-safe, secvența „verifică, apoi acționează” nu e atomică. Funcția din computeIfAbsent trebuie să fie scurtă și să nu modifice aceeași mapă, pentru că rulează ținând lacătul bucket-ului. size() este doar o estimare în timpul scrierilor concurente.

Ce urmărește intervievatorul: La senior, intervievatorul vrea să audă de operațiile compuse atomice. Mulți candidați cred că o colecție thread-safe face automat tot codul corect.

Excepții

34 Junior

Care este diferența dintre excepțiile checked și unchecked? Cum arată ierarhia Throwable?

Răspuns scurt: Excepțiile checked (IOException, SQLException) trebuie prinse sau declarate cu throws, compilatorul verifică asta. Cele unchecked (RuntimeException și subclasele ei, plus Error) nu sunt verificate. Throwable are două ramuri: Exception și Error.

Ierarhia:

  • Throwable
  • Error: probleme grave ale JVM-ului, din care de obicei nu îți revii (OutOfMemoryError, StackOverflowError). Nu se prind în codul obișnuit.
  • Exception
  • excepții checked: IOException, SQLException, InterruptedException. Compilatorul te obligă să le tratezi sau să le declari.
  • RuntimeException și subclasele ei, excepții unchecked: NullPointerException, IllegalArgumentException, IllegalStateException, IndexOutOfBoundsException.
JAVA
// checked: trebuie tratată sau declarată
public String citeste(Path p) throws IOException {
    return Files.readString(p);
}

// unchecked: semnalează o greșeală de programare sau o stare invalidă
public void setVarsta(int v) {
    if (v < 0) throw new IllegalArgumentException("Vârsta nu poate fi negativă: " + v);
    this.varsta = v;
}

Ideea inițială era: checked pentru situații din care apelantul se poate recupera (fișier lipsă, rețea căzută), unchecked pentru bug-uri (argument invalid, null neașteptat). În practică, excepțiile checked se combină prost cu lambda-urile și cu straturile multiple ale unei aplicații, așa că framework-urile moderne, Spring inclusiv, folosesc aproape doar unchecked. Spring traduce SQLException într-o ierarhie unchecked, DataAccessException.

Un detaliu util pentru Spring: implicit, @Transactional face rollback doar pentru excepții unchecked și Error, nu pentru cele checked.

Ce urmărește intervievatorul: Este întrebarea de bază despre excepții. Intervievatorul vrea ierarhia corectă și motivul pentru care există cele două categorii.

35 Junior

Ce este try-with-resources și de ce e mai bun decât finally pentru închiderea resurselor?

Răspuns scurt: Try-with-resources (Java 7) închide automat, în ordine inversă, orice resursă care implementează AutoCloseable, chiar dacă apare o excepție. E mai scurt decât finally și păstrează excepția originală, adăugând erorile de la close() ca suppressed.

Varianta veche, cu finally, e lungă și are o capcană:

JAVA
BufferedReader br = null;
try {
    br = new BufferedReader(new FileReader("date.txt"));
    return br.readLine();
} finally {
    if (br != null) br.close();   // dacă și close() aruncă, excepția originală se pierde
}

Dacă readLine() aruncă o excepție, iar apoi și close() aruncă, a doua o înlocuiește pe prima și pierzi cauza reală a problemei.

Cu try-with-resources:

JAVA
try (BufferedReader br = Files.newBufferedReader(Path.of("date.txt"));
     Connection con = dataSource.getConnection();
     PreparedStatement ps = con.prepareStatement("SELECT 1")) {
    return br.readLine();
} catch (IOException | SQLException e) {
    throw new IllegalStateException("Nu am putut procesa fișierul", e);
}

Ce garantează:

  • resursele se închid automat, în ordinea inversă a declarării (ps, apoi con, apoi br);
  • dacă blocul aruncă și close() aruncă la rândul lui, excepția principală e păstrată, iar cea de la close() se poate citi cu e.getSuppressed();
  • funcționează cu orice clasă care implementează AutoCloseable, inclusiv clasele tale.

Din Java 9 poți folosi și o variabilă deja declarată, dacă e efectiv finală: try (br) { ... }. Resursele uitate deschise, mai ales conexiunile JDBC, epuizează pool-ul de conexiuni și blochează aplicația, deci acesta e un detaliu cu impact real în producție.

Ce urmărește intervievatorul: Verifică dacă scrii cod care nu lasă resurse deschise. Detaliul despre excepțiile suppressed arată că înțelegi de ce a apărut construcția.

36 Junior

Ce întoarce metoda următoare: try { return 1; } finally { return 2; }? Dar dacă finally doar modifică variabila returnată?

Răspuns scurt: Întoarce 2: un return din finally înlocuiește valoarea din try și chiar înghite o excepție aruncată în try. Dacă finally doar modifică o variabilă primitivă după return, valoarea deja calculată nu se schimbă.

JAVA
static int a() {
    try {
        return 1;
    } finally {
        return 2;                 // câștigă finally
    }
}

static int b() {
    int x = 1;
    try {
        return x;                 // valoarea 1 e salvată acum
    } finally {
        x = 99;                   // nu afectează rezultatul
    }
}

static List<String> c() {
    List<String> l = new ArrayList<>();
    try {
        return l;                 // se salvează referința
    } finally {
        l.add("din finally");     // obiectul e modificat, se vede la apelant
    }
}

static int d() {
    try {
        throw new RuntimeException("eroare");
    } finally {
        return 0;                 // excepția dispare complet
    }
}

Rezultate: a() întoarce 2, b() întoarce 1, c() întoarce o listă care conține „din finally”, iar d() întoarce 0 fără nicio excepție.

Explicația: la return x, valoarea expresiei este evaluată și salvată înainte să ruleze finally. Pentru un primitiv, e o copie, deci modificările ulterioare nu contează. Pentru un obiect, e copiată referința, deci modificarea obiectului se vede. Un return sau un throw din finally înlocuiește complet rezultatul blocului try.

Concluzia practică: nu pune return în finally. Compilatorul acceptă codul, iar unele unelte de analiză statică îl semnalează, tocmai pentru că poate ascunde excepții și face depanarea foarte grea.

Ce urmărește intervievatorul: Este o întrebare-capcană de tip „ce afișează”. Diferența dintre primitive și referințe în finally arată dacă înțelegi cu adevărat cum se evaluează return.

37 Junior

Care este diferența dintre throw și throws? Cum creezi o excepție proprie?

Răspuns scurt: throw aruncă efectiv o instanță de excepție, în corpul metodei. throws apare în semnătura metodei și declară ce excepții checked poate arunca. O excepție proprie extinde RuntimeException (sau Exception, pentru checked) și păstrează mesajul și cauza.

JAVA
public Produs gaseste(long id) throws ProdusNegasitException {   // throws: declarație
    return repo.findById(id)
               .orElseThrow(() -> new ProdusNegasitException(id)); // throw: acțiune
}

O excepție proprie e utilă când vrei să exprimi o situație de business pe care apelantul o poate trata distinct, de exemplu să o transforme într-un răspuns HTTP 404.

JAVA
public class ProdusNegasitException extends RuntimeException {
    private final long produsId;

    public ProdusNegasitException(long produsId) {
        super("Produsul cu id " + produsId + " nu există");
        this.produsId = produsId;
    }

    public ProdusNegasitException(String mesaj, Throwable cauza) {
        super(mesaj, cauza);          // păstrează excepția originală
        this.produsId = -1;
    }

    public long getProdusId() { return produsId; }
}

Recomandări:

  • numele se termină în Exception și descrie problema (StocInsuficientException), nu locul unde a apărut;
  • oferă constructori cu mesaj și cu cauză, ca să nu pierzi stack trace-ul original când învelești o excepție tehnică;
  • adaugă câmpuri utile pentru tratare (ID-ul, codul de eroare), nu doar text;
  • nu crea câte o excepție pentru fiecare metodă. Câteva excepții de domeniu, plus cele standard (IllegalArgumentException, IllegalStateException), acoperă majoritatea cazurilor.

Dacă excepția e unchecked, throws nu e obligatoriu, dar poate fi scris pentru documentare, iar mulți preferă tagul @throws din Javadoc.

Ce urmărește intervievatorul: Verifică vocabularul de bază și dacă știi să proiectezi o excepție utilă. Greșeala frecventă e excepția fără constructor cu cauză.

38 Mid

Care sunt bunele practici în tratarea excepțiilor? Ce greșeli vezi des la code review?

Răspuns scurt: Prinde doar ce poți trata, nu înghiți excepțiile, păstrează cauza la wrapping, loghează o singură dată, la granița potrivită, și nu folosi excepțiile pentru controlul fluxului. Cea mai frecventă greșeală este un catch gol sau un catch (Exception e) care doar afișează.

Greșeli tipice și varianta corectă:

JAVA
// 1. Excepția înghițită: problema dispare fără urmă
try { trimiteEmail(); } catch (Exception e) { }

// 2. Cauza pierdută
catch (SQLException e) { throw new RuntimeException("Eroare DB"); }
// corect:
catch (SQLException e) { throw new DataAccessFailure("Nu am putut salva comanda " + id, e); }

// 3. Logare dublă: aceeași eroare apare de 3 ori în log, la fiecare strat
catch (IOException e) { log.error("eroare", e); throw e; }

// 4. Excepții pentru controlul fluxului
try { Integer.parseInt(s); return true; } catch (NumberFormatException e) { return false; }

Principii:

  • prinde specific: catch (Exception e) prinde și bug-uri pe care nu le anticipai (de exemplu un NPE), pe care le-ai trata greșit ca pe o eroare „cunoscută”;
  • tratează sau propagă, nu ambele. Fie rezolvi situația (retry, valoare implicită, mesaj pentru utilizator), fie o lași să urce;
  • loghează la graniță: într-o aplicație Spring, un @RestControllerAdvice central loghează și transformă excepțiile în răspunsuri HTTP. Straturile de jos doar aruncă;
  • mesaje cu context: ID-uri, valori, ce operație a eșuat. „Eroare” nu ajută pe nimeni la 3 noaptea;
  • nu prinde Throwable sau Error, cu excepții rare (de exemplu la granița unui thread, ca să loghezi înainte de oprire);
  • dacă prinzi InterruptedException, refă flag-ul: Thread.currentThread().interrupt().

Excepțiile au un cost: construirea stack trace-ului e relativ scumpă, deci nu le folosi pentru situații normale, cum e validarea unui input care des e invalid.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă experiență reală de code review. Candidații buni dau exemple concrete de anti-patterns și explică de ce sunt periculoase.

39 Mid

Cum ai depana un NullPointerException apărut în producție?

Răspuns scurt: Pornești de la stack trace: linia exactă și, din Java 14+, mesajul care spune ce referință era null. Reproduci cu datele din log, afli de unde vine valoarea lipsă și repari cauza (validare, Optional, valori implicite), nu doar simptomul, apoi adaugi un test.

Un proces structurat, pe care îl poți povesti la interviu:

  • Citește stack trace-ul de sus în jos, până la primul cadru din codul tău. Acolo e linia unde s-a dereferențiat null. Dacă excepția e învelită, caută secțiunea Caused by:.
  • Folosește mesajele Helpful NPE (JEP 358, introduse în Java 14 și active implicit din Java 15): în loc de un simplu NullPointerException, primești ceva de genul Cannot invoke "String.length()" because the return value of "Client.getEmail()" is null. Pe o linie ca comanda.getClient().getAdresa().getOras() afli exact care verigă lipsea.
  • Corelează cu logurile: ID-ul cererii (correlation ID), datele de intrare, utilizatorul. De multe ori null-ul vine dintr-un câmp opțional din baza de date, dintr-un JSON fără o cheie sau dintr-un apel extern care a eșuat.
  • Reprodu local cu aceleași date și scrie un test care pică.
  • Repară cauza: validează la intrare (@NotNull, Objects.requireNonNull cu mesaj), întoarce Optional din metodele care pot să nu găsească nimic, inițializează colecțiile ca liste goale, nu null.
JAVA
public Comanda(Client client, List<Linie> linii) {
    this.client = Objects.requireNonNull(client, "client este obligatoriu");
    this.linii = linii == null ? List.of() : List.copyOf(linii);
}

Ce nu faci: un if (x != null) pus peste tot fără să înțelegi de ce valoarea lipsește. Asta mută eroarea mai departe și produce date incomplete în tăcere. Adaugă, în schimb, testul de regresie, ca bug-ul să nu revină.

Ce urmărește intervievatorul: Verifică metoda de depanare, nu doar cunoștințele. Un candidat bun pomenește stack trace-ul, Helpful NPE, logurile, reproducerea și testul de regresie.

40 Mid

Cum gestionezi excepțiile checked în interiorul unui lambda sau al unui stream?

Răspuns scurt: Interfețele funcționale standard (Function, Consumer) nu declară excepții checked, deci codul nu compilează dacă lambda-ul aruncă una. Soluțiile: prinzi excepția în lambda și o învelești într-una unchecked (de exemplu UncheckedIOException), extragi o metodă ajutătoare sau folosești o buclă for.

JAVA
List<Path> fisiere = List.of(Path.of("a.txt"), Path.of("b.txt"));

// Nu compilează: Files.readString aruncă IOException
// fisiere.stream().map(Files::readString).toList();

Varianta 1: învelești într-o excepție unchecked, cu cauza păstrată.

JAVA
List<String> continut = fisiere.stream()
        .map(p -> {
            try {
                return Files.readString(p);
            } catch (IOException e) {
                throw new UncheckedIOException("Nu pot citi " + p, e);
            }
        })
        .toList();

Varianta 2: o metodă ajutătoare care păstrează stream-ul lizibil.

JAVA
@FunctionalInterface
interface ThrowingFunction<T, R> { R apply(T t) throws Exception; }

static <T, R> Function<T, R> unchecked(ThrowingFunction<T, R> f) {
    return t -> {
        try { return f.apply(t); }
        catch (RuntimeException e) { throw e; }
        catch (Exception e) { throw new RuntimeException(e); }
    };
}

fisiere.stream().map(unchecked(Files::readString)).toList();

Varianta 3: dacă vrei să continui procesarea și să colectezi erorile, întorci un rezultat explicit (un record Rezultat cu valoare sau eroare) în loc să arunci.

Alegerea depinde de ce vrei să se întâmple: oprire la prima eroare (variantele 1 și 2), procesare completă cu raport de erori (varianta 3) sau o simplă buclă for, perfect acceptabilă când logica de tratare e complexă. Nu prinde excepția doar ca să întorci null, pentru că mută problema mai departe în pipeline.

Ce urmărește intervievatorul: E o problemă reală din codul Java modern. Intervievatorul urmărește dacă păstrezi cauza și dacă te gândești la comportamentul dorit la eroare.

Java 8+: lambda, streams, Optional

41 Junior

Ce este o expresie lambda și ce este o interfață funcțională?

Răspuns scurt: O interfață funcțională are exact o metodă abstractă, de exemplu Runnable sau Comparator. O expresie lambda este o implementare scurtă, anonimă, a acelei metode. Adnotarea @FunctionalInterface cere compilatorului să verifice regula.

Înainte de Java 8, ca să transmiți un comportament scriai o clasă anonimă:

JAVA
Collections.sort(nume, new Comparator<String>() {
    @Override
    public int compare(String a, String b) { return a.length() - b.length(); }
});

Cu lambda, aceeași logică devine:

JAVA
nume.sort((a, b) -> Integer.compare(a.length(), b.length()));

O lambda se poate folosi oriunde se așteaptă o interfață funcțională, adică o interfață cu o singură metodă abstractă. Metodele default și static nu se pun la socoteală.

JAVA
@FunctionalInterface
interface Validator<T> {
    boolean valid(T valoare);
    default Validator<T> si(Validator<T> altul) { return v -> valid(v) && altul.valid(v); }
}

Validator<String> nenul = s -> s != null;
Validator<String> scurt = s -> s.length() <= 20;
System.out.println(nenul.si(scurt).valid("Ana"));   // true

Reguli de reținut:

  • o lambda poate folosi variabile locale din exterior doar dacă sunt effectively final, adică nu sunt modificate după inițializare. Motivul: lambda capturează valoarea, nu variabila, și poate rula mai târziu, eventual pe alt thread;
  • this într-o lambda înseamnă instanța clasei în care e scrisă, nu lambda însăși, spre deosebire de clasele anonime;
  • intern, lambda-urile sunt implementate prin invokedynamic, nu prin clase anonime generate la compilare.

Lambda-urile stau la baza Stream API, a lui Optional, a lui CompletableFuture și a multor API-uri din Spring.

Ce urmărește intervievatorul: Verifică înțelegerea legăturii dintre lambda și interfețe. Regula „effectively final” și motivul ei sunt întrebate des ca follow-up.

42 Junior

Care sunt interfețele funcționale standard din java.util.function și când folosești fiecare?

Răspuns scurt: Cele de bază sunt Function<T,R> (transformă), Predicate<T> (testează, întoarce boolean), Consumer<T> (consumă, nu întoarce nimic), Supplier<T> (produce o valoare fără parametri) și BiFunction sau UnaryOperator pentru variante cu doi parametri sau același tip.

Pachetul java.util.function acoperă majoritatea nevoilor, deci rar ai nevoie de interfețe proprii:

  • Function<T, R>: R apply(T t). Transformare: Function<String, Integer> lungime = String::length;
  • Predicate<T>: boolean test(T t). Filtrare: Predicate<String> gol = String::isBlank;
  • Consumer<T>: void accept(T t). Efect, de exemplu afișare sau salvare: Consumer<String> afiseaza = System.out::println;
  • Supplier<T>: T get(). Creare leneșă: Supplier<List<String>> fabrica = ArrayList::new;
  • UnaryOperator<T> și BinaryOperator<T>: cazuri speciale ale lui Function, cu același tip la intrare și ieșire.
  • BiFunction<T, U, R>, BiConsumer<T, U>, BiPredicate<T, U>: variante cu doi parametri.
  • Variante pentru primitive, care evită boxing-ul: IntPredicate, ToIntFunction<T>, IntUnaryOperator, IntSupplier.

Se compun ușor:

JAVA
Predicate<String> nenul = Objects::nonNull;
Predicate<String> email = nenul.and(s -> s.contains("@")).and(s -> !s.isBlank());

Function<String, String> curata = String::trim;
Function<String, String> normalizeaza = curata.andThen(String::toLowerCase);

System.out.println(email.test(" ana@x.ro "));          // true
System.out.println(normalizeaza.apply("  ANA@X.RO ")); // ana@x.ro

Supplier e important pentru evaluarea leneșă: optional.orElseGet(() -> calculScump()) apelează funcția doar dacă e nevoie, spre deosebire de orElse(calculScump()), care o apelează mereu. La fel, log.debug("...", () -> ...) sau Objects.requireNonNull(x, () -> mesaj) construiesc mesajul doar când trebuie.

Ce urmărește intervievatorul: Verifică dacă știi vocabularul standard și nu reinventezi interfețe. Diferența orElse/orElseGet, adusă de Supplier, e un follow-up frecvent.

43 Junior

Care este diferența dintre operațiile intermediare și cele terminale într-un Stream? Ce înseamnă că stream-urile sunt lazy?

Răspuns scurt: Operațiile intermediare (filter, map, sorted) întorc un nou stream și nu execută nimic. Operațiile terminale (collect, forEach, count, findFirst) declanșează procesarea. Lazy înseamnă că elementele trec pe rând prin tot pipeline-ul și doar cât e nevoie.

Un stream e un pipeline: o sursă, zero sau mai multe operații intermediare și exact o operație terminală. Fără operație terminală, nu se întâmplă nimic.

JAVA
List<String> nume = List.of("Ana", "Bogdan", "Cristina", "Dan", "Elena");

Stream<String> s = nume.stream()
        .filter(n -> { System.out.println("filter " + n); return n.length() > 3; })
        .map(n -> { System.out.println("map " + n); return n.toUpperCase(); });
// nimic afișat încă

Optional<String> primul = s.findFirst();
// filter Ana
// filter Bogdan
// map Bogdan
System.out.println(primul.get());   // BOGDAN

Observă două lucruri. Elementele nu trec întâi toate prin filter, apoi toate prin map: fiecare element parcurge întregul lanț. Și procesarea se oprește după „Bogdan”, pentru că findFirst e o operație short-circuiting. „Cristina”, „Dan” și „Elena” nu sunt atinse deloc. Același lucru face anyMatch, limit sau takeWhile.

Excepție parțială: operațiile stateful, precum sorted() și distinct(), trebuie să vadă toate elementele înainte să emită ceva.

Alte reguli:

  • un stream se poate consuma o singură dată; a doua operație terminală aruncă IllegalStateException;
  • un stream nu modifică sursa;
  • lambda-urile din filter și map nu ar trebui să aibă efecte secundare. Pentru efecte există forEach, iar peek e gândit doar pentru depanare.

Operații terminale uzuale: collect, toList() (Java 16), forEach, reduce, count, min, max, anyMatch, findFirst.

Ce urmărește intervievatorul: Verifică dacă înțelegi modelul de execuție, nu doar sintaxa. Exemplul cu ordinea afișărilor e o întrebare clasică de tip „ce afișează”.

44 Junior

Cum folosești corect Optional? Ce greșeli se fac de obicei?

Răspuns scurt: Optional (Java 8) e gândit ca tip de retur pentru metode care pot să nu găsească o valoare. Îl consumi cu map, filter, orElse, orElseGet sau orElseThrow, nu cu get() fără verificare. Nu îl folosești ca tip de câmp, de parametru sau în colecții.

Optional<T> face explicit, în semnătură, faptul că rezultatul poate lipsi. Spring Data îl folosește, de exemplu, în findById.

JAVA
Optional<Client> client = clientRepository.findById(id);

String oras = client
        .map(Client::getAdresa)
        .map(Adresa::getOras)
        .orElse("necunoscut");

Client c = clientRepository.findById(id)
        .orElseThrow(() -> new ClientNegasitException(id));

client.ifPresentOrElse(
        x -> log.info("Găsit {}", x.getNume()),
        () -> log.warn("Clientul {} lipsește", id));   // Java 9

Greșeli frecvente:

  • optional.get() fără verificare: e doar un NPE cu alt nume (NoSuchElementException). Folosește orElseThrow();
  • if (opt.isPresent()) { x = opt.get(); }: funcționează, dar ratează rostul API-ului;
  • orElse(apelScump()): argumentul se evaluează mereu, chiar dacă valoarea există. Folosește orElseGet(() -> apelScump());
  • Optional drept câmp de entitate sau parametru de metodă: nu e serializabil, complică apelurile și nu a fost proiectat pentru asta;
  • Optional<List<T>>: întoarce o listă goală;
  • o metodă care întoarce Optional nu trebuie să întoarcă niciodată null. Folosește Optional.empty();
  • Optional.of(null) aruncă NPE; pentru valori care pot fi null, folosește Optional.ofNullable(x).

Pentru primitive există OptionalInt, OptionalLong și OptionalDouble, întoarse de exemplu de IntStream.max(). Optional nu elimină null din Java, dar documentează clar contractul metodei.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că folosești Optional idiomatic. Greșelile cu get() și orElse cu apel scump sunt cele mai des întâlnite.

45 Junior

Ce sunt method references și care sunt cele patru tipuri?

Răspuns scurt: Un method reference (::) este o scurtătură pentru o lambda care doar apelează o metodă existentă. Tipurile: metodă statică (Integer::parseInt), metodă a unui obiect anume (System.out::println), metodă de instanță a unui tip arbitrar (String::length) și constructor (ArrayList::new).

Când lambda-ul nu face nimic altceva decât să apeleze o metodă, un method reference e mai scurt și mai ușor de citit.

JAVA
// 1. Metodă statică: ClassName::staticMethod
Function<String, Integer> parse = Integer::parseInt;          // s -> Integer.parseInt(s)

// 2. Metodă a unui obiect anume: obiect::metoda
Consumer<String> print = System.out::println;                 // s -> System.out.println(s)
Predicate<String> esteAdmin = "admin"::equals;                // s -> "admin".equals(s)

// 3. Metodă de instanță pe un tip arbitrar: ClassName::instanceMethod
Function<String, Integer> lungime = String::length;           // s -> s.length()
BiFunction<String, String, Boolean> incepe = String::startsWith; // (s, p) -> s.startsWith(p)

// 4. Constructor: ClassName::new
Supplier<List<String>> lista = ArrayList::new;                // () -> new ArrayList<>()
Function<String, StringBuilder> sb = StringBuilder::new;      // s -> new StringBuilder(s)
IntFunction<int[]> array = int[]::new;                        // n -> new int[n]

Tipul 3 e cel care încurcă: primul parametru al funcției devine obiectul pe care se apelează metoda. De aceea String::startsWith se potrivește cu un BiFunction, unde primul argument e String-ul, iar al doilea e prefixul.

Un detaliu la tipul 2: obiectul se evaluează în momentul creării referinței, nu la fiecare apel. obj::metoda cu obj == null aruncă NPE imediat, chiar dacă referința nu e folosită niciodată, pe când lambda-ul x -> obj.metoda(x) ar arunca abia la apel.

Folosește method references când sunt clare (map(Client::getNume)). Dacă trebuie să te oprești să înțelegi ce face referința, o lambda explicită e mai bună.

Ce urmărește intervievatorul: Verifică familiaritatea cu sintaxa modernă. Tipul „instanță pe tip arbitrar” e cel la care greșesc mulți candidați.

46 Mid

Care este diferența dintre map și flatMap într-un Stream?

Răspuns scurt: map transformă fiecare element într-o singură valoare nouă, deci un stream de N elemente rămâne de N elemente. flatMap transformă fiecare element într-un stream și apoi le concatenează, aplatizând structurile imbricate, de exemplu o listă de liste.

map este o transformare unu-la-unu. flatMap este unu-la-oricâte: fiecare element produce un stream (gol, cu unul sau cu mai multe elemente), iar rezultatele sunt lipite într-un singur stream.

JAVA
record Comanda(String client, List<String> produse) {}

List<Comanda> comenzi = List.of(
    new Comanda("Ana", List.of("carte", "pix")),
    new Comanda("Ion", List.of("caiet")),
    new Comanda("Dan", List.of()));

List<List<String>> imbricat = comenzi.stream()
        .map(Comanda::produse)              // Stream<List<String>>
        .toList();                          // [[carte, pix], [caiet], []]

List<String> toateProdusele = comenzi.stream()
        .flatMap(c -> c.produse().stream()) // Stream<String>
        .distinct()
        .toList();                          // [carte, pix, caiet]

Alte utilizări frecvente:

  • cuvintele dintr-o listă de propoziții: linii.stream().flatMap(l -> Arrays.stream(l.split(" ")));
  • Optional.flatMap, când funcția întoarce deja un Optional, ca să nu obții Optional<Optional<T>>:
JAVA
Optional<Adresa> adresa = clientRepo.findById(id)
        .flatMap(Client::getAdresaPrincipala);   // getAdresaPrincipala întoarce Optional<Adresa>
  • eliminarea valorilor absente: stream.flatMap(Optional::stream) (Java 9) păstrează doar valorile prezente.

Din Java 16 există și mapMulti, o alternativă imperativă la flatMap, utilă când fiecare element produce puține rezultate și nu vrei să creezi un stream nou pentru fiecare. Pentru majoritatea cazurilor, flatMap rămâne varianta clară și cunoscută de toată lumea.

Ce urmărește intervievatorul: E una dintre cele mai frecvente întrebări despre streams. Intervievatorul vrea un exemplu concret de aplatizare, ideal și pe Optional.

47 Mid

Cum folosești Collectors.groupingBy, partitioningBy și toMap? Ce capcană are toMap?

Răspuns scurt: groupingBy grupează elementele într-un Map după o cheie, cu un collector opțional pentru valori (counting, summingInt, mapping). partitioningBy împarte în două grupuri, true și false. toMap aruncă IllegalStateException la chei duplicate dacă nu dai o funcție de combinare.

JAVA
record Angajat(String nume, String dept, int salariu, boolean remote) {}

List<Angajat> echipa = List.of(
    new Angajat("Ana", "IT", 9000, true),
    new Angajat("Ion", "IT", 8000, false),
    new Angajat("Mara", "HR", 6000, true));

Map<String, List<Angajat>> peDept = echipa.stream()
        .collect(Collectors.groupingBy(Angajat::dept));

Map<String, Long> numarPeDept = echipa.stream()
        .collect(Collectors.groupingBy(Angajat::dept, Collectors.counting()));

Map<String, Double> salariuMediu = echipa.stream()
        .collect(Collectors.groupingBy(Angajat::dept,
                 TreeMap::new,                                  // chei sortate
                 Collectors.averagingInt(Angajat::salariu)));

Map<String, List<String>> numePeDept = echipa.stream()
        .collect(Collectors.groupingBy(Angajat::dept,
                 Collectors.mapping(Angajat::nume, Collectors.toList())));

Map<Boolean, List<Angajat>> remoteSauNu = echipa.stream()
        .collect(Collectors.partitioningBy(Angajat::remote));  // mereu ambele chei

Capcana lui toMap:

JAVA
// IllegalStateException: Duplicate key IT
// echipa.stream().collect(Collectors.toMap(Angajat::dept, Angajat::nume));

Map<String, String> ok = echipa.stream()
        .collect(Collectors.toMap(Angajat::dept, Angajat::nume,
                 (a, b) -> a + ", " + b));                     // {IT=Ana, Ion, HR=Mara}

toMap mai aruncă NullPointerException dacă o valoare e null, pentru că folosește intern merge. groupingBy nu acceptă chei null. Diferența dintre partitioningBy și groupingBy cu un boolean: partitioningBy întoarce mereu ambele chei, true și false, chiar și când un grup e gol.

Ce urmărește intervievatorul: Verifică dacă poți face rapoarte simple cu streams, ceva ce se scrie des în aplicațiile de business. Capcana cu cheile duplicate apare frecvent în producție.

48 Mid

Scrie cu streams codul care întoarce, pentru fiecare departament, primii 3 angajați după salariu.

Răspuns scurt: Grupezi cu groupingBy după departament, iar ca downstream folosești collectingAndThen: sortezi lista descrescător după salariu și păstrezi primele 3 elemente. Alternativ, sortezi întâi tot stream-ul și grupezi cu un collector care limitează.

JAVA
import java.util.*;
import java.util.stream.*;

public class TopSalarii {
    record Angajat(String nume, String dept, int salariu) {}

    static Map<String, List<Angajat>> top3PeDept(List<Angajat> angajati) {
        return angajati.stream()
                .collect(Collectors.groupingBy(
                        Angajat::dept,
                        TreeMap::new,
                        Collectors.collectingAndThen(
                                Collectors.toList(),
                                lista -> lista.stream()
                                        .sorted(Comparator.comparingInt(Angajat::salariu).reversed()
                                                .thenComparing(Angajat::nume))
                                        .limit(3)
                                        .toList())));
    }

    public static void main(String[] args) {
        List<Angajat> a = List.of(
                new Angajat("Ana", "IT", 9000), new Angajat("Ion", "IT", 8000),
                new Angajat("Dan", "IT", 9500), new Angajat("Eva", "IT", 7000),
                new Angajat("Mara", "HR", 6000));
        top3PeDept(a).forEach((dept, lista) ->
                System.out.println(dept + " -> " + lista.stream().map(Angajat::nume).toList()));
        // HR -> [Mara]
        // IT -> [Dan, Ana, Ion]
    }
}

Puncte de discutat la interviu:

  • thenComparing(Angajat::nume) face rezultatul determinist când doi angajați au același salariu. Fără el, ordinea depinde de ordinea din sursă;
  • TreeMap::new sortează departamentele, ca ieșirea să fie stabilă;
  • complexitatea e O(n log n) din sortare. Pentru volume foarte mari și un k mic, poți folosi un PriorityQueue de mărime k pe fiecare grup, în O(n log k);
  • dacă datele vin din baza de date, e mai eficient să lași SQL-ul să facă treaba, cu o funcție fereastră: ROW_NUMBER() OVER (PARTITION BY dept ORDER BY salariu DESC), filtrată la cel mult 3.

Ultimul punct e cel care impresionează: arăți că alegi locul potrivit pentru calcul, nu doar că știi API-ul.

Ce urmărește intervievatorul: Este un exercițiu de live coding pentru mid. Intervievatorul urmărește compunerea collectorilor, egalitățile de salariu și dacă te gândești la SQL ca alternativă.

49 Mid

De ce s-a introdus API-ul java.time și ce clase folosești pentru date, ore și fusuri orare?

Răspuns scurt: java.util.Date și Calendar erau mutabile, nesigure între thread-uri și greu de folosit. java.time (Java 8) are clase imuabile și clare: LocalDate, LocalDateTime, ZonedDateTime, Instant pentru momente exacte, plus Duration și Period pentru intervale.

Problemele API-ului vechi: Date e mutabil (deci un câmp „final” de tip Date se poate schimba din exterior), lunile din Calendar încep de la 0, iar SimpleDateFormat nu e thread-safe, o sursă clasică de bug-uri când e ținut într-un câmp static.

Clasele din java.time sunt imuabile și thread-safe:

  • LocalDate: o dată fără oră și fără fus (ziua de naștere, data facturii);
  • LocalTime, LocalDateTime: ora, respectiv data și ora, tot fără fus;
  • ZonedDateTime: data și ora într-un fus anume, cu reguli de ora de vară (Europe/Bucharest);
  • Instant: un moment exact pe axa timpului, în UTC. Potrivit pentru timestamp-uri în baza de date și în loguri;
  • Duration (ore, minute, secunde) și Period (ani, luni, zile);
  • DateTimeFormatter: imuabil, deci poate fi constantă statică.
JAVA
LocalDate scadenta = LocalDate.of(2024, 1, 31).plusMonths(1);      // 2024-02-29
long zile = ChronoUnit.DAYS.between(LocalDate.now(), scadenta);

Instant acum = Instant.now();
ZonedDateTime bucuresti = acum.atZone(ZoneId.of("Europe/Bucharest"));

DateTimeFormatter RO = DateTimeFormatter.ofPattern("dd.MM.yyyy HH:mm");
System.out.println(bucuresti.format(RO));

Duration timeout = Duration.ofSeconds(30);

Reguli practice: stochează momentele ca Instant sau OffsetDateTime în UTC și convertește în fusul utilizatorului doar la afișare. Nu folosi LocalDateTime pentru evenimente care au loc „acum”, pentru că pierzi informația despre fus, iar la schimbarea orei apar ore duble sau lipsă. Pentru testare, injectează un Clock în loc să apelezi now() direct.

Ce urmărește intervievatorul: Arată dacă ai lucrat cu date reale, unde fusurile orare și formatarea produc bug-uri. Detaliul cu Clock injectat pentru teste e un plus.

50 Senior

Când are sens un parallel stream și când e o idee proastă? Ce probleme apar cu efectele secundare în streams?

Răspuns scurt: Parallel stream împarte munca pe ForkJoinPool.commonPool. Ajută la calcule CPU-intensive pe volume mari, cu surse ușor de împărțit (ArrayList, array-uri) și operații fără stare. E o idee proastă pentru I/O, pentru volume mici sau pentru cod cu efecte secundare, care produce rezultate greșite.

list.parallelStream() sau .parallel() rulează pipeline-ul pe mai multe thread-uri din ForkJoinPool.commonPool, al cărui număr de thread-uri depinde implicit de numărul de nuclee. Paralelizarea are un cost: împărțirea datelor, coordonarea thread-urilor și combinarea rezultatelor. Câștigul apare doar când munca per element e mare.

Când poate ajuta: calcule CPU-intensive pe sute de mii de elemente, surse care se împart ușor (ArrayList, array-uri, IntStream.range), operații fără stare și asociative (sum, max, reduce corect scris).

Când strică:

  • I/O sau apeluri blocante (HTTP, baza de date): ocupi thread-urile din pool-ul comun, partajat cu toată aplicația, inclusiv cu CompletableFuture fără executor dedicat;
  • surse greu de împărțit: LinkedList, Stream.iterate, fișiere citite linie cu linie;
  • operații dependente de ordine (findFirst, limit, sorted), care pierd o mare parte din avantaj;
  • efecte secundare, care dau rezultate greșite:
JAVA
List<Integer> rezultat = new ArrayList<>();
IntStream.range(0, 10_000).parallel().forEach(rezultat::add);
System.out.println(rezultat.size());   // de obicei mai puțin de 10000 sau o excepție

List<Integer> corect = IntStream.range(0, 10_000).parallel()
        .boxed().toList();             // colectarea e sigură

ArrayList nu e thread-safe, deci adăugările concurente se pierd. Regula e aceeași și pentru stream-urile secvențiale: lambda-urile din map și filter nu modifică stare externă, iar rezultatul se construiește cu collect sau reduce.

Răspunsul de senior: nu activezi paralelismul pe intuiție. Măsori cu un benchmark (JMH), iar într-un server web, unde cererile rulează deja în paralel, câștigul e adesea nul sau negativ.

Ce urmărește intervievatorul: Intervievatorul urmărește judecata, nu entuziasmul. Candidatul senior pomenește pool-ul comun, I/O-ul blocant, efectele secundare și măsurarea.

Concurență și multithreading

51 Junior

Care este diferența dintre Thread, Runnable și Callable? Ce se întâmplă dacă apelezi run() în loc de start()?

Răspuns scurt: Thread reprezintă un fir de execuție. Runnable este o sarcină fără rezultat și fără excepții checked, iar Callable întoarce un rezultat și poate arunca excepții. start() pornește un thread nou, pe când run() execută codul pe thread-ul curent, ca un apel obișnuit.

Un thread este un fir de execuție independent, cu propria stivă, care rulează în paralel cu celelalte (sau intercalat, dacă sunt mai multe thread-uri decât nuclee). Codul pe care îl rulează se descrie separat:

  • Runnable: void run(), fără rezultat, fără excepții checked;
  • Callable<V>: V call() throws Exception, întoarce un rezultat, se trimite de obicei la un ExecutorService, care îți dă un Future<V>.
JAVA
Runnable sarcina = () -> System.out.println("rulez pe " + Thread.currentThread().getName());

Thread t = new Thread(sarcina, "worker-1");
t.start();      // rulez pe worker-1 (thread nou)
t.join();       // așteaptă terminarea

new Thread(sarcina, "worker-2").run();   // rulez pe main: nu s-a creat niciun thread

Callable<Integer> calcul = () -> 6 * 7;
try (ExecutorService ex = Executors.newSingleThreadExecutor()) {  // AutoCloseable din Java 19
    Future<Integer> f = ex.submit(calcul);
    System.out.println(f.get());         // 42, blochează până e gata
}

start() cere JVM-ului să creeze un thread nou, care apoi apelează run(). Dacă apelezi run() direct, codul rulează sincron, pe thread-ul curent. Un thread se poate porni o singură dată; un al doilea start() aruncă IllegalThreadStateException.

În cod real nu creezi thread-uri de mână pentru fiecare sarcină, pentru că sunt scumpe și greu de controlat. Folosești un ExecutorService (un pool de thread-uri), iar din Java 21 poți folosi virtual threads pentru sarcini cu mult I/O. Preferă să implementezi Runnable decât să extinzi Thread: separi sarcina de mecanismul care o rulează.

Ce urmărește intervievatorul: Este întrebarea de intrare în concurență. Capcana run() versus start() verifică dacă înțelegi ce înseamnă de fapt un thread nou.

52 Junior

Ce face cuvântul cheie synchronized?

Răspuns scurt: synchronized asigură că un singur thread execută la un moment dat blocul sau metoda protejată de același monitor (lacăt). Garantează excludere mutuală și vizibilitate: modificările făcute în bloc sunt văzute de următorul thread care ia același lacăt.

Fiecare obiect Java are un monitor intern. synchronized îl ia la intrare și îl eliberează la ieșire, inclusiv dacă se aruncă o excepție.

JAVA
public class ContBancar {
    private long sold;
    private final Object lacat = new Object();

    public synchronized void depune(long suma) {   // lacătul este this
        sold += suma;
    }

    public void retrage(long suma) {
        synchronized (lacat) {                      // lacăt explicit, privat
            if (sold < suma) throw new IllegalStateException("Fonduri insuficiente");
            sold -= suma;
        }
    }

    public static synchronized void metodaStatica() { } // lacătul este ContBancar.class
}

Atenție la exemplul de mai sus: depune și retrage folosesc lacăte diferite (this și lacat), deci nu se exclud reciproc. Într-o clasă reală, toate metodele care ating sold trebuie să folosească același lacăt.

Ce garantează synchronized:

  • excludere mutuală: thread-urile care folosesc același monitor nu intră simultan;
  • vizibilitate: la ieșire, modificările sunt publicate în memoria principală, iar thread-ul care intră apoi le vede;
  • reentranță: un thread care deține lacătul poate intra din nou în alt bloc sincronizat pe același obiect, fără să se blocheze singur.

Bune practici: sincronizează cât mai puțin cod (doar secțiunea critică), preferă un obiect lacăt private final în locul lui this, ca să nu poată fi blocat din exterior, și nu face I/O sau apeluri lente în interiorul blocului. Pentru contoare simple, AtomicLong e o alternativă mai ușoară.

Ce urmărește intervievatorul: Verifică dacă știi și partea de vizibilitate, nu doar excluderea mutuală, și dacă înțelegi că lacătul trebuie să fie același obiect.

53 Mid

Care este diferența dintre volatile, synchronized și clasele Atomic?

Răspuns scurt: volatile garantează doar vizibilitatea: fiecare citire vede ultima scriere. Nu face atomice operațiile compuse precum count++. synchronized oferă atomicitate și vizibilitate, cu un lacăt. AtomicInteger și celelalte clase atomice fac operații compuse atomice fără lacăt, prin compare-and-swap.

Problema de bază: un thread poate ține o valoare în cache-ul procesorului sau în registre, iar compilatorul și procesorul pot reordona instrucțiunile. Fără sincronizare, un thread poate să nu vadă niciodată modificarea făcută de altul.

volatile rezolvă vizibilitatea pentru o singură variabilă. E potrivit pentru flag-uri:

JAVA
private volatile boolean oprit = false;

public void ruleaza() {
    while (!oprit) { proceseaza(); }   // fără volatile, bucla poate rula la nesfârșit
}
public void opreste() { oprit = true; }

Dar volatile int count; count++; rămâne nesigur, pentru că count++ înseamnă citire, adunare și scriere: două thread-uri pot citi aceeași valoare și una dintre incrementări se pierde.

Atomic* (AtomicInteger, AtomicLong, AtomicReference) folosesc instrucțiunea CAS (compare-and-swap) a procesorului: „setează valoarea nouă doar dacă cea curentă e cea pe care am citit-o”, reîncercând în buclă la conflict.

JAVA
private final AtomicInteger cereri = new AtomicInteger();
cereri.incrementAndGet();                         // atomic
cereri.updateAndGet(v -> Math.min(v + 10, 100));  // operație compusă atomică

Pentru contoare foarte solicitate din multe thread-uri, LongAdder e mai rapid, pentru că împarte valoarea pe mai multe celule.

synchronized rămâne necesar când trebuie să modifici atomic mai multe variabile împreună (de exemplu sold și istoric) sau când ai o secvență „verifică, apoi acționează” peste mai multe câmpuri.

Pe scurt: volatile pentru flag-uri, Atomic* pentru o singură valoare cu operații compuse, synchronized sau Lock pentru invarianți care implică mai multe câmpuri.

Ce urmărește intervievatorul: Este o întrebare clasică de mid. Greșeala tipică: candidatul spune că volatile face count++ thread-safe.

54 Mid

Ce este un ExecutorService și cum folosești CompletableFuture pentru sarcini asincrone?

Răspuns scurt: ExecutorService gestionează un pool de thread-uri reutilizabile, căruia îi trimiți sarcini și primești Future-uri. CompletableFuture (Java 8) permite compunerea sarcinilor asincrone fără blocare: thenApply, thenCompose, thenCombine, allOf, exceptionally.

Crearea unui thread pentru fiecare sarcină e scumpă și nelimitată. Un ExecutorService reutilizează un număr controlat de thread-uri și pune sarcinile în coadă.

JAVA
ExecutorService pool = Executors.newFixedThreadPool(4);
Future<String> f = pool.submit(() -> descarca("https://exemplu.ro"));
String rezultat = f.get(5, TimeUnit.SECONDS);   // blochează, cu timeout
pool.shutdown();                                 // nu mai acceptă sarcini noi
pool.awaitTermination(30, TimeUnit.SECONDS);

Future.get() blochează thread-ul apelant. CompletableFuture permite să descrii ce se întâmplă după terminare, fără blocare:

JAVA
ExecutorService io = Executors.newFixedThreadPool(10);

CompletableFuture<Client> client = CompletableFuture.supplyAsync(() -> clientApi.get(id), io);
CompletableFuture<List<Comanda>> comenzi = CompletableFuture.supplyAsync(() -> comenziApi.get(id), io);

CompletableFuture<Profil> profil = client
        .thenCombine(comenzi, Profil::new)              // ambele în paralel
        .orTimeout(2, TimeUnit.SECONDS)                 // Java 9
        .exceptionally(ex -> Profil.gol(id));           // fallback la eroare

Profil p = profil.join();

Metode utile: thenApply (transformare sincronă), thenCompose (când pasul următor întoarce tot un CompletableFuture, echivalentul lui flatMap), thenCombine, allOf și anyOf, handle și exceptionally pentru erori.

Capcane:

  • fără executor explicit, supplyAsync folosește ForkJoinPool.commonPool, nepotrivit pentru I/O blocant;
  • Executors.newFixedThreadPool folosește o coadă nelimitată, deci sub încărcare mare memoria poate crește necontrolat. În producție se folosește adesea un ThreadPoolExecutor configurat explicit, cu coadă limitată și politică de respingere;
  • uitarea lui shutdown() ține JVM-ul pornit.

În Spring, alternativa declarativă e @Async cu un TaskExecutor configurat.

Ce urmărește intervievatorul: Verifică dacă știi să rulezi lucruri în paralel controlat. Detaliile despre pool-ul comun și coada nelimitată diferențiază un candidat mid bun.

55 Mid

Ce afișează codul în care două thread-uri incrementează de 100.000 de ori același câmp int count, fără sincronizare? Cum repari?

Răspuns scurt: Rezultatul este de obicei mai mic decât 200.000 și diferă de la o rulare la alta, pentru că count++ nu e atomic și incrementările se pierd (race condition). Se repară cu AtomicInteger, cu synchronized sau cu un contor separat pe fiecare thread, adunat la final.

JAVA
public class Cursa {
    static int count = 0;

    public static void main(String[] args) throws InterruptedException {
        Runnable inc = () -> { for (int i = 0; i < 100_000; i++) count++; };
        Thread a = new Thread(inc), b = new Thread(inc);
        a.start(); b.start();
        a.join();  b.join();
        System.out.println(count);    // de exemplu 137412, diferit la fiecare rulare
    }
}

count++ se execută în trei pași: citește valoarea, adună 1, scrie înapoi. Dacă ambele thread-uri citesc 500, ambele scriu 501, iar o incrementare se pierde. Aceasta e o race condition: rezultatul depinde de ordinea în care sistemul de operare planifică thread-urile. Uneori, pe o mașină cu un singur nucleu sau cu un număr mic de iterații, poți obține chiar 200.000, ceea ce face bug-ul și mai periculos: trece testele și apare în producție.

Soluții:

JAVA
static final AtomicInteger atomic = new AtomicInteger();
Runnable inc1 = () -> { for (int i = 0; i < 100_000; i++) atomic.incrementAndGet(); };

static final Object lacat = new Object();
Runnable inc2 = () -> { for (int i = 0; i < 100_000; i++) synchronized (lacat) { count++; } };

A treia variantă, adesea cea mai rapidă: fiecare thread numără local și adaugă la final o singură dată, sincronizat. Sau folosești LongAdder ori un stream cu sum().

Notă: join() e esențial aici și dintr-un motiv mai puțin evident. El nu doar așteaptă terminarea, ci creează și o relație happens-before, deci main vede garantat valorile scrise de thread-uri.

Ce urmărește intervievatorul: Este o întrebare de tip „ce afișează” foarte frecventă. Intervievatorul vrea explicația pașilor din count++ și faptul că bug-ul nu e determinist.

56 Mid

Ce este un deadlock, cum îl eviți și cum îl detectezi într-o aplicație care rulează?

Răspuns scurt: Deadlock-ul apare când thread-urile așteaptă fiecare un lacăt ținut de celălalt și niciunul nu mai avansează. Îl eviți luând lacătele mereu în aceeași ordine sau cu tryLock și timeout. Îl detectezi cu un thread dump (jstack, jcmd).

Exemplul clasic: un transfer între două conturi, care blochează contul sursă, apoi contul destinație.

JAVA
void transfer(Cont din, Cont in, long suma) {
    synchronized (din) {
        synchronized (in) {
            din.retrage(suma);
            in.depune(suma);
        }
    }
}
// Thread 1: transfer(A, B) ține A, așteaptă B
// Thread 2: transfer(B, A) ține B, așteaptă A  => deadlock

Cele patru condiții necesare sunt excluderea mutuală, ținerea unui lacăt în timp ce aștepți altul, lipsa preempțiunii și așteptarea circulară. E suficient să elimini una.

Cum îl eviți:

  • ordine globală a lacătelor: blochezi întâi contul cu ID-ul mai mic, indiferent de direcția transferului, și dispare așteptarea circulară;
JAVA
Cont primul = din.getId() < in.getId() ? din : in;
Cont alDoilea = primul == din ? in : din;
synchronized (primul) { synchronized (alDoilea) { /* transfer */ } }
  • ReentrantLock.tryLock(timeout): renunți și reîncerci dacă nu obții lacătul;
  • secțiuni critice scurte, fără apeluri externe ținând un lacăt.

Cum îl detectezi: aplicația nu mai răspunde, dar CPU-ul e jos. Faci un thread dump:

BASH
jcmd <pid> Thread.print     # sau: jstack <pid>

La final, JVM-ul afișează Found one Java-level deadlock:, cu thread-urile implicate și lacătele pe care le țin și le așteaptă. Programatic, ai ThreadMXBean.findDeadlockedThreads().

Un echivalent frecvent la baze de date: două tranzacții care actualizează aceleași rânduri în ordine inversă. Baza de date detectează situația și anulează una dintre tranzacții, deci codul trebuie să poată reîncerca.

Ce urmărește intervievatorul: Verifică dacă poți explica, preveni și diagnostica. Pomenirea thread dump-ului și a ordinii globale a lacătelor e ce caută intervievatorul.

57 Senior

Ce este Java Memory Model și ce înseamnă relația happens-before?

Răspuns scurt: Java Memory Model definește când scrierea făcută de un thread devine vizibilă altui thread. Happens-before este garanția că efectele unei acțiuni sunt vizibile celei care urmează. O dau lacătele, volatile, start(), join(), câmpurile final și colecțiile concurente.

Fără reguli, compilatorul, JIT-ul și procesorul pot reordona instrucțiunile și pot ține valori în cache, iar alt thread poate vedea stări incomplete. JMM (definit în JLS, capitolul 17, revizuit în Java 5 prin JSR-133) spune că un program fără data races se comportă ca și cum ar fi executat secvențial consistent. Pentru asta trebuie relații happens-before între scrieri și citiri.

Regulile principale:

  • în același thread, fiecare acțiune happens-before acțiunile care urmează în ordinea programului;
  • eliberarea unui lacăt happens-before obținerea ulterioară a aceluiași lacăt;
  • o scriere volatile happens-before orice citire ulterioară a aceleiași variabile;
  • thread.start() happens-before orice acțiune din thread-ul pornit, iar tot ce face thread-ul happens-before revenirea din join();
  • valorile câmpurilor final sunt vizibile după terminarea constructorului, dacă this nu scapă din constructor;
  • punerea într-o colecție concurentă (ConcurrentHashMap, BlockingQueue) happens-before scoaterea.

Exemplul clasic e double-checked locking, greșit fără volatile:

JAVA
class Config {
    private static volatile Config instanta;    // fără volatile: obiect parțial construit

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

Fără volatile, scrierea referinței poate fi reordonată înaintea inițializării câmpurilor, iar alt thread vede un obiect nenul, dar neinițializat. Concluzia practică: orice stare partajată mutabilă are nevoie de un mecanism care creează happens-before. „Pare că merge pe laptopul meu” nu e o dovadă, pentru că x86 are un model de memorie mai strict decât ARM.

Ce urmărește intervievatorul: La senior, intervievatorul vrea să vadă că înțelegi de ce funcționează mecanismele de sincronizare, nu doar cum se folosesc. Double-checked locking e testul clasic.

58 Senior

Ce sunt virtual threads din Java 21 și când le folosești?

Răspuns scurt: Virtual threads (JEP 444, finale în Java 21) sunt thread-uri ușoare, gestionate de JVM, nu de sistemul de operare, deci poți avea sute de mii simultan. Ajută la aplicații cu mult I/O blocant, nu la calcule intense pe CPU.

Un thread clasic (platform thread) corespunde unui thread al sistemului de operare, cu o stivă de ordinul megabyților și un cost de creare și de schimbare de context semnificativ. De aceea serverele foloseau pool-uri de câteva sute de thread-uri, iar o aplicație care așteaptă mult după baza de date rămânea fără thread-uri disponibile, deși procesorul stătea liber.

Un virtual thread rulează pe un număr mic de thread-uri purtătoare (carrier threads, un ForkJoinPool). Când face o operație blocantă de I/O, JVM-ul îl „demontează” de pe carrier, îi salvează stiva în heap și eliberează carrier-ul pentru alt virtual thread. Codul rămâne scris sincron, simplu de citit și de depanat.

JAVA
try (ExecutorService ex = Executors.newVirtualThreadPerTaskExecutor()) {
    List<Future<String>> rezultate = IntStream.range(0, 10_000)
            .mapToObj(i -> ex.submit(() -> httpClient.get("/produse/" + i)))
            .toList();
}   // close() așteaptă terminarea tuturor sarcinilor

Thread.startVirtualThread(() -> System.out.println("ușor"));

În Spring Boot 3.2+ le activezi cu spring.threads.virtual.enabled=true, iar Tomcat procesează fiecare cerere pe un virtual thread.

Ce trebuie știut:

  • nu le pui în pool. Sunt ieftine, creezi câte unul pentru fiecare sarcină;
  • nu fac codul CPU-bound mai rapid;
  • pinning: în Java 21, un virtual thread blocat în interiorul unui bloc synchronized rămâne legat de carrier. JEP 491, din Java 24, rezolvă problema pentru synchronized. Pe Java 21 se recomandă ReentrantLock în zonele cu I/O;
  • ThreadLocal cu obiecte mari devine costisitor la sute de mii de thread-uri;
  • resursele limitate rămân limitate: dacă pool-ul de conexiuni la baza de date are 20 de conexiuni, 10.000 de virtual threads vor aștepta după ele.

Ce urmărește intervievatorul: Arată dacă ești la zi cu platforma. La senior se așteaptă nuanțele: pinning, ce nu rezolvă și faptul că resursa limitată se mută la baza de date.

59 Senior

Când folosești ReentrantLock, ReadWriteLock sau Semaphore în loc de synchronized?

Răspuns scurt: synchronized e suficient în majoritatea cazurilor. ReentrantLock adaugă tryLock cu timeout, așteptare întreruptibilă, fairness și mai multe Condition. ReadWriteLock permite multe citiri simultane și o singură scriere. Semaphore limitează numărul de thread-uri care accesează o resursă.

ReentrantLock face aceleași garanții ca synchronized, dar cu control explicit:

JAVA
private final ReentrantLock lock = new ReentrantLock();

public boolean incearcaRezervare(Loc loc) throws InterruptedException {
    if (!lock.tryLock(200, TimeUnit.MILLISECONDS)) return false;   // nu așteaptă la infinit
    try {
        return loc.rezerva();
    } finally {
        lock.unlock();            // obligatoriu în finally
    }
}

Ce aduce în plus: tryLock (evitarea deadlock-urilor), lockInterruptibly, fairness opțional (thread-urile primesc lacătul în ordinea sosirii, cu cost de performanță) și obiecte Condition multiple, de exemplu „coadă plină” și „coadă goală” separate. Dezavantajul: dacă uiți unlock(), lacătul rămâne luat pentru totdeauna.

ReentrantReadWriteLock e util când citirile domină: mai mulți cititori simultan, un singur scriitor exclusiv. Pentru citiri foarte frecvente există StampedLock, cu citire optimistă, dar nu e reentrant. Dacă datele sunt într-o colecție, un ConcurrentHashMap e adesea suficient.

Semaphore limitează concurența, nu protejează o stare:

JAVA
private final Semaphore apeluri = new Semaphore(5);   // max 5 apeluri simultane la API extern

public Raspuns apeleaza(Cerere c) throws InterruptedException {
    apeluri.acquire();
    try { return client.trimite(c); }
    finally { apeluri.release(); }
}

Alte unelte din java.util.concurrent: CountDownLatch (aștepți să termine N sarcini), CyclicBarrier, BlockingQueue pentru producător-consumator.

Răspunsul de senior: începi cu cea mai simplă unealtă corectă. Preferi structuri imuabile și colecții concurente, folosești synchronized pentru secțiuni critice simple și treci la Lock explicit doar când ai nevoie concretă de funcțiile lui. Și testezi sub încărcare, nu doar unitar.

Ce urmărește intervievatorul: Verifică dacă știi trusa de unelte din java.util.concurrent și, mai ales, dacă alegi cu discernământ.

JVM și memorie

60 Junior

Care este diferența dintre stack și heap în Java?

Răspuns scurt: Fiecare thread are propriul stack, cu cadre pentru apelurile de metode: variabile locale, parametri, referințe. Heap-ul e comun tuturor thread-urilor și conține obiectele, gestionate de garbage collector. Stack-ul plin dă StackOverflowError, heap-ul plin dă OutOfMemoryError.

Stack-ul (stiva) aparține unui singur thread. La fiecare apel de metodă se adaugă un cadru (frame), care conține parametrii, variabilele locale primitive și referințele locale. La ieșirea din metodă, cadrul dispare automat. E rapid, are mărime limitată (configurabilă cu -Xss) și nu e partajat, deci variabilele locale sunt implicit thread-safe.

Heap-ul e comun pentru toate thread-urile. Acolo stau obiectele create cu new, array-urile și câmpurile obiectelor. Memoria se eliberează de garbage collector, când obiectele nu mai sunt accesibile. Mărimea se setează cu -Xms (inițial) și -Xmx (maxim).

JAVA
public class Exemplu {
    public static void main(String[] args) {
        int x = 10;                         // stack (main)
        Persoana p = new Persoana("Ana");   // referința p pe stack, obiectul în heap
        saluta(p);
    }
    static void saluta(Persoana om) {       // cadru nou pe stack; om indică spre același obiect
        String mesaj = "Salut, " + om.nume; // referința pe stack, String-ul în heap
        System.out.println(mesaj);
    }
}

static int recursiv(int n) { return recursiv(n + 1); }   // StackOverflowError

Erori tipice:

  • StackOverflowError: recursivitate fără condiție de oprire sau prea adâncă, de exemplu un toString() care se apelează circular între două entități JPA cu relație bidirecțională;
  • OutOfMemoryError: Java heap space: prea multe obiecte ținute în viață.

O nuanță pentru mid: JIT-ul poate face escape analysis și poate evita alocarea în heap pentru obiectele care nu ies din metodă (scalar replacement). Din punctul de vedere al programatorului, regula rămâne însă „obiectele sunt în heap”. Separat de heap există și Metaspace (din Java 8), unde stau metadatele claselor.

Ce urmărește intervievatorul: Este o întrebare de bază despre JVM. Intervievatorul verifică modelul mental corect: referința pe stack, obiectul în heap.

61 Junior

Ce face garbage collector-ul și când devine un obiect eligibil pentru colectare?

Răspuns scurt: Garbage collector-ul eliberează automat memoria obiectelor care nu mai sunt accesibile pornind de la rădăcini (GC roots): variabile locale ale thread-urilor active, câmpuri statice, referințe JNI. Un obiect fără niciun drum de la o rădăcină devine eligibil, chiar dacă face parte dintr-un ciclu de referințe.

Java nu are free() sau delete. GC-ul determină ce obiecte sunt „vii” plecând de la GC roots:

  • variabilele locale și parametrii din stivele thread-urilor active;
  • câmpurile statice ale claselor încărcate;
  • referințele din cod nativ (JNI) și monitoarele ținute.

Tot ce se poate atinge, direct sau indirect, de la aceste rădăcini e viu. Restul e gunoi. Spre deosebire de numărarea referințelor, metoda funcționează și pentru cicluri: două obiecte care se referă reciproc, dar la care nu mai ajunge nimeni, sunt colectate.

JAVA
void proceseaza() {
    Client a = new Client("Ana");
    Client b = new Client("Ion");
    a.prieten = b;
    b.prieten = a;          // ciclu
    a = null;
    b = null;               // ambele devin eligibile, ciclul nu le salvează
}

Client c = new Client("Dan");
c = new Client("Eva");      // obiectul "Dan" devine eligibil

static List<Client> cache = new ArrayList<>();
cache.add(new Client("Mara"));   // rămâne viu cât timp e în lista statică

Lucruri de reținut:

  • eligibil nu înseamnă colectat imediat. GC-ul rulează când decide JVM-ul;
  • System.gc() e doar o sugestie și nu se folosește în cod de producție;
  • există și referințe mai slabe: WeakReference (colectată la următorul GC dacă nu mai există referințe tari, folosită de WeakHashMap), SoftReference (colectată doar când memoria e pe terminate) și PhantomReference (pentru curățare, prin Cleaner);
  • GC-ul gestionează doar memoria. Fișierele, socket-urile și conexiunile se închid explicit, cu try-with-resources.

Ce urmărește intervievatorul: Verifică înțelegerea conceptului de accesibilitate. Mulți candidați cred că ciclurile de referințe împiedică colectarea, cum se întâmplă la reference counting.

62 Mid

Cum poate apărea un memory leak într-o aplicație Java, deși există garbage collector?

Răspuns scurt: Un memory leak în Java înseamnă obiecte care rămân accesibile, deși nu mai sunt necesare, deci GC-ul nu le poate colecta. Cauze frecvente: colecții statice care doar cresc, cache-uri fără limită, listeneri neînregistrați invers, ThreadLocal necurățat în pool-uri de thread-uri și resurse neînchise.

GC-ul colectează doar ce e inaccesibil. Dacă păstrezi din greșeală o referință, obiectul trăiește la nesfârșit. Cele mai frecvente surse:

  • Colecții statice sau cu durată lungă care primesc mereu elemente și nu se golesc niciodată:
JAVA
public class AuditService {
    private static final List<Eveniment> istoric = new ArrayList<>();
    public void inregistreaza(Eveniment e) { istoric.add(e); }   // crește la infinit
}
  • Cache-uri fără limită sau fără expirare, de exemplu un HashMap folosit drept cache. Soluția e un cache cu dimensiune maximă și expirare (Caffeine).
  • Chei mutabile sau fără equals/hashCode în HashMap: aceeași cheie logică creează intrări noi la fiecare put.
  • Listeneri și callback-uri înregistrați și niciodată eliminați.
  • ThreadLocal în pool-uri: thread-urile din pool trăiesc cât aplicația, deci valoarea rămâne dacă nu apelezi remove():
JAVA
private static final ThreadLocal<ContextUtilizator> CTX = new ThreadLocal<>();
try {
    CTX.set(context);
    proceseazaCererea();
} finally {
    CTX.remove();      // altfel contextul rămâne pe thread și „trece” la cererea următoare
}

Acesta e și un risc de securitate: o cerere poate vedea datele utilizatorului anterior.

  • Clase interne non-statice care țin o referință implicită spre obiectul exterior.
  • Resurse neînchise: stream-uri, conexiuni, ResultSet.
  • ClassLoader leaks la redeploy în servere de aplicații, din cauza unui thread sau a unui driver JDBC rămas înregistrat.

Simptomul tipic: memoria folosită după fiecare full GC crește constant, până la OutOfMemoryError. Se confirmă cu un heap dump analizat în Eclipse MAT, care arată ce obiecte rețin cea mai multă memorie.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi că GC-ul nu te protejează de toate problemele de memorie. Exemplul cu ThreadLocal în pool e cel mai apreciat.

63 Mid

Cum se încarcă o clasă în JVM? Ce sunt ClassLoader-ele și modelul de delegare?

Răspuns scurt: O clasă trece prin încărcare, linking (verificare, pregătire, rezolvare) și inițializare, la prima utilizare activă. ClassLoader-ele formează o ierarhie: Bootstrap, Platform și Application. Fiecare deleagă întâi părintelui, ca să nu se încarce de două ori clasele de bază.

Etapele:

  • Loading: un ClassLoader găsește bytecode-ul (în JAR, în director, în rețea) și creează un obiect Class;
  • Linking: *verificarea* bytecode-ului (siguranță), *pregătirea* (câmpurile statice primesc valori implicite) și *rezolvarea* referințelor simbolice;
  • Initialization: rulează inițializatorii statici și blocurile static, o singură dată și thread-safe. Se întâmplă la prima utilizare activă: new, apelul unei metode statice, accesarea unui câmp static care nu e constantă de compilare, Class.forName.

Ierarhia de ClassLoader-e, din Java 9:

  • Bootstrap: încarcă modulele de bază (java.base), implementat în cod nativ;
  • Platform: alte module ale platformei (în Java 8 se numea Extension ClassLoader);
  • Application (System): classpath-ul și modulepath-ul aplicației tale.

Delegarea către părinte: când i se cere o clasă, un loader întreabă întâi părintele și o încarcă singur doar dacă părintele n-o găsește. Așa, nimeni nu poate înlocui java.lang.String cu o versiune proprie.

JAVA
System.out.println(String.class.getClassLoader());        // null (Bootstrap)
System.out.println(Exemplu.class.getClassLoader());       // ...AppClassLoader

O clasă e identificată prin nume plus ClassLoader-ul care a încărcat-o. De aici apare eroarea derutantă ClassCastException: X cannot be cast to X, când aceeași clasă e încărcată de două loader-e diferite (frecvent în servere de aplicații sau cu DevTools în Spring Boot).

Diferența dintre două erori cerute des: ClassNotFoundException apare când încarci explicit o clasă după nume și nu e găsită; NoClassDefFoundError apare când o clasă exista la compilare, dar lipsește la rulare sau inițializarea ei statică a eșuat anterior.

Ce urmărește intervievatorul: Verifică înțelegerea mecanismului de rulare. Diferența dintre ClassNotFoundException și NoClassDefFoundError e un follow-up clasic.

64 Mid

Cum este organizat heap-ul pe generații și ce garbage collector-e cunoști?

Răspuns scurt: Majoritatea GC-urilor împart heap-ul în generația tânără (Eden și Survivor) și cea veche, pentru că majoritatea obiectelor mor tinere. G1 este GC-ul implicit din Java 9. Mai există Parallel (throughput), ZGC și Shenandoah (pauze foarte mici) și Serial (pentru heap-uri mici).

Ipoteza generațională: majoritatea obiectelor (DTO-uri, String-uri temporare, iteratori) devin gunoi foarte repede. De aceea heap-ul se împarte:

  • Young generation: obiectele noi se alocă în Eden. La un *minor GC*, obiectele vii se copiază în unul dintre spațiile Survivor, iar după ce supraviețuiesc unui număr de colectări sunt promovate în generația veche. Colectarea e rapidă, pentru că se copiază doar puținele obiecte vii;
  • Old generation: obiecte cu viață lungă (cache-uri, bean-uri, sesiuni). Se colectează mai rar și mai scump;
  • Metaspace (din Java 8, în locul PermGen): metadatele claselor, în memorie nativă, nu în heap.

Colectoare din HotSpot:

  • Serial: un singur thread, potrivit pentru heap-uri mici sau containere cu un singur procesor;
  • Parallel: mai multe thread-uri, optimizat pentru throughput, cu pauze mai lungi. A fost implicit până în Java 8;
  • G1 (implicit din Java 9): împarte heap-ul în regiuni și colectează întâi regiunile cu cel mai mult gunoi, încercând să respecte o țintă de pauză (-XX:MaxGCPauseMillis, implicit 200 ms);
  • ZGC (producție din Java 15, generațional din Java 21) și Shenandoah: colectare aproape complet concurentă, cu pauze de ordinul milisecundelor chiar și la heap-uri foarte mari.
BASH
java -XX:+UseG1GC -Xms2g -Xmx2g -Xlog:gc*:file=gc.log -jar app.jar
java -XX:+UseZGC -XX:+ZGenerational -jar app.jar   # Java 21

În practică, G1 cu setări implicite e un punct de plecare bun. Schimbi colectorul sau parametrii doar pe baza măsurătorilor din logurile GC (-Xlog:gc), de exemplu dacă pauzele afectează latența cererilor.

Ce urmărește intervievatorul: Arată dacă înțelegi de ce există generațiile și dacă știi ce colector rulează aplicația ta. Nu se așteaptă tuning detaliat la mid, ci înțelegerea compromisului dintre throughput și latență.

65 Senior

Aplicația din producție cade cu OutOfMemoryError. Cum procedezi?

Răspuns scurt: Citești tipul exact al erorii (Java heap space, Metaspace etc.), obții un heap dump (ideal automat, cu -XX:+HeapDumpOnOutOfMemoryError), îl analizezi în Eclipse MAT ca să afli ce reține memoria, corelezi cu metricile și repari cauza, nu doar mărești -Xmx.

Pasul 1: tipul erorii, pentru că fiecare are altă cauză:

  • Java heap space: prea multe obiecte vii; leak sau încărcare prea mare;
  • GC overhead limit exceeded: JVM-ul petrece aproape tot timpul în GC și recuperează foarte puțin;
  • Metaspace: prea multe clase, des un leak de ClassLoader sau generare dinamică de clase;
  • unable to create native thread: prea multe thread-uri sau limite ale sistemului de operare;
  • Direct buffer memory: memorie off-heap (Netty, NIO).

Pasul 2: date. Configurează din timp:

BASH
java -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/var/dumps \
     -Xlog:gc*:file=/var/log/app/gc.log:time -jar app.jar

jcmd <pid> GC.heap_dump /tmp/heap.hprof     # manual, cât aplicația încă rulează
jcmd <pid> GC.class_histogram | head -30    # rapid: ce clase ocupă cel mai mult

Pasul 3: analiza. Deschide dump-ul în Eclipse MAT sau în VisualVM. „Leak Suspects” și „Dominator Tree” arată ce obiecte rețin cea mai multă memorie și lanțul de referințe până la un GC root. Cauze tipice: o listă statică, un cache fără limită, un query care încarcă milioane de rânduri dintr-odată (findAll() pe o tabelă mare), sesiuni HTTP care nu expiră.

Pasul 4: corelează cu metricile (heap folosit după GC) și cu deploy-urile. A apărut după o anumită versiune? Crește constant (leak) sau sare brusc (o cerere anume)?

Pasul 5: repară cauza și adaugă o protecție: paginare, limite pe cache, streaming de date. Mărirea -Xmx e legitimă doar dacă analiza arată că aplicația chiar are nevoie de mai multă memorie, nu ca să amâni un leak. Atenție: heap dump-ul conține date din memorie, inclusiv date personale, deci îl tratezi ca pe date sensibile.

Ce urmărește intervievatorul: La senior, intervievatorul urmărește un proces de investigare cu unelte concrete. Răspunsul „măresc -Xmx” fără analiză e un semnal negativ.

66 Senior

Ce trebuie să știi despre rularea JVM-ului într-un container Docker sau Kubernetes?

Răspuns scurt: JVM-urile moderne (Java 10+, backport în 8u191) citesc limitele de memorie și CPU ale containerului. Dimensionezi heap-ul procentual cu -XX:MaxRAMPercentage, lași loc pentru memoria non-heap, iar la CPU limitat ții cont că se reduc thread-urile GC și pool-urile implicite.

Înainte de suportul pentru containere, JVM-ul vedea toată memoria și toate procesoarele mașinii gazdă, nu limitele containerului. Rezultatul: un heap implicit prea mare, iar kernelul omora procesul (OOMKilled) fără niciun OutOfMemoryError în loguri. De la Java 10 (și 8u191), opțiunea UseContainerSupport e activă implicit, iar JVM-ul citește limitele din cgroups. Suportul pentru cgroups v2 a apărut în Java 15 și a fost portat și în 11.0.16 și 8u372.

Memoria: implicit, heap-ul maxim e 25% din memoria containerului, adesea prea puțin. Folosește procente în loc de valori fixe:

FROM eclipse-temurin:21-jre
COPY target/app.jar /app/app.jar
ENV JAVA_TOOL_OPTIONS="-XX:MaxRAMPercentage=75.0 -XX:+ExitOnOutOfMemoryError"
ENTRYPOINT ["java", "-jar", "/app/app.jar"]

Nu da 100% heap-ului. JVM-ul mai folosește memorie pentru Metaspace, stivele thread-urilor, codul compilat de JIT, buffere directe și GC. Dacă limita containerului e 1 GiB și heap-ul e tot 1 GiB, procesul va fi omorât.

CPU: dacă containerul are o limită de unul sau două procesoare, JVM-ul alege mai puține thread-uri pentru GC, pentru ForkJoinPool.commonPool și pentru compilatorul JIT. Cu mai puțin de două procesoare sau cu mai puțin de aproximativ 1,8 GB de memorie, JVM-ul poate alege implicit Serial GC în loc de G1. Verifică ce vede JVM-ul:

BASH
java -XX:+PrintFlagsFinal -version | grep -E "MaxHeapSize|UseG1GC|UseSerialGC"
java -Xlog:os+container=info -version

Alte bune practici: -XX:+ExitOnOutOfMemoryError, ca orchestratorul să repornească un proces bolnav în loc să-l lase pe jumătate funcțional; health checks prin Spring Boot Actuator (/actuator/health/liveness și /readiness); și timpul de pornire luat în calcul la probe, sau redus cu CDS (Class Data Sharing).

Ce urmărește intervievatorul: Verifică experiența de producție cu aplicații containerizate, foarte frecventă azi. Mulți candidați nu știu că OOMKilled nu lasă niciun OutOfMemoryError în loguri.

Spring Boot, JPA/Hibernate și testare

67 Junior

Ce este Spring Boot și cum diferă de Spring Framework?

Răspuns scurt: Spring Framework oferă containerul de dependency injection, Spring MVC, tranzacții și integrarea cu baze de date. Spring Boot îl face ușor de pornit: auto-configurare, dependențe starter, server web încorporat (Tomcat) și configurare externă, astfel încât aplicația rulează direct cu java -jar.

Spring Framework e fundația: containerul IoC (Inversion of Control), care creează și leagă obiectele, AOP, gestionarea tranzacțiilor, Spring MVC pentru web, JdbcTemplate și integrarea cu JPA. Înainte de Boot, o aplicație cerea multă configurare XML sau Java și un server de aplicații separat, în care făceai deploy unui .war.

Spring Boot adaugă convenții peste framework:

  • starters: spring-boot-starter-web aduce un set de dependențe compatibile între ele (Spring MVC, Jackson, Tomcat), fără să alegi singur versiunile;
  • auto-configurare: dacă găsește pe classpath driverul PostgreSQL și Spring Data JPA, configurează automat DataSource, EntityManagerFactory și managerul de tranzacții. Se bazează pe condiții precum @ConditionalOnClass și @ConditionalOnMissingBean, deci un bean definit de tine înlocuiește varianta implicită;
  • server încorporat: aplicația e un .jar executabil;
  • configurare externă: application.yml, variabile de mediu, profile (application-prod.yml, activat cu spring.profiles.active=prod);
  • Actuator: endpoint-uri pentru health checks și metrici.
JAVA
@SpringBootApplication     // = @Configuration + @EnableAutoConfiguration + @ComponentScan
public class MagazinApplication {
    public static void main(String[] args) {
        SpringApplication.run(MagazinApplication.class, args);
    }
}
YAML
spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/magazin
    username: app
server:
  port: 8080

Ca să vezi ce auto-configurări s-au aplicat și de ce, pornește aplicația cu --debug. Raportul de condiții e foarte util când ceva nu se configurează cum te aștepți. Versiuni: Spring Boot 3.x cere Java 17+ și a trecut de la javax.* la jakarta.*.

Ce urmărește intervievatorul: Întrebarea verifică dacă înțelegi ce face Boot „magic” în spate. Candidații buni explică auto-configurarea și cum o suprascrii.

68 Junior

Ce este dependency injection și de ce se recomandă injectarea prin constructor?

Răspuns scurt: Dependency injection înseamnă că un obiect își primește dependențele din exterior, în loc să le creeze singur, iar containerul Spring le construiește și le leagă. Injectarea prin constructor face dependențele explicite și finale, obiectul nu poate exista incomplet și se testează ușor, fără Spring.

Fără DI, o clasă își creează singură dependențele și rămâne legată de implementări concrete:

JAVA
public class ComandaService {
    private final ComandaRepository repo = new JdbcComandaRepository();  // greu de testat
}

Cu DI, Spring (containerul IoC) creează bean-urile și le injectează. Clasa doar declară de ce are nevoie:

JAVA
@Service
public class ComandaService {
    private final ComandaRepository repo;
    private final PlataClient plata;

    public ComandaService(ComandaRepository repo, PlataClient plata) {  // @Autowired e opțional
        this.repo = repo;                                                // când există un singur constructor
        this.plata = plata;
    }
}

Variantele de injectare:

  • prin constructor (recomandată): câmpuri final, obiect complet la creare, dependențe vizibile în semnătură. În teste scrii simplu new ComandaService(mockRepo, mockPlata). Dacă un constructor ajunge la 7–8 parametri, e un semnal că clasa face prea multe;
  • prin setter: pentru dependențe opționale;
  • pe câmp (@Autowired private Repo repo;): scurtă, dar ascunde dependențele, nu permite final și cere reflection sau Spring pentru a fi testată.

Când există mai multe implementări ale aceleiași interfețe, Spring nu știe pe care să o aleagă și aruncă NoUniqueBeanDefinitionException. Rezolvi cu @Primary pe implementarea implicită sau cu @Qualifier("nume") la punctul de injectare.

Un bonus al injectării prin constructor: dependențele circulare (A are nevoie de B, B are nevoie de A) sunt descoperite la pornire. Din Spring Boot 2.6 ele sunt interzise implicit, iar ciclul e de obicei un semn de design de revizuit.

Ce urmărește intervievatorul: Este probabil cea mai importantă întrebare de bază despre Spring. Intervievatorul vrea motivația (testare, imuabilitate), nu doar definiția.

69 Junior

Care este diferența dintre @Component, @Service, @Repository, @Controller și @RestController?

Răspuns scurt: Toate marchează o clasă ca bean descoperit prin component scanning. @Service și @Repository sunt specializări semantice ale lui @Component, iar @Repository traduce în plus excepțiile de persistență. @Controller întoarce view-uri, iar @RestController (= @Controller + @ResponseBody) scrie răspunsul direct, de obicei JSON.

@SpringBootApplication pornește component scanning în pachetul clasei principale și în subpachete. Orice clasă adnotată cu @Component sau cu o specializare a ei devine bean.

  • @Component: generic, pentru clase utilitare sau adaptoare;
  • @Service: logica de business. Tehnic e identic cu @Component, dar comunică intenția și poate fi folosit în reguli de arhitectură sau aspecte;
  • @Repository: accesul la date. În plus, activează traducerea excepțiilor specifice (de exemplu din Hibernate) în ierarhia DataAccessException din Spring. Interfețele Spring Data JPA nu au nevoie de adnotare, sunt detectate automat;
  • @Controller: Spring MVC clasic, metodele întorc numele unui view (Thymeleaf);
  • @RestController: fiecare metodă are implicit @ResponseBody, iar rezultatul e serializat (JSON prin Jackson).
JAVA
@RestController
@RequestMapping("/api/produse")
public class ProdusController {
    private final ProdusService service;
    public ProdusController(ProdusService service) { this.service = service; }

    @GetMapping("/{id}")
    public ProdusDto get(@PathVariable long id) { return service.gaseste(id); }
}

@Service
public class ProdusService {
    private final ProdusRepository repo;
    public ProdusService(ProdusRepository repo) { this.repo = repo; }
    public ProdusDto gaseste(long id) {
        return repo.findById(id).map(ProdusDto::din)
                   .orElseThrow(() -> new ProdusNegasitException(id));
    }
}

public interface ProdusRepository extends JpaRepository<Produs, Long> { }

Structura controller → service → repository e convenția uzuală: controller-ul se ocupă de HTTP, service-ul de reguli și tranzacții, repository-ul de date. Pentru clase din biblioteci externe, pe care nu le poți adnota, creezi bean-ul cu o metodă @Bean într-o clasă @Configuration.

Ce urmărește intervievatorul: Verifică dacă știi stereotipurile și structura pe straturi. Detaliul despre traducerea excepțiilor la @Repository e cel pe care puțini îl știu.

70 Junior

Cum construiești un endpoint REST în Spring Boot? Care e diferența dintre @PathVariable, @RequestParam și @RequestBody?

Răspuns scurt: Creezi un @RestController cu metode adnotate @GetMapping, @PostMapping etc. @PathVariable citește o bucată din cale (/produse/42), @RequestParam un parametru din query string (?pagina=2), iar @RequestBody deserializează corpul JSON al cererii într-un obiect. Întorci coduri HTTP potrivite prin ResponseEntity.

JAVA
@RestController
@RequestMapping("/api/produse")
public class ProdusController {
    private final ProdusService service;
    public ProdusController(ProdusService service) { this.service = service; }

    @GetMapping("/{id}")                                   // GET /api/produse/42
    public ProdusDto unul(@PathVariable long id) {
        return service.gaseste(id);                        // 200 OK
    }

    @GetMapping                                            // GET /api/produse?categorie=carti&pagina=0
    public List<ProdusDto> lista(@RequestParam(required = false) String categorie,
                                 @RequestParam(defaultValue = "0") int pagina) {
        return service.cauta(categorie, pagina);
    }

    @PostMapping                                           // POST cu JSON în corp
    public ResponseEntity<ProdusDto> creeaza(@Valid @RequestBody ProdusNou cerere) {
        ProdusDto creat = service.creeaza(cerere);
        return ResponseEntity.created(URI.create("/api/produse/" + creat.id())).body(creat); // 201
    }

    @DeleteMapping("/{id}")
    @ResponseStatus(HttpStatus.NO_CONTENT)                 // 204
    public void sterge(@PathVariable long id) { service.sterge(id); }
}

public record ProdusNou(@NotBlank String nume, @Positive BigDecimal pret) {}

Când folosești ce:

  • @PathVariable: identifică resursa (/produse/42);
  • @RequestParam: filtre, sortare, paginare, parametri opționali;
  • @RequestBody: datele pentru creare sau actualizare, în format JSON.

Bune practici: folosește DTO-uri separate (aici records) în loc să expui entitățile JPA, ca să nu scapi câmpuri interne și să nu ai probleme cu relațiile lazy la serializare. Validează cu @Valid și adnotările Jakarta Validation. Tratează erorile centralizat, cu @RestControllerAdvice și @ExceptionHandler, ca un ProdusNegasitException să devină 404, iar o validare eșuată 400. Respectă semantica HTTP: GET nu modifică date, POST creează, PUT înlocuiește, PATCH modifică parțial, DELETE șterge.

Ce urmărește intervievatorul: Verifică dacă ai construit efectiv un API. Intervievatorul urmărește codurile HTTP corecte, DTO-urile și validarea, nu doar adnotările.

71 Mid

Ce scope-uri pot avea bean-urile Spring? Este un bean singleton thread-safe?

Răspuns scurt: Scope-ul implicit e singleton: o singură instanță per container. Mai există prototype (instanță nouă la fiecare injectare) și, în aplicații web, request, session și application. Un singleton nu e automat thread-safe: e partajat de toate cererile, deci nu trebuie să țină stare mutabilă.

Scope-uri:

  • singleton (implicit): o instanță, creată la pornire și partajată de toți;
  • prototype: o instanță nouă de fiecare dată când bean-ul e cerut de container. Spring nu gestionează distrugerea lui;
  • request, session, application, websocket: în aplicațiile web, câte o instanță per cerere HTTP, per sesiune etc.
JAVA
@Service
public class RaportService {
    private int procesate = 0;                 // PERICOL: stare partajată între cereri
    private final List<String> erori = new ArrayList<>(); // PERICOL

    public Raport genereaza(Cerere c) {
        procesate++;                           // race condition sub încărcare
        // ...
    }
}

Tomcat procesează fiecare cerere HTTP pe un thread separat, deci aceeași instanță de RaportService e folosită simultan de multe thread-uri. Un singleton e thread-safe doar dacă e fără stare (stateless) sau dacă starea e imuabilă ori protejată corect (AtomicInteger, ConcurrentHashMap). Datele specifice unei cereri stau în variabile locale și parametri, nu în câmpuri.

Capcana cu prototype: dacă injectezi un bean prototype într-un singleton, injectarea se face o singură dată, la crearea singleton-ului, deci primești practic tot o singură instanță. Soluții: ObjectProvider<T>, cu getObject() la fiecare utilizare, sau un proxy de scope.

JAVA
@Service
public class ExportService {
    private final ObjectProvider<ExportContext> contexte;
    public ExportService(ObjectProvider<ExportContext> contexte) { this.contexte = contexte; }
    public void exporta() {
        ExportContext ctx = contexte.getObject();   // instanță nouă de fiecare dată
    }
}

Ciclul de viață al unui bean: instanțiere, injectarea dependențelor, @PostConstruct, utilizare, @PreDestroy la oprire.

Ce urmărește intervievatorul: Este o întrebare de mid foarte frecventă. Greșeala gravă e să crezi că singleton înseamnă thread-safe și să ții stare per cerere în câmpuri.

72 Mid

Cum funcționează @Transactional? De ce uneori nu are niciun efect?

Răspuns scurt: Spring creează un proxy în jurul bean-ului. Proxy-ul pornește tranzacția înainte de metodă și face commit la final sau rollback la excepție. Nu are efect la apeluri din aceeași clasă (self-invocation), pe metode private și, implicit, nu face rollback la excepții checked.

Când un bean are metode @Transactional, Spring nu injectează obiectul tău, ci un proxy (JDK dynamic proxy sau o subclasă generată cu CGLIB). Apelul trece prin proxy, care deschide tranzacția, apelează metoda reală și apoi face commit sau rollback.

JAVA
@Service
public class ComandaService {

    @Transactional
    public void plaseaza(Comanda c) {
        comandaRepo.save(c);
        stocService.scade(c.produse());   // dacă aruncă RuntimeException: rollback total
    }

    public void importa(List<Comanda> comenzi) {
        comenzi.forEach(this::plaseaza);  // self-invocation: NU trece prin proxy, fără tranzacție
    }
}

Situații în care @Transactional „nu merge”:

  • self-invocation: this.plaseaza() ocolește proxy-ul. Soluții: muți metoda într-un alt bean sau pui tranzacția pe metoda apelantă;
  • metode private (sau final, cu CGLIB): proxy-ul nu le poate intercepta;
  • excepții checked: implicit, rollback se face doar pentru RuntimeException și Error. Pentru altele: @Transactional(rollbackFor = Exception.class);
  • excepția prinsă în metodă: dacă faci catch și nu o arunci mai departe, proxy-ul vede o terminare normală și face commit;
  • obiectul a fost creat cu new, nu de Spring, deci nu are proxy.

Alte detalii utile:

  • @Transactional(readOnly = true) pe citiri: Hibernate poate sări peste dirty checking, iar unele drivere sau baze de date optimizează;
  • tranzacția ține ocupată o conexiune din pool. Nu face apeluri HTTP lente în interiorul ei;
  • pune adnotarea pe stratul de service, care definește unitatea de lucru, nu pe controller și nici pe fiecare metodă de repository.

Ce urmărește intervievatorul: Este întrebarea de mid preferată despre Spring. Intervievatorul vrea mecanismul de proxy și capcana self-invocation, care produce bug-uri reale.

73 Mid

Care este diferența dintre JPA, Hibernate și Spring Data JPA? Ce stări poate avea o entitate?

Răspuns scurt: JPA (azi Jakarta Persistence) este specificația standard de ORM. Hibernate este cea mai folosită implementare a ei. Spring Data JPA stă deasupra și generează repository-uri din interfețe. O entitate poate fi transient, managed, detached sau removed, în raport cu persistence context-ul.

  • JPA definește API-ul: adnotările (@Entity, @Id, @OneToMany), EntityManager și limbajul JPQL. Nu face nimic singur.
  • Hibernate implementează JPA: generează SQL, gestionează cache-ul de nivel 1, lazy loading și dirty checking.
  • Spring Data JPA elimină codul repetitiv: scrii o interfață, iar implementarea e generată, inclusiv query-uri derivate din numele metodelor.
JAVA
@Entity
public class Client {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String email;
    protected Client() {}                      // cerut de JPA
    public Client(String email) { this.email = email; }
    public void setEmail(String email) { this.email = email; }
}

public interface ClientRepository extends JpaRepository<Client, Long> {
    Optional<Client> findByEmail(String email);                    // query derivat
    @Query("select c from Client c where c.email like %:domeniu")
    List<Client> dinDomeniu(@Param("domeniu") String domeniu);
}

Stările unei entități:

  • transient: creată cu new, necunoscută de JPA;
  • managed: atașată persistence context-ului (după persist, find sau un query, în cadrul tranzacției). Orice modificare e detectată automat (dirty checking) și scrisă la flush sau commit, fără save();
  • detached: contextul s-a închis (tranzacția s-a terminat). Modificările nu mai sunt urmărite; merge() le copiază înapoi într-o instanță managed;
  • removed: marcată pentru ștergere la flush.
JAVA
@Transactional
public void schimbaEmail(long id, String nou) {
    Client c = repo.findById(id).orElseThrow();   // managed
    c.setEmail(nou);                              // UPDATE generat automat la commit
}

Mulți candidați cred că trebuie apelat save() după fiecare modificare. Înțelegerea dirty checking-ului explică și de ce apar uneori UPDATE-uri „neașteptate” în loguri.

Ce urmărește intervievatorul: Verifică dacă înțelegi straturile și ciclul de viață al entităților. Dirty checking-ul e conceptul care separă candidații care au lucrat serios cu JPA.

74 Mid

Ce este problema N+1 în Hibernate și cum o rezolvi?

Răspuns scurt: Problema N+1 apare când încarci N entități cu un query, apoi accesezi o relație lazy a fiecăreia, iar Hibernate execută câte un query în plus pentru fiecare: 1 + N query-uri. Se rezolvă cu JOIN FETCH, @EntityGraph, batch fetching sau proiecții DTO.

JAVA
@Entity
public class Comanda {
    @Id Long id;
    @ManyToOne(fetch = FetchType.LAZY) Client client;
    @OneToMany(mappedBy = "comanda") List<Linie> linii;    // LAZY implicit
}

List<Comanda> comenzi = comandaRepo.findAll();             // 1 query
for (Comanda c : comenzi) {
    System.out.println(c.getLinii().size());               // câte un query pentru fiecare comandă
}
// 100 de comenzi => 101 query-uri

Pe date de test cu 5 rânduri nu observi nimic. În producție, cu mii de rânduri, pagina devine lentă și baza de date e inundată de query-uri mici.

Cum o detectezi: activezi logarea SQL în dezvoltare (spring.jpa.show-sql=true sau, mai bine, logging.level.org.hibernate.SQL=DEBUG) și numeri query-urile. Statisticile Hibernate (hibernate.generate_statistics=true) sau unelte dedicate pot face din asta un test care pică.

Cum o rezolvi:

JAVA
// 1. JOIN FETCH în JPQL
@Query("select distinct c from Comanda c join fetch c.linii where c.status = :s")
List<Comanda> cuLinii(@Param("s") Status s);

// 2. @EntityGraph pe metoda din repository
@EntityGraph(attributePaths = {"client", "linii"})
List<Comanda> findByStatus(Status s);
  • batch fetching: @BatchSize(size = 50) pe relație sau hibernate.default_batch_fetch_size, ca relațiile să fie încărcate în loturi, cu IN (...). Funcționează bine și cu paginarea;
  • proiecții DTO: dacă ai nevoie doar de câteva câmpuri, un query care întoarce direct un record e cel mai eficient.

Atenție: JOIN FETCH pe o colecție combinat cu paginare face ca Hibernate să pagineze în memorie (cu avertismentul HHH90003004 în Hibernate 6) sau dă rezultate duplicate. Iar FetchType.EAGER nu e o soluție: încarcă relația peste tot, inclusiv unde nu ai nevoie, și poate produce tot N+1.

Ce urmărește intervievatorul: Este probabil cea mai întrebată problemă de performanță cu JPA. Intervievatorul vrea cauza, detectarea și cel puțin două soluții, cu limitele lor.

75 Mid

Care este diferența dintre FetchType.LAZY și EAGER? De ce apare LazyInitializationException?

Răspuns scurt: LAZY încarcă relația abia la primul acces, printr-un proxy. EAGER o încarcă imediat, odată cu entitatea. LazyInitializationException apare când accesezi o relație lazy după ce sesiunea Hibernate s-a închis, de exemplu în controller sau la serializarea JSON, în afara tranzacției.

Valorile implicite din JPA: @ManyToOne și @OneToOne sunt EAGER, @OneToMany și @ManyToMany sunt LAZY. Recomandarea uzuală e să faci toate relațiile LAZY și să încarci explicit ce îți trebuie pentru fiecare caz de utilizare.

JAVA
@ManyToOne(fetch = FetchType.LAZY)
private Client client;

Cu LAZY, Hibernate pune în locul relației un proxy sau o colecție neinițializată. La primul acces, execută query-ul, dar doar dacă persistence context-ul (sesiunea) e încă deschis.

JAVA
@Service
public class ComandaService {
    @Transactional(readOnly = true)
    public Comanda gaseste(long id) { return repo.findById(id).orElseThrow(); }
}

// în controller, după ce tranzacția s-a închis:
Comanda c = service.gaseste(1L);
c.getLinii().size();   // LazyInitializationException: could not initialize proxy - no Session

Soluții corecte:

  • încarci datele necesare în service, în tranzacție, cu JOIN FETCH sau @EntityGraph;
  • transformi în DTO în interiorul tranzacției și returnezi DTO-ul, nu entitatea. E cea mai curată variantă și rezolvă și problemele de serializare JSON (bucle infinite pe relațiile bidirecționale, câmpuri interne expuse).

Soluții de evitat:

  • să schimbi relația în EAGER „ca să meargă”: încarci date inutile peste tot;
  • hibernate.enable_lazy_load_no_trans=true: deschide câte o sesiune nouă pentru fiecare acces, adică N+1 ascuns;
  • să te bazezi pe Open Session In View. Spring Boot îl activează implicit (spring.jpa.open-in-view=true) și afișează un avertisment la pornire. Ține conexiunea la baza de date ocupată pe toată durata cererii, inclusiv la randare. Multe echipe îl dezactivează și încarcă explicit datele în service.

Ce urmărește intervievatorul: Verifică dacă înțelegi legătura dintre lazy loading și durata sesiunii. Intervievatorul apreciază când candidatul știe de open-in-view și de ce e controversat.

76 Mid

Cum scrii un test unitar pentru un service Spring cu JUnit 5 și Mockito?

Răspuns scurt: Creezi service-ul direct, cu dependențele înlocuite de mock-uri (@Mock, @InjectMocks, cu MockitoExtension), definești comportamentul cu when(...).thenReturn(...), apelezi metoda și verifici rezultatul cu assert-uri și interacțiunile cu verify(). Nu pornești contextul Spring.

Un test unitar verifică o singură clasă, izolată de baza de date și de rețea. Rulează în milisecunde, deci poți avea sute de teste.

JAVA
@ExtendWith(MockitoExtension.class)
class ComandaServiceTest {

    @Mock ComandaRepository repo;
    @Mock StocClient stoc;
    @InjectMocks ComandaService service;     // creat cu mock-urile prin constructor

    @Test
    void plaseazaComandaCandStoculEsteSuficient() {
        Comanda c = new Comanda(1L, "carte", 2);
        when(stoc.disponibil("carte")).thenReturn(5);
        when(repo.save(any(Comanda.class))).thenAnswer(inv -> inv.getArgument(0));

        Comanda rezultat = service.plaseaza(c);

        assertEquals(Status.CONFIRMATA, rezultat.getStatus());
        verify(stoc).rezerva("carte", 2);
    }

    @Test
    void aruncaExceptieCandStoculEsteInsuficient() {
        when(stoc.disponibil("carte")).thenReturn(1);

        StocInsuficientException ex = assertThrows(StocInsuficientException.class,
                () -> service.plaseaza(new Comanda(1L, "carte", 2)));

        assertTrue(ex.getMessage().contains("carte"));
        verify(repo, never()).save(any());
    }
}

Structura Arrange, Act, Assert (sau Given, When, Then) face testul ușor de citit. Numele testului descrie comportamentul, nu metoda.

Bune practici:

  • testează comportamentul, nu implementarea. Prea multe verify fac testele fragile la refactorizare;
  • un test verifică un singur scenariu; folosește @ParameterizedTest cu @CsvSource pentru variații de date;
  • nu face mock la obiectele de valoare (DTO-uri, records) și nici la clasa testată;
  • Mockito, în modul strict din MockitoExtension, raportează stub-urile nefolosite, semn că testul are cod inutil;
  • AssertJ (assertThat(x).isEqualTo(...)) oferă mesaje de eroare mai clare și e inclus în spring-boot-starter-test.

Ce urmărește intervievatorul: Verifică dacă scrii teste în mod obișnuit. Intervievatorul urmărește izolarea, structura testului și testarea cazurilor de eroare, nu doar a celui fericit.

77 Senior

Cum testezi integrarea într-o aplicație Spring Boot? Când folosești @SpringBootTest, @WebMvcTest, @DataJpaTest și Testcontainers?

Răspuns scurt: @SpringBootTest pornește tot contextul, pentru teste end-to-end. @WebMvcTest încarcă doar stratul web, cu MockMvc, iar @DataJpaTest doar stratul JPA. Testcontainers rulează o bază de date reală (de exemplu PostgreSQL) în Docker, ca testele să folosească același motor ca producția.

O strategie echilibrată are multe teste unitare rapide, un număr moderat de teste pe felii (slice tests) și câteva teste end-to-end.

@WebMvcTest verifică maparea HTTP, validarea, serializarea JSON și tratarea erorilor, cu service-ul înlocuit de un mock:

JAVA
@WebMvcTest(ProdusController.class)
class ProdusControllerTest {
    @Autowired MockMvc mvc;
    @MockitoBean ProdusService service;      // Spring Boot 3.4+; înainte: @MockBean

    @Test
    void intoarce404CandProdusulNuExista() throws Exception {
        when(service.gaseste(99L)).thenThrow(new ProdusNegasitException(99L));
        mvc.perform(get("/api/produse/99"))
           .andExpect(status().isNotFound());
    }
}

@DataJpaTest verifică query-urile, maparea entităților și constrângerile. Implicit, rulează fiecare test într-o tranzacție anulată la final.

Testcontainers rezolvă o problemă reală: H2 în memorie nu se comportă identic cu PostgreSQL (tipuri de date, funcții SQL, constrângeri, ON CONFLICT). Un test verde pe H2 poate ascunde un query care pică în producție.

JAVA
@SpringBootTest
@Testcontainers
class ComandaFlowIT {
    @Container
    @ServiceConnection                      // Spring Boot 3.1+: configurează automat datasource-ul
    static PostgreSQLContainer<?> db = new PostgreSQLContainer<>("postgres:16-alpine");

    @Autowired ComandaService service;

    @Test
    void comandaEsteSalvataSiStoculScade() { /* ... */ }
}

@SpringBootTest încarcă toată aplicația și e cel mai lent. Îl folosești pentru fluxuri complete. Spring refolosește contextul între clasele de test cu aceeași configurație, așa că abuzul de @MockitoBean diferite în fiecare clasă invalidează cache-ul și încetinește suita.

La nivel senior se discută și ce nu testezi: getteri, configurări triviale. Testele lente sau instabile (flaky) se repară imediat, altfel echipa începe să le ignore.

Ce urmărește intervievatorul: Intervievatorul vrea o strategie de testare, nu doar adnotări. Argumentul pentru Testcontainers în locul lui H2 e cel care arată experiență.

78 Senior

Ce înseamnă propagarea tranzacțiilor în Spring? Când folosești REQUIRED și REQUIRES_NEW?

Răspuns scurt: Propagarea decide ce se întâmplă când o metodă tranzacțională e apelată din altă tranzacție. REQUIRED (implicit) se alătură tranzacției existente sau creează una. REQUIRES_NEW suspendă tranzacția curentă și pornește una independentă, utilă pentru audit sau loguri care trebuie salvate chiar dacă operația principală eșuează.

Valori principale ale propagation:

  • REQUIRED (implicit): dacă există o tranzacție, o folosește; altfel creează una;
  • REQUIRES_NEW: suspendă tranzacția curentă și pornește una nouă, cu commit sau rollback independent;
  • NESTED: savepoint în aceeași tranzacție. Funcționează cu DataSourceTransactionManager (JDBC), dar nu e suportat de JpaTransactionManager;
  • SUPPORTS, NOT_SUPPORTED, MANDATORY, NEVER: rulează cu sau fără tranzacție, după reguli.

Capcana cu REQUIRED: o excepție într-o metodă internă marchează toată tranzacția pentru rollback, chiar dacă o prinzi în metoda exterioară.

JAVA
@Service
class ComandaService {
    @Transactional
    public void plaseaza(Comanda c) {
        repo.save(c);
        try {
            puncteService.acorda(c);         // REQUIRED, aruncă RuntimeException
        } catch (RuntimeException e) {
            log.warn("Punctele nu s-au acordat", e);
        }
    }   // la commit: UnexpectedRollbackException, comanda NU e salvată
}

Proxy-ul lui acorda a marcat tranzacția comună ca rollback-only. Dacă vrei ca eșecul punctelor să nu afecteze comanda, acorda trebuie să ruleze în propria tranzacție:

JAVA
@Service
class AuditService {
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void inregistreaza(String eveniment) { auditRepo.save(new Audit(eveniment)); }
}

Atenție la REQUIRES_NEW: folosește o a doua conexiune din pool cât timp prima e suspendată. Sub încărcare, cu un pool mic, poți bloca aplicația (pool exhaustion). În plus, metoda trebuie să fie în alt bean, altfel self-invocation ocolește proxy-ul.

Separat de propagare există izolarea (isolation = Isolation.REPEATABLE_READ etc.), care controlează ce vede tranzacția din modificările altor tranzacții. Cele mai multe aplicații rămân pe nivelul implicit al bazei de date.

Ce urmărește intervievatorul: La senior, intervievatorul urmărește capcanele reale: UnexpectedRollbackException și consumul dublu de conexiuni cu REQUIRES_NEW.

79 Senior

Cum ai securiza un API REST construit cu Spring Boot?

Răspuns scurt: Folosești Spring Security cu autentificare stateless, de obicei token-uri JWT emise de un server OAuth2 sau OIDC și validate ca resource server. Adaugi autorizare pe roluri sau permisiuni, HTTPS, validarea inputului, CORS configurat strict, rate limiting și secretele în afara codului.

Securitatea are mai multe straturi. Un răspuns de senior le acoperă pe rând.

Autentificare. Pentru un API consumat de un frontend sau de o aplicație mobilă, varianta uzuală e OAuth2/OIDC: un identity provider (Keycloak sau un serviciu gestionat) emite un JWT semnat, iar aplicația ta îl validează ca resource server. Nu implementa singur login-ul și semnarea token-urilor dacă nu e nevoie.

JAVA
@Configuration
@EnableMethodSecurity
class SecurityConfig {
    @Bean
    SecurityFilterChain api(HttpSecurity http) throws Exception {
        http
            .csrf(csrf -> csrf.disable())     // acceptabil pentru API stateless cu Bearer token
            .sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
            .authorizeHttpRequests(a -> a
                .requestMatchers("/actuator/health").permitAll()
                .requestMatchers(HttpMethod.GET, "/api/produse/**").permitAll()
                .requestMatchers("/api/admin/**").hasRole("ADMIN")
                .anyRequest().authenticated())
            .oauth2ResourceServer(o -> o.jwt(Customizer.withDefaults()));
        return http.build();
    }
}
YAML
spring.security.oauth2.resourceserver.jwt.issuer-uri: https://auth.exemplu.ro/realms/magazin

Autorizare fină cu @PreAuthorize("hasRole('ADMIN') or #id == authentication.name"). Verifică mereu că utilizatorul are dreptul pe resursa anume, nu doar că e logat. Accesul la comanda altcuiva prin schimbarea ID-ului în URL (IDOR) e una dintre cele mai frecvente vulnerabilități.

Restul straturilor: doar HTTPS; parole stocate cu BCryptPasswordEncoder sau Argon2, dacă le gestionezi tu; validarea inputului cu @Valid; query-uri parametrizate; CORS cu origini explicite, nu *; rate limiting pe login și pe endpoint-urile scumpe; mesaje de eroare fără stack trace-uri; secrete în variabile de mediu sau într-un vault, nu în Git; dependențe scanate pentru vulnerabilități cunoscute (OWASP Dependency-Check, Dependabot); endpoint-urile Actuator expuse minimal.

Ghidul de referință pentru verificare este OWASP API Security Top 10.

Ce urmărește intervievatorul: Intervievatorul verifică dacă ai o imagine completă, nu doar „pun JWT”. Autorizarea pe resursă (IDOR) e punctul pe care îl ratează mulți candidați.

80 Senior

Un endpoint care întoarce lista de comenzi devine foarte lent pe măsură ce crește tabela. Cum îl reproiectezi?

Răspuns scurt: Introduci paginare (de preferat keyset pentru volume mari), întorci DTO-uri sau proiecții cu doar câmpurile necesare, elimini N+1, adaugi indexurile potrivite și măsori înainte și după. Pentru exporturi mari folosești streaming sau procesare asincronă, nu un singur răspuns uriaș.

Pornești de la măsurători: câte query-uri se execută, cât durează fiecare, câtă memorie folosește cererea. Apoi lucrezi pe rând la cauzele uzuale.

1. Paginare. Un findAll() fără limită încarcă toată tabela în memorie. Spring Data are suport direct:

JAVA
@GetMapping("/api/comenzi")
public Page<ComandaDto> lista(@PageableDefault(size = 20, sort = "creataLa",
                              direction = Sort.Direction.DESC) Pageable p) {
    return repo.findByClientId(clientCurent(), p).map(ComandaDto::din);
}

Limitează size maxim (spring.data.web.pageable.max-page-size). Page execută și un COUNT(*), scump pe tabele mari; dacă interfața nu are nevoie de numărul total, folosește Slice.

2. Keyset pagination. OFFSET 100000 obligă baza de date să parcurgă și să arunce 100.000 de rânduri. Paginarea după cheie folosește indexul direct:

SQL
SELECT id, total, creata_la FROM comanda
WHERE client_id = ? AND (creata_la, id) < (?, ?)
ORDER BY creata_la DESC, id DESC
LIMIT 20;

3. Proiecții DTO în loc de entități complete: select new ...ComandaDto(c.id, c.total, c.creataLa) from Comanda c ... sau o interfață de proiecție. Mai puține date, fără dirty checking, fără relații lazy.

4. Fără N+1: @EntityGraph sau batch fetching pentru relațiile afișate.

5. Indexuri pe coloanele din WHERE și ORDER BY, aici (client_id, creata_la, id), verificate cu EXPLAIN ANALYZE.

6. Volume foarte mari (exporturi): job asincron care generează fișierul și notifică utilizatorul, sau streaming (Stream<T> din repository, cu @Transactional(readOnly = true)), nu un JSON de sute de MB.

Eventual, adaugi cache pentru date citite des și modificate rar. La final verifici cu un test de încărcare că timpul de răspuns rămâne stabil când volumul crește.

Ce urmărește intervievatorul: Este o întrebare de design pentru senior. Intervievatorul urmărește dacă începi cu măsurarea și dacă știi limitele paginării cu OFFSET.

SQL, Git, Linux și Docker

81 Junior

Care este diferența dintre INNER JOIN, LEFT JOIN și RIGHT JOIN în SQL?

Răspuns scurt: INNER JOIN întoarce doar rândurile care au corespondent în ambele tabele. LEFT JOIN întoarce toate rândurile din tabela din stânga, cu NULL în coloanele din dreapta acolo unde nu există potrivire. RIGHT JOIN face același lucru invers și se folosește rar.

Să luăm tabelele client (id, nume) și comanda (id, client_id, total).

SQL
-- INNER JOIN: doar clienții care au comenzi
SELECT c.nume, o.total
FROM client c
JOIN comanda o ON o.client_id = c.id;

-- LEFT JOIN: toți clienții, inclusiv cei fără comenzi (total = NULL)
SELECT c.nume, o.total
FROM client c
LEFT JOIN comanda o ON o.client_id = c.id;

-- Clienții care NU au nicio comandă
SELECT c.nume
FROM client c
LEFT JOIN comanda o ON o.client_id = c.id
WHERE o.id IS NULL;

-- Număr de comenzi pe client, inclusiv 0
SELECT c.nume, COUNT(o.id) AS nr_comenzi
FROM client c
LEFT JOIN comanda o ON o.client_id = c.id
GROUP BY c.id, c.nume;

Detalii care se cer des:

  • COUNT(o.id) numără doar valorile nenule, deci clienții fără comenzi primesc 0. COUNT(*) le-ar număra ca 1;
  • o condiție pusă pe tabela din dreapta în WHERE (de exemplu WHERE o.total > 100) transformă practic LEFT JOIN-ul în INNER JOIN, pentru că elimină rândurile cu NULL. Dacă vrei să păstrezi toți clienții, pui condiția în ON: LEFT JOIN comanda o ON o.client_id = c.id AND o.total > 100;
  • FULL OUTER JOIN întoarce rândurile din ambele părți, cu NULL unde lipsește corespondentul. Nu există în MySQL;
  • un JOIN pe o relație unu-la-mulți multiplică rândurile din stânga, o cauză frecventă a sumelor greșite în rapoarte.

În JPA, aceleași concepte apar ca join și left join în JPQL.

Ce urmărește intervievatorul: SQL e cerut la aproape orice interviu de Java backend. Capcana cu condiția din WHERE care anulează LEFT JOIN-ul e întrebarea de follow-up preferată.

82 Junior

Scrie un query care afișează departamentele cu mai mult de 5 angajați și salariul mediu al fiecăruia. Care e diferența dintre WHERE și HAVING?

Răspuns scurt: Grupezi cu GROUP BY după departament, calculezi COUNT(*) și AVG(salariu) și filtrezi grupurile cu HAVING COUNT(*) > 5. WHERE filtrează rândurile înainte de grupare, HAVING filtrează grupurile după agregare.

SQL
SELECT d.nume                 AS departament,
       COUNT(*)               AS nr_angajati,
       ROUND(AVG(a.salariu), 2) AS salariu_mediu
FROM angajat a
JOIN departament d ON d.id = a.departament_id
WHERE a.activ = TRUE                    -- filtrează rânduri, înainte de grupare
GROUP BY d.id, d.nume
HAVING COUNT(*) > 5                     -- filtrează grupuri, după agregare
ORDER BY salariu_mediu DESC;

Ordinea logică de execuție explică diferența: FROM și JOIN, apoi WHERE, GROUP BY, HAVING, SELECT, ORDER BY, LIMIT. Din acest motiv:

  • în WHERE nu poți folosi funcții de agregare (WHERE COUNT(*) > 5 dă eroare), pentru că grupurile încă nu există;
  • aliasurile din SELECT nu pot fi folosite, în general, în WHERE, dar pot fi folosite în ORDER BY. Unele baze de date, precum MySQL și PostgreSQL, acceptă aliasuri și în GROUP BY, dar nu e standard;
  • orice coloană din SELECT care nu e agregată trebuie să apară în GROUP BY. MySQL, cu anumite setări, permite altfel, dar rezultatul e imprevizibil.

Pune în WHERE tot ce se poate filtra la nivel de rând. E mai eficient, pentru că grupezi mai puține date și poți folosi indexuri.

Variante de follow-up:

  • angajații care câștigă peste media departamentului lor: subquery corelat sau funcția fereastră AVG(salariu) OVER (PARTITION BY departament_id);
  • al doilea cel mai mare salariu: SELECT DISTINCT salariu FROM angajat ORDER BY salariu DESC LIMIT 1 OFFSET 1 sau DENSE_RANK().

Ce urmărește intervievatorul: Este exercițiul SQL clasic. Intervievatorul verifică GROUP BY, HAVING și dacă știi de ce agregările nu merg în WHERE.

83 Junior

Ce este un index într-o bază de date? Când ajută și când nu?

Răspuns scurt: Un index este o structură separată, de obicei un B-tree, care permite găsirea rapidă a rândurilor după una sau mai multe coloane, fără scanarea întregii tabele. Accelerează WHERE, JOIN și ORDER BY, dar ocupă spațiu și încetinește INSERT, UPDATE și DELETE.

Fără index, un SELECT * FROM comanda WHERE client_id = 42 citește toată tabela (full table scan). Un index B-tree pe client_id ține valorile sortate, cu pointeri spre rânduri, deci căutarea devine logaritmică.

SQL
CREATE INDEX idx_comanda_client ON comanda (client_id);

-- index compus: util pentru filtrare după client și sortare după dată
CREATE INDEX idx_comanda_client_data ON comanda (client_id, creata_la DESC);

CREATE UNIQUE INDEX idx_client_email ON client (email);   -- și constrângere de unicitate

Când ajută:

  • coloane din WHERE, JOIN ... ON și ORDER BY, pe tabele mari;
  • coloane selective, cu multe valori distincte (email, ID-uri). Un index pe o coloană cu două valori (activ) ajută rar;
  • cheile străine: multe baze de date, PostgreSQL inclusiv, nu creează automat index pe coloana de cheie străină, iar JOIN-urile și ștergerile în cascadă devin lente.

Când nu ajută sau nu e folosit:

  • funcții pe coloană: WHERE LOWER(email) = ? nu folosește indexul pe email, ci cere un index pe expresie;
  • LIKE '%text', cu wildcard la început;
  • index compus (a, b) și o condiție doar pe b: regula prefixului din stânga spune că indexul se folosește doar pentru a sau pentru a și b;
  • tabele mici, unde scanarea completă e oricum rapidă;
  • conversii implicite de tip, de exemplu compararea unei coloane text cu un număr.

Costul: fiecare index trebuie actualizat la fiecare scriere și ocupă spațiu. Nu indexa toate coloanele. Verifică planul de execuție cu EXPLAIN (sau EXPLAIN ANALYZE în PostgreSQL) ca să vezi dacă indexul e folosit efectiv.

Ce urmărește intervievatorul: Verifică dacă înțelegi compromisul citire-scriere. Detaliile despre funcțiile pe coloană și ordinea coloanelor în indexul compus arată experiență practică.

84 Junior

Ce este SQL injection și cum o previi în Java?

Răspuns scurt: SQL injection apare când inputul utilizatorului este concatenat în textul unui query și ajunge să fie interpretat ca cod SQL. O previi folosind mereu parametri (PreparedStatement, parametri numiți în JPQL, metodele Spring Data) și drepturi minime pentru utilizatorul bazei de date.

Codul vulnerabil:

JAVA
String sql = "SELECT * FROM utilizator WHERE email = '" + email + "' AND parola_hash = '" + hash + "'";
ResultSet rs = statement.executeQuery(sql);

Dacă cineva trimite ca email ' OR '1'='1' --, query-ul devine:

SQL
SELECT * FROM utilizator WHERE email = '' OR '1'='1' --' AND parola_hash = '...'

Condiția e mereu adevărată, iar restul e comentat. Atacatorul se autentifică fără parolă sau, cu alte variante, poate citi ori șterge date.

Varianta corectă, cu PreparedStatement:

JAVA
String sql = "SELECT id, email FROM utilizator WHERE email = ?";
try (PreparedStatement ps = conexiune.prepareStatement(sql)) {
    ps.setString(1, email);                  // valoarea e trimisă separat de query
    try (ResultSet rs = ps.executeQuery()) {
        while (rs.next()) { /* ... */ }
    }
}

Baza de date primește structura query-ului și valorile separat, deci inputul e tratat mereu ca dată, niciodată ca SQL.

În JPA și Spring Data:

JAVA
@Query("select u from Utilizator u where u.email = :email")
Optional<Utilizator> dupaEmail(@Param("email") String email);   // sigur

// NESIGUR: concatenare în JPQL sau în query nativ
em.createQuery("select u from Utilizator u where u.email = '" + email + "'");

Atenție la părțile care nu pot fi parametrizate, cum sunt numele de coloane la sortare dinamică (ORDER BY + input). Acolo folosești o listă albă de valori permise. Ca apărare în profunzime, utilizatorul cu care se conectează aplicația nu are drepturi de DROP sau de administrare. SQL injection apare constant în listele OWASP Top 10, în categoria Injection.

Ce urmărește intervievatorul: Este o întrebare de securitate de bază pe care orice developer backend trebuie să o știe. Cazul ORDER BY dinamic arată că te-ai gândit dincolo de exemplul clasic.

85 Mid

Ce înseamnă ACID și ce sunt nivelurile de izolare ale tranzacțiilor?

Răspuns scurt: ACID înseamnă atomicitate, consistență, izolare și durabilitate. Nivelurile de izolare (READ UNCOMMITTED, READ COMMITTED, REPEATABLE READ, SERIALIZABLE) stabilesc ce anomalii sunt permise între tranzacții concurente: dirty reads, non-repeatable reads, phantom reads. PostgreSQL folosește implicit READ COMMITTED.

ACID:

  • Atomicitate: toate operațiile tranzacției reușesc sau niciuna. Un transfer nu poate retrage banii fără să-i depună;
  • Consistență: se trece dintr-o stare validă în alta, cu constrângerile respectate;
  • Izolare: tranzacțiile concurente nu se influențează în moduri nepermise;
  • Durabilitate: după commit, datele rămân, chiar dacă serverul cade imediat.

Anomaliile pe care le controlează izolarea:

  • dirty read: citești date încă necomise de altă tranzacție, care poate face rollback;
  • non-repeatable read: citești același rând de două ori și primești valori diferite, pentru că altă tranzacție l-a modificat între timp;
  • phantom read: același query cu WHERE întoarce alt set de rânduri, pentru că s-au inserat rânduri noi;
  • lost update: două tranzacții citesc aceeași valoare, o modifică și ultima scriere o suprascrie pe prima.

Nivelurile standard:

  • READ UNCOMMITTED: permite toate anomaliile;
  • READ COMMITTED: fără dirty reads. Implicit în PostgreSQL, Oracle și SQL Server;
  • REPEATABLE READ: fără non-repeatable reads. Implicit în MySQL InnoDB;
  • SERIALIZABLE: tranzacțiile se comportă ca și cum ar rula una după alta. La conflict, aplicația trebuie să reîncerce.

Lost update apare des la „citește stocul, scade, salvează”. Soluții: optimistic locking cu @Version în JPA, care aruncă OptimisticLockException la conflict, sau pessimistic locking (SELECT ... FOR UPDATE, prin @Lock(LockModeType.PESSIMISTIC_WRITE)), ori un UPDATE stoc SET cantitate = cantitate - 1 WHERE id = ? AND cantitate > 0 atomic.

JAVA
@Entity
class Produs {
    @Id Long id;
    int stoc;
    @Version Long versiune;   // UPDATE ... WHERE id = ? AND versiune = ?
}

Ce urmărește intervievatorul: Verifică dacă înțelegi concurența la nivelul bazei de date, ceva ce afectează direct corectitudinea aplicației. Exemplul cu @Version leagă teoria de Java.

86 Junior

Care este diferența dintre git merge și git rebase? Când îl folosești pe fiecare?

Răspuns scurt: merge unește două ramuri printr-un commit de merge și păstrează istoria exact cum a fost. rebase mută commit-urile tale peste vârful altei ramuri, rescriind istoria într-o linie dreaptă. Faci rebase pe ramura ta locală înainte de pull request, dar nu rescrii istoria ramurilor partajate.

Să presupunem că ai creat feature/plata din main, iar între timp au apărut commit-uri noi pe main.

Merge:

BASH
git switch feature/plata
git merge main          # creează un commit de merge care are doi părinți

Istoria arată exact ce s-a întâmplat, cu ramificații. Nu rescrie commit-uri existente, deci e sigur pe ramuri pe care lucrează mai mulți oameni. Dezavantajul: multe commit-uri de merge fac istoria greu de citit.

Rebase:

BASH
git switch feature/plata
git fetch origin
git rebase origin/main  # reaplică fiecare commit al tău peste ultimul main
# la conflict: rezolvi, apoi git add <fisier> și git rebase --continue
git push --force-with-lease

Rezultatul e o istorie liniară, ca și cum ai fi început lucrul de pe ultimul main. Commit-urile primesc hash-uri noi, deci ramura trebuie împinsă cu force. --force-with-lease e varianta sigură: refuză push-ul dacă altcineva a adăugat între timp commit-uri pe ramura remote.

Regula de aur: nu face rebase pe commit-uri pe care alții le-au preluat deja (de exemplu main sau o ramură comună). Le-ai rescrie istoria și ar ajunge cu commit-uri duplicate și conflicte.

Utilizări practice:

  • rebase pe ramura ta de feature, ca să o aduci la zi și să rezolvi conflictele înainte de review;
  • git rebase -i ca să comasezi commit-uri de tip „fix typo” înainte de PR;
  • merge (sau „squash and merge” din GitHub sau GitLab) pentru integrarea PR-ului în main, după convenția echipei.

Dacă ceva iese prost, git reflog îți arată starea anterioară, iar git rebase --abort anulează un rebase în curs.

Ce urmărește intervievatorul: Verifică dacă lucrezi sigur cu Git în echipă. Regula despre ramurile partajate și --force-with-lease sunt punctele urmărite.

87 Junior

Descrie cum lucrezi cu Git într-o echipă: de la un task nou până la codul ajuns în main. Cum rezolvi un conflict?

Răspuns scurt: Pornești o ramură din main actualizat, faci commit-uri mici, deschizi un pull request, treci prin code review și CI, apoi integrezi. Un conflict se rezolvă local: alegi varianta corectă în fișierele marcate, rulezi testele și finalizezi merge-ul sau rebase-ul.

Un flux tipic (GitHub Flow sau o variantă cu ramuri de feature):

BASH
git switch main
git pull                                   # main la zi
git switch -c feature/AP-123-export-csv    # ramură cu ID-ul task-ului

# lucrezi, apoi:
git status
git add src/main/java/.../ExportService.java
git commit -m "Adaugă export CSV pentru comenzi"
git push -u origin feature/AP-123-export-csv
# deschizi pull request-ul în GitHub sau GitLab

În PR: descrii ce și de ce ai schimbat, cum se poate testa, legi task-ul din Jira. Pipeline-ul CI rulează build-ul și testele. Colegii fac review, tu răspunzi la comentarii cu commit-uri noi, apoi PR-ul se integrează și ramura se șterge.

Conflictul apare când tu și altcineva ați modificat aceleași linii:

<<<<<<< HEAD
    private static final int LIMITA = 100;
=======
    private static final int LIMITA = 500;
>>>>>>> origin/main

Pașii:

  • git fetch și apoi git merge origin/main sau git rebase origin/main;
  • deschizi fiecare fișier în conflict (git status le listează). IntelliJ are un instrument vizual cu trei panouri;
  • decizi varianta corectă, care poate fi o combinație a celor două. Dacă nu știi de ce colegul a schimbat valoarea, îl întrebi;
  • ștergi marcajele, rulezi build-ul și testele;
  • git add pe fișiere, apoi git commit (la merge) sau git rebase --continue.

Bune practici: commit-uri mici, fiecare cu o singură idee; PR-uri mici, ușor de revizuit; sincronizare frecventă cu main, ca să ai conflicte mici; fără secrete sau fișiere generate în repository (.gitignore pentru target/, .idea/, .env).

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că poți lucra imediat într-o echipă. Rezolvarea conflictului fără a șterge pur și simplu modificările colegului e un semn de maturitate.

88 Junior

Aplicația ta Java rulează pe un server Linux și nu răspunde. Ce comenzi folosești ca să investighezi?

Răspuns scurt: Verifici dacă procesul rulează (ps, systemctl status), dacă portul ascultă (ss -tlnp), citești logurile (tail -f, grep, journalctl), verifici resursele (top, free -h, df -h) și, dacă procesul pare blocat, faci un thread dump cu jcmd sau jstack.

O investigație ordonată, de la general la specific:

BASH
# 1. Procesul rulează?
systemctl status magazin            # dacă rulează ca serviciu systemd
ps aux | grep java                  # PID, memorie, utilizator
jps -l                              # procesele Java (din JDK)

# 2. Ascultă pe port?
ss -tlnp | grep 8080                # sau: netstat -tlnp (mai vechi)
curl -i http://localhost:8080/actuator/health

# 3. Ce spun logurile?
journalctl -u magazin --since "15 min ago"
tail -f /var/log/magazin/app.log
grep -n "ERROR" /var/log/magazin/app.log | tail -20
grep -A 20 "OutOfMemoryError" /var/log/magazin/app.log   # 20 de linii după potrivire
less +G app.log                     # deschide la final; caută cu /text

# 4. Resurse
top                                 # CPU și memorie pe procese (sau htop)
free -h                             # memoria sistemului
df -h                               # disc plin? (cauză clasică: loguri care nu se rotesc)

# 5. Ce face JVM-ul?
jcmd <pid> Thread.print > threads.txt     # thread dump: blocat, deadlock, așteaptă DB?
jcmd <pid> GC.heap_info

Interpretare:

  • procesul lipsește: caută în journalctl sau dmesg dacă nu a fost omorât de OOM killer (dmesg | grep -i killed);
  • procesul există, dar portul nu ascultă: aplicația e încă în pornire sau a eșuat la inițializare;
  • CPU 100% pe procesul Java: posibilă buclă infinită sau GC continuu. Thread dump-ul și logul GC arată care;
  • CPU aproape de zero, dar cererile nu răspund: thread-uri blocate (deadlock, pool de conexiuni epuizat, apel extern fără timeout);
  • disc plin: aplicația nu mai poate scrie loguri sau fișiere temporare.

Reține și diferența dintre kill <pid> (SIGTERM, oprire grațioasă) și kill -9 (SIGKILL, fără curățare).

Ce urmărește intervievatorul: Verifică dacă te descurci în afara IDE-ului. Intervievatorul urmărește ordinea logică a investigației, nu doar o listă de comenzi.

89 Junior

Care este diferența dintre o imagine Docker și un container? Scrie un Dockerfile pentru o aplicație Spring Boot.

Răspuns scurt: O imagine este un șablon imuabil, format din straturi, care conține aplicația și tot ce îi trebuie pentru rulare. Un container este o instanță pornită a unei imagini, cu propriul proces, sistem de fișiere izolat și rețea. Din aceeași imagine poți porni oricâte containere.

Analogia din Java: imaginea e clasa, containerul e obiectul. Imaginea se construiește o dată (docker build), se publică într-un registry și rulează identic pe laptop, în CI și în producție.

Un Dockerfile multi-stage, care compilează aplicația într-o imagine și o rulează într-una mai mică:

# Etapa 1: build
FROM maven:3.9-eclipse-temurin-21 AS build
WORKDIR /src
COPY pom.xml .
RUN mvn -q dependency:go-offline          # strat cache-uit cât timp pom.xml nu se schimbă
COPY src ./src
RUN mvn -q package -DskipTests

# Etapa 2: rulare
FROM eclipse-temurin:21-jre
WORKDIR /app
RUN useradd --system app
COPY --from=build /src/target/*.jar app.jar
USER app                                   # nu rula ca root
EXPOSE 8080
ENTRYPOINT ["java", "-XX:MaxRAMPercentage=75", "-jar", "app.jar"]
BASH
docker build -t magazin:1.0 .
docker run -d --name magazin -p 8080:8080 \
  -e SPRING_PROFILES_ACTIVE=prod magazin:1.0
docker ps                       # containere care rulează
docker logs -f magazin          # logurile aplicației
docker exec -it magazin sh      # shell în container
docker stop magazin && docker rm magazin

De ce contează detaliile:

  • straturile se refolosesc din cache. Copierea pom.xml și descărcarea dependențelor înaintea codului sursă înseamnă că o modificare de cod nu mai descarcă din nou toate dependențele;
  • multi-stage lasă Maven și sursele în afara imaginii finale, deci imaginea e mai mică și are mai puține vulnerabilități;
  • imaginea jre în locul celei jdk reduce dimensiunea;
  • un utilizator non-root limitează pagubele în caz de compromitere;
  • configurarea vine din variabile de mediu, deci aceeași imagine merge în toate mediile.

Containerul e efemer: datele scrise în el se pierd la ștergere. Pentru date persistente folosești volume.

Ce urmărește intervievatorul: Docker e acum așteptat și la junior. Intervievatorul urmărește distincția imagine-container și un Dockerfile rezonabil, ideal multi-stage și non-root.

90 Mid

Cum rulezi local aplicația Spring Boot împreună cu PostgreSQL folosind Docker Compose? Cum comunică containerele?

Răspuns scurt: Definești în docker-compose.yml două servicii, app și db. Compose creează o rețea comună în care fiecare serviciu e accesibil după nume, deci aplicația se conectează la jdbc:postgresql://db:5432. Datele bazei stau într-un volum, iar pornirea aplicației se condiționează de un healthcheck al bazei.

YAML
services:
  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_DB: magazin
      POSTGRES_USER: app
      POSTGRES_PASSWORD: ${DB_PASSWORD}       # din fișierul .env, nu din Git
    volumes:
      - pgdata:/var/lib/postgresql/data       # datele supraviețuiesc recreării containerului
    ports:
      - "5432:5432"                           # doar ca să te conectezi din IDE
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U app -d magazin"]
      interval: 5s
      retries: 10

  app:
    build: .
    environment:
      SPRING_DATASOURCE_URL: jdbc:postgresql://db:5432/magazin
      SPRING_DATASOURCE_USERNAME: app
      SPRING_DATASOURCE_PASSWORD: ${DB_PASSWORD}
    ports:
      - "8080:8080"
    depends_on:
      db:
        condition: service_healthy

volumes:
  pgdata:
BASH
docker compose up -d --build
docker compose logs -f app
docker compose down          # oprește și șterge containerele; volumul rămâne
docker compose down -v       # șterge și volumul (pierzi datele)

Cum comunică: Compose creează o rețea bridge pentru proiect, iar DNS-ul intern rezolvă numele serviciului (db) la IP-ul containerului. De aceea, în container, localhost înseamnă containerul însuși, nu baza de date. Aceasta e o greșeală foarte frecventă: aplicația merge din IDE cu localhost:5432, dar pică în container.

ports publică un port pe mașina gazdă și e necesar doar pentru acces din exterior. Containerele din aceeași rețea comunică direct pe portul intern, fără ports.

depends_on simplu așteaptă doar pornirea containerului, nu ca PostgreSQL să accepte conexiuni. De aceea se folosește condition: service_healthy cu un healthcheck. Variabilele SPRING_DATASOURCE_URL etc. suprascriu proprietățile din application.yml prin relaxed binding.

Spring Boot 3.1+ are și modulul spring-boot-docker-compose, care pornește automat serviciile din compose.yaml la rularea aplicației din IDE.

Ce urmărește intervievatorul: Verifică dacă ai lucrat cu un mediu local realist. Confuzia cu localhost în container și lipsa healthcheck-ului sunt problemele pe care intervievatorul vrea să le auzi.

91 Mid

Care este diferența dintre Maven și Gradle? Ce sunt fazele Maven și scope-urile dependențelor?

Răspuns scurt: Ambele gestionează build-ul și dependențele. Maven folosește XML declarativ (pom.xml) și un ciclu de viață fix, cu faze (compile, test, package, install). Gradle folosește un DSL în Groovy sau Kotlin, e mai flexibil și, de obicei, mai rapid datorită build-ului incremental și cache-ului.

Maven are un ciclu de viață standard. Rularea unei faze rulează și toate fazele dinaintea ei:

  • validate, compile, test (testele unitare, prin Surefire), package (creează .jar), verify (testele de integrare, prin Failsafe), install (în repository-ul local ~/.m2), deploy (într-un repository remote).
BASH
mvn clean package            # șterge target/, compilează, testează, împachetează
mvn -DskipTests package      # fără rularea testelor
mvn dependency:tree          # de unde vine o dependență (conflicte de versiuni)
./mvnw spring-boot:run       # Maven Wrapper: aceeași versiune de Maven pentru toți

Scope-urile dependențelor în Maven:

  • compile (implicit): disponibilă peste tot și inclusă în artefact;
  • provided: necesară la compilare, dar furnizată de mediu la rulare (de exemplu Servlet API pe un server de aplicații, Lombok);
  • runtime: doar la rulare, cum sunt driverele JDBC;
  • test: doar pentru teste (JUnit, Mockito).
HTML
<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <scope>runtime</scope>
</dependency>

Echivalentele din Gradle: implementation, compileOnly, runtimeOnly, testImplementation.

KOTLIN
dependencies {
    implementation("org.springframework.boot:spring-boot-starter-web")
    runtimeOnly("org.postgresql:postgresql")
    testImplementation("org.springframework.boot:spring-boot-starter-test")
}

Versiunile dependențelor Spring nu se scriu de mână: vin din BOM-ul Spring Boot (spring-boot-starter-parent sau pluginul io.spring.dependency-management), care garantează versiuni compatibile între ele. Dependențele tranzitive aduc uneori versiuni conflictuale. Maven alege versiunea cea mai apropiată în arbore („nearest wins”), iar Gradle o alege pe cea mai mare, de unde apar surprize de tipul NoSuchMethodError la rulare. Alegerea dintre Maven și Gradle ține de obicei de proiect; important e să știi să citești și să depanezi build-ul.

Ce urmărește intervievatorul: Verifică dacă înțelegi build-ul, nu doar butonul Run din IDE. Scope-urile și conflictele de versiuni tranzitive apar des în proiecte reale.

92 Senior

Un query devine brusc lent în producție. Cum îl investighezi și îl optimizezi?

Răspuns scurt: Identifici query-ul exact (loguri de query-uri lente, pg_stat_statements, APM), îl rulezi cu EXPLAIN ANALYZE ca să vezi planul real, cauți scanări complete, estimări greșite sau sortări pe disc, apoi corectezi: index potrivit, query rescris, statistici actualizate, paginare. Validezi cu date de volum realist.

1. Găsește query-ul. Din aplicație: logarea query-urilor lente din Hibernate (hibernate.session.events.log.LOG_QUERIES_SLOWER_THAN_MS, din Hibernate 5.4.5) sau un APM. Din baza de date, în PostgreSQL: log_min_duration_statement și extensia pg_stat_statements, care arată query-urile după timpul total consumat. Uneori vinovatul nu e un query lent, ci unul rapid executat de mii de ori (N+1).

2. Citește planul real.

SQL
EXPLAIN (ANALYZE, BUFFERS)
SELECT o.id, o.total
FROM comanda o
WHERE o.client_id = 42 AND o.status = 'PLATITA'
ORDER BY o.creata_la DESC
LIMIT 20;

Ce cauți:

  • Seq Scan pe o tabelă mare, acolo unde te așteptai la un index;
  • diferențe mari între rows estimat și actual rows, semn de statistici vechi, care se rezolvă cu ANALYZE comanda;
  • Sort cu external merge Disk: sortarea nu încape în work_mem;
  • Nested Loop pe multe rânduri, unde un hash join ar fi mai potrivit.

3. De ce „brusc”? Volumul a trecut un prag și planul s-a schimbat, un deploy a adus un query nou, statisticile sunt vechi sau există blocări (pg_stat_activity, pg_locks).

4. Repară.

  • index compus potrivit: CREATE INDEX CONCURRENTLY idx_comanda_client_status_data ON comanda (client_id, status, creata_la DESC);. CONCURRENTLY nu blochează scrierile în producție;
  • rescrierea query-ului: fără funcții pe coloanele indexate, fără SELECT *, EXISTS în loc de IN cu subquery mare unde ajută, keyset pagination în loc de OFFSET mare;
  • mai puține date cerute: proiecții, paginare, cache pentru rezultate citite des.

5. Verifică din nou cu EXPLAIN ANALYZE, pe un volum de date realist, și urmărește metrica după deploy. Un index adăugat ajută citirea, dar încetinește scrierile, deci trebuie justificat.

Ce urmărește intervievatorul: La senior, intervievatorul vrea un proces bazat pe date. Mențiunea că problema poate fi un query rapid rulat de mii de ori arată experiență reală.

Comportamentale și HR

93 Junior

Spune-mi câteva lucruri despre tine și de ce ai ales Java.

Răspuns scurt: Un răspuns bun durează 1–2 minute și urmează un fir: ce faci acum, ce ai construit relevant pentru post (proiecte, tehnologii), ce te atrage la Java și la această echipă. Legi totul de rolul pentru care aplici, fără să-ți recitești CV-ul.

Este de obicei prima întrebare și arată cum comunici. O structură care funcționează este prezent, trecut, viitor:

  • Prezent: cine ești profesional acum. „Lucrez de un an ca programator Java junior” sau „Termin un program de reconversie în care am construit aplicații cu Spring Boot și PostgreSQL”.
  • Trecut: una sau două realizări relevante, concrete. Un proiect cu un rezultat clar: ce ai construit, ce tehnologii, ce problemă ai rezolvat. Dacă vii din alt domeniu, spune ce aduci de acolo (lucru cu clienți, procese, rigoare).
  • Viitor: de ce acest rol și această firmă. Arată că ai citit anunțul.

Exemplu de structură pentru un junior:

„Am terminat anul trecut un curs intensiv de Java și de atunci construiesc aplicații
backend. Cel mai complet proiect e un API de rezervări cu Spring Boot, PostgreSQL și
Docker, cu autentificare JWT și teste cu JUnit și Testcontainers; e pe GitHub.
Am ales Java pentru că îmi place să lucrez cu tipuri stricte și cu un ecosistem matur,
folosit în sisteme mari. Mă atrage rolul vostru pentru că lucrați pe produse cu
mulți utilizatori și aș vrea să învăț de la o echipă care face code review serios.”

De ce Java: motivele bune sunt concrete, de exemplu ecosistemul (Spring, instrumentele), tipizarea statică, sistemele mari unde contează stabilitatea sau un proiect anume care ți-a plăcut. Evită răspunsurile care sună doar a „am auzit că se câștigă bine”.

Greșeli frecvente: povestea vieții de la liceu încoace, un monolog lung, critici la adresa angajatorului actual.

Ce urmărește intervievatorul: Intervievatorul evaluează comunicarea, motivația și potrivirea cu rolul. Greșeala tipică este un răspuns lung, fără structură și fără legătură cu postul.

94 Junior

Ai lucrat în Scrum? Descrie cum arată un sprint și care e rolul tău ca developer.

Răspuns scurt: Un sprint durează de obicei una până la patru săptămâni și începe cu sprint planning. Urmează daily scrum-uri scurte, apoi sprint review (demo) și retrospectivă. Ca developer, estimezi, îți asumi task-uri, semnalezi blocajele devreme și livrezi incremente care respectă Definition of Done.

Scrum este un cadru Agile cu trei roluri (responsabilități), în terminologia Scrum Guide 2020: Product Owner (prioritizează backlog-ul și decide ce aduce valoare), Scrum Master (facilitează procesul și înlătură obstacole) și Developers (echipa care construiește produsul).

Evenimentele unui sprint:

  • Sprint Planning: echipa alege din product backlog ce poate livra și stabilește obiectivul sprintului. Poveștile sunt discutate și estimate, adesea în story points, cu Planning Poker;
  • Daily Scrum: maximum 15 minute, în fiecare zi. Nu e un raport către șef, ci coordonare: ce am făcut ieri pentru obiectivul sprintului, ce fac azi, ce mă blochează;
  • Sprint Review: demonstrezi ce s-a livrat și primești feedback de la stakeholderi;
  • Retrospectiva: echipa discută ce a mers bine, ce nu și ce schimbă concret în sprintul următor.

Artefacte: product backlog, sprint backlog și incrementul, care trebuie să respecte Definition of Done (de exemplu: cod revizuit, teste scrise și trecute, documentație, deploy pe mediul de test).

Model de răspuns:

„În proiectul de echipă din curs am lucrat în sprinturi de două săptămâni, cu board
în Jira. La planning estimam în story points; mi-am asumat partea de API pentru
plăți. La un daily am spus din prima zi că documentația furnizorului de plăți era
incompletă, iar Scrum Master-ul ne-a pus în legătură cu ei; altfel am fi pierdut
sprintul. La retrospectivă am propus ca fiecare PR să aibă un reviewer stabilit din
start, și timpul de review a scăzut vizibil.”

Intervievatorul urmărește dacă semnalezi la timp blocajele și dacă înțelegi că un task „aproape gata” nu e gata.

Ce urmărește intervievatorul: Verifică dacă te poți integra în procesul echipei din prima săptămână. Greșeala frecventă e să descrii daily-ul ca pe o raportare către manager.

95 Junior

Povestește un bug greu pe care l-ai rezolvat.

Răspuns scurt: Folosește structura STAR: situația, sarcina ta, acțiunile concrete (cum ai reprodus, ce ipoteze ai testat, ce unelte ai folosit) și rezultatul, plus ce ai schimbat ca bug-ul să nu revină. Concentrează-te pe metoda de depanare, nu doar pe soluție.

Intervievatorul nu caută un bug spectaculos, ci felul în care gândești când ceva nu merge. Structura STAR te ajută să nu te pierzi în detalii:

  • Situația: contextul, pe scurt. Ce aplicație, ce simptom, cât de grav.
  • Sarcina: ce responsabilitate aveai tu.
  • Acțiunile: partea cea mai lungă. Cum ai reprodus problema, ce ipoteze ai avut, cum le-ai eliminat, ce unelte ai folosit (debugger, loguri, thread dump, EXPLAIN, Git bisect), pe cine ai consultat.
  • Rezultatul: ce s-a rezolvat și, important, ce ai făcut ca să nu se repete: un test de regresie, monitorizare, o regulă de code review.

Exemplu de model:

S: În aplicația de rezervări, unii utilizatori primeau din când în când rezervarea
   altcuiva în pagina de confirmare. Nu se reproducea local.
T: Eram pe tura de suport și am preluat bug-ul.
A: Am căutat în loguri tiparul și am observat că apărea doar sub încărcare. Asta
   mi-a sugerat o problemă de concurență. Am citit codul și am găsit un câmp în
   care se ținea rezervarea curentă într-un bean singleton, deci partajat între
   cereri. Am scris un test cu mai multe thread-uri care reproducea problema,
   apoi am mutat valoarea într-o variabilă locală.
R: Testul a trecut, bug-ul nu a mai apărut. Am propus o regulă în code review:
   fără stare mutabilă în bean-urile singleton, și am adăugat testul în suită.

Alege un bug real, de-al tău, pentru că vor urma întrebări. Spune „eu”, nu doar „noi”. Dacă ai avut o ipoteză greșită pe parcurs, spune-o: arată onestitate. Evită bug-urile banale.

Ce urmărește intervievatorul: Se verifică metoda de depanare, perseverența și asumarea. Greșeala tipică e o poveste vagă, fără pași concreți, sau fără ce s-a învățat la final.

96 Junior

Ce faci când te blochezi la un task și nu știi cum să mergi mai departe?

Răspuns scurt: Încerci singur, structurat și cu o limită de timp: documentație, cod existent, un exemplu minim. Dacă nu avansezi, ceri ajutor cu o întrebare bine pregătită (ce ai încercat, ce te aștepți, ce se întâmplă) și anunți devreme dacă e afectat termenul.

Intervievatorul vrea să știe două lucruri: că nu renunți la primul obstacol și că nu stai blocat în tăcere zile întregi. Pentru un junior, al doilea caz e mai costisitor pentru echipă.

O abordare pe care o poți descrie:

  • Înțelege problema: recitește cerința, verifică ce înseamnă „gata”. Uneori blocajul vine dintr-o cerință neclară, iar soluția e o întrebare către Product Owner;
  • Investighează structurat: documentația oficială (Spring, Java), codul existent din proiect care face ceva similar, testele, istoricul din Git (git log, git blame), mesajul exact de eroare;
  • Izolează: un exemplu minim care reproduce problema. De multe ori soluția apare chiar în timpul acestui pas;
  • Pune o limită de timp: de exemplu o oră sau două pe aceeași problemă fără progres, după care ceri ajutor;
  • Cere ajutor bine: un mesaj care poate fi înțeles fără context suplimentar.
„Încerc să salvez o comandă cu liniile ei, dar primesc
TransientPropertyValueException. Am verificat că am cascade pe relație și am
încercat să salvez întâi liniile. Branch-ul e feature/AP-210, testul care pică e
ComandaServiceIT. Ai 10 minute azi să ne uităm împreună?”
  • Comunică impactul: dacă blocajul afectează estimarea, spui la daily, nu în ultima zi a sprintului;
  • Notează ce ai învățat, ca să nu repeți căutarea și ca să poți ajuta un coleg.

Instrumentele de AI pot ajuta la explicarea unei erori, dar ce primești verifici în documentație și cu teste, iar codul pe care nu îl înțelegi nu ajunge în PR. Un astfel de răspuns arată autonomie, respect pentru timpul colegilor și transparență.

Ce urmărește intervievatorul: Verifică autonomia și comunicarea. Răspunsurile extreme, „mă descurc mereu singur” sau „întreb imediat”, sunt ambele semnale negative.

97 Mid

Ce faci când nu ești de acord cu un coleg la code review?

Răspuns scurt: Separi persoana de cod și discuți argumente verificabile: performanță, lizibilitate, riscuri, convențiile echipei. Asculți motivul celuilalt, iar dacă nu ajungeți la un acord, discutați direct sau implicați un al treilea. Contează produsul, nu cine are dreptate.

Code review-ul e un loc firesc pentru dezacorduri. Întrebarea verifică dacă știi să le gestionezi fără să blochezi echipa sau să strici relațiile.

Principii pe care le poți enunța și exemplifica:

  • Comentezi codul, nu persoana: „metoda asta face trei lucruri, ce zici să o împărțim?” în loc de „ai scris prost”;
  • Explici de ce: un comentariu fără motiv e greu de acceptat. „findAll() aici încarcă toată tabela, iar în producție are câteva sute de mii de rânduri” e un argument verificabil;
  • Distingi între blocant și preferință: un bug sau o problemă de securitate trebuie rezolvate; stilul personal e opțional. Multe echipe marchează sugestiile minore cu „nit:”;
  • Asculți: poate colegul știe un context pe care tu nu îl știi;
  • Escaladezi constructiv: dacă nu ajungeți la un acord, întrebați tech lead-ul sau adoptați o regulă de echipă, ca discuția să nu se repete la fiecare PR.

Model STAR:

S: Un coleg mai experimentat a propus în PR-ul meu să înlocuiesc un query JPQL cu
   unul nativ, pentru performanță.
T: Eu credeam că pierdem portabilitatea și verificarea la compilare.
A: Am întrebat ce problemă de performanță a observat. Am rulat amândoi EXPLAIN
   ANALYZE pe datele de test și diferența a fost neglijabilă. Am păstrat JPQL,
   dar am adăugat indexul pe care îl sugerase, care chiar conta.
R: PR-ul s-a integrat în aceeași zi și am stabilit în echipă că schimbările de
   performanță se justifică cu un plan de execuție.

Și invers: comentariile primite nu le iei personal.

Ce urmărește intervievatorul: Intervievatorul evaluează colaborarea și maturitatea emoțională. Răspunsurile care sună a „eu am avut dreptate și el a cedat” sunt un semnal negativ.

98 Mid

Ai estimat un task la trei zile, iar după două zile îți dai seama că mai ai nevoie de încă o săptămână. Ce faci?

Răspuns scurt: Anunți imediat, nu la termen: explici ce ai descoperit, de ce estimarea s-a schimbat și propui opțiuni (reducerea scopului, împărțirea task-ului, ajutor, mutarea termenului). Lași decizia de prioritizare Product Owner-ului sau lead-ului, cu informațiile corecte, apoi analizezi la retrospectivă ce ai ratat la estimare.

Estimările greșite sunt normale în dezvoltarea software, pentru că descoperi complexitatea pe parcurs. Problema reală e să afle echipa prea târziu. Intervievatorul urmărește transparența, asumarea și capacitatea de a propune soluții.

Pași pe care îi poți descrie:

  • Înțelege de ce: ce nu se știa la estimare? O integrare cu un sistem vechi, date murdare, o cerință ascunsă, o dependență de altă echipă?
  • Re-estimează realist, eventual împărțind munca rămasă în bucăți mai mici;
  • Comunică imediat: la daily și direct cu Product Owner-ul sau lead-ul, nu doar o actualizare în Jira;
  • Vino cu opțiuni, nu doar cu problema:
  • livrăm acum varianta minimă (de exemplu exportul fără filtrele avansate), iar restul devine task separat;
  • un coleg care cunoaște sistemul vechi lucrează o zi cu mine;
  • mutăm termenul, dacă funcționalitatea completă e obligatorie;
  • Lasă decizia de prioritate celor care răspund de produs, dar oferă-le toate informațiile;
  • Învață: la retrospectivă, ce semnal puteai prinde mai devreme? Poate un spike (o investigație scurtă, cu durată fixă) înainte de estimare.

Model de răspuns:

„Am avut de integrat facturarea cu un serviciu extern. A doua zi am descoperit că
API-ul lor nu avea endpoint pentru storno, deci trebuia o soluție alternativă. Am
anunțat la daily, cu două variante: lansăm fără storno, cu procedura manuală
documentată, sau amânăm o săptămână. PO-ul a ales prima variantă. De atunci, pentru
integrări externe, propun un spike de o zi înainte de estimare.”

Evită povestea cu nopțile lucrate în secret ca să recuperezi: ascunde problema.

Ce urmărește intervievatorul: Se verifică transparența și orientarea spre soluții. Greșeala tipică e să ascunzi întârzierea până în ultima zi sau să vii doar cu problema, fără opțiuni.

99 Senior

Cum ajuți un developer junior nou în echipă să devină productiv?

Răspuns scurt: Pregătești un onboarding clar (mediu local care pornește ușor, documentație, primul task mic și real), stabilești un coleg de referință, faci pair programming și code review explicativ, oferi feedback des și concret și crești treptat complexitatea și autonomia. Măsori progresul după autonomie, nu după viteză.

La nivel senior, ești evaluat și după cum ridici nivelul celor din jur. Un răspuns bun descrie un sistem, nu doar bunăvoință.

Înainte și în prima săptămână:

  • mediu local reproductibil: un README cu pașii de pornire, docker compose up pentru dependențe, date de test;
  • o imagine de ansamblu: arhitectura, fluxurile principale de business, unde sunt logurile, cum se face deploy;
  • un prim task mic și real, care ajunge în producție în primele zile. Trece prin tot fluxul: ramură, PR, review, CI, deploy.

În primele luni:

  • un coleg de referință (buddy), pe care îl poate întreba fără reținere;
  • pair programming pe task-uri mai complexe, cu juniorul la tastatură;
  • code review explicativ: nu doar „schimbă asta”, ci de ce, cu link spre documentație sau convenții. Evidențiezi și ce e bine făcut;
  • task-uri cu complexitate crescătoare și responsabilitate tot mai mare, de exemplu ownership pe o funcționalitate mică;
  • discuții 1:1 scurte și regulate.

Cultura: încurajezi întrebările, lauzi progresul în public și dai feedbackul critic în privat, concret și la timp.

Model STAR:

S: Am primit în echipă doi juniori din reconversie, într-un proiect fără documentație
   de pornire.
A: Am scris împreună cu ei README-ul, ca exercițiu de onboarding, am creat un
   docker-compose pentru dependențe și am ales pentru fiecare un bug mic din backlog.
   Am făcut pair programming de două ori pe săptămână.
R: Ambii au livrat în producție în prima săptămână, iar README-ul a scurtat și
   onboarding-ul celor care au venit după.

Ce urmărește intervievatorul: Intervievatorul verifică leadership-ul tehnic și empatia. Răspunsurile de tipul „îi trimit documentația și îl las să întrebe” arată lipsă de experiență în mentorat.

100 Senior

Povestește o decizie tehnică importantă pe care ai lua-o altfel dacă ai putea da timpul înapoi.

Răspuns scurt: Alegi o decizie reală, cu impact, explici contextul și argumentele de atunci, ce s-a întâmplat de fapt, ce ai învățat și cum decizi acum diferit (de exemplu documentezi decizia, faci un prototip, stabilești criterii de revenire). Arăți asumare și gândire în compromisuri, nu vinovăție.

Întrebarea testează onestitatea, capacitatea de reflecție și maturitatea în decizii. Un senior care spune că n-a greșit niciodată nu e credibil.

Structură recomandată:

  • Contextul și decizia: ce trebuia rezolvat, ce opțiuni existau, ce ai ales;
  • Argumentele de atunci: arată că decizia a fost rezonabilă cu informațiile disponibile, nu una luată la întâmplare;
  • Ce s-a întâmplat: consecințele concrete (costuri de mentenanță, incidente, timp pierdut);
  • Ce ai făcut când ai văzut problema: cum ai corectat sau ai limitat efectele;
  • Ce ai învățat și ce faci diferit acum, de preferat un proces, nu doar „am fost mai atent”.

Exemplu de model:

„Pentru o aplicație internă cu o echipă de patru oameni, am propus împărțirea în
șase microservicii, ca să fim pregătiți pentru creștere. Argumentul era scalarea
independentă. În practică, traficul a rămas modest, iar fiecare funcționalitate
atingea trei servicii: deploy-uri coordonate, depanare prin loguri distribuite,
tranzacții greu de gestionat. După un an am comasat patru servicii într-un monolit
modular, cu module separate pe domenii.

Acum pornesc de la un monolit bine structurat și extrag un serviciu doar când am un
motiv măsurabil: încărcare diferită, o echipă separată, alt ritm de livrare. Scriu
decizia într-un ADR, cu alternativele și condițiile în care am reconsidera-o.”

Ce face răspunsul puternic: compromisuri explicite (complexitate operațională față de flexibilitate), date concrete, corectarea făcută și un mecanism nou de decizie, cum sunt ADR-urile (Architecture Decision Records). Evită exemplele în care vina e doar a altora și pe cele fără impact real.

Ce urmărește intervievatorul: La senior, intervievatorul caută asumare și gândire în compromisuri. Greșeala tipică e un exemplu banal sau o poveste în care candidatul nu a greșit de fapt.

Întrebări de interviu pe tehnologii

Pregătire de interviu pentru alte meserii

Exerciții rezolvate pentru Java Developer

← 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 Developer, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

De la întrebări la primul job de Java Developer

Traseul de carieră îți pune cursurile în ordine, cu exerciții verificate automat și proiecte despre care poți vorbi la interviu. Primele lecții sunt gratuite.