Purane Java mein List (jisme order hota hai) aur LinkedHashSet/LinkedHashMap (jinme bhi predictable order hota hai) ke paas "first element" ya "last element" nikalne ka koi common, consistent tareeka nahi tha — List.get(0) vs List.get(size()-1), ya alag-alag collections mein alag methods.

Java 21 ne teen naye interfaces diye: SequencedCollection, SequencedSet, SequencedMap — jo List, LinkedHashSet, LinkedHashMap jaise ordered collections ko common methods dete hain: getFirst(), getLast(), addFirst(), addLast(), removeFirst(), removeLast(), aur reversed() (jo collection ko reversed view mein dekhta hai, bina copy banaye).

Real-world use-case: jab kisi list ka "most recent" ya "oldest" item chahiye ho (jaise ek activity feed ya undo history), pehle manual index math karna padta tha — ab getLast()/getFirst() se seedha aur readable code milta hai.

• getFirst() / getLast() — pehla / aakhri element nikalo
• addFirst() / addLast() — shuru / end mein add karo
• removeFirst() / removeLast() — shuru / end se hatao
• reversed() — reversed view, bina copy banaye

List<String> names = new ArrayList<>(List.of("Aman", "Riya", "Zoya"));
System.out.println(names.getFirst());  // Aman
System.out.println(names.getLast());   // Zoya
names.addFirst("Aarav");
System.out.println(names.reversed());  // [Zoya, Riya, Aman, Aarav]

// LinkedHashMap bhi ab yehi methods deta hai:
LinkedHashMap<String, Integer> scores = new LinkedHashMap<>();
scores.put("A", 90);
scores.putFirst("Z", 100); // naya method — sabse pehle daalta hai

Java 17 mein records aaye the data classes ke liye, aur Java 16+ mein instanceof pattern matching aayi thi. Java 21 ne inko combine kar diya — ab record ke andar ke fields ko seedha "destructure" (nikaal) kar sakte ho ek instanceof ya switch check mein, bina record.field() call kiye.

Jaise agar record Point(int x, int y) hai, to if (obj instanceof Point(int x, int y)) likhne se, agar obj ek Point hai, to x aur y directly available ho jaate hain — record ke andar record bhi ho sakta hai (nested destructuring), jo deeply nested data structures ke liye bahut clean code deta hai.

Interview mein record patterns ko sealed classes ke saath combine karke poocha ja sakta hai — dono milkar functional languages jaisa "algebraic data type" pattern dete hain, jaha data ki shape aur usko process karne ka logic dono explicit aur type-safe hote hain.

record Point(int x, int y) {}
record Line(Point start, Point end) {}

Object obj = new Point(3, 4);

// Record pattern — seedha destructure
if (obj instanceof Point(int x, int y)) {
  System.out.println("x=" + x + ", y=" + y);
}

// Nested record pattern
Object line = new Line(new Point(0, 0), new Point(3, 4));
if (line instanceof Line(Point(int x1, int y1), Point(int x2, int y2))) {
  System.out.println("Line from (" + x1 + "," + y1 + ") to (" + x2 + "," + y2 + ")");
}

Java 17 mein ye preview feature tha, Java 21 mein finally stable/final ho gaya. Ab switch expression/statement mein type-based branching, record destructuring, aur guard conditions (when clause) sab ek saath use kar sakte ho.

null bhi ab switch mein directly handle ho sakta hai (case null ->) — pehle switch null par NullPointerException deta tha, isliye alag se null check karna padta tha. Guard condition (when) se ek type-match ke andar bhi extra condition laga sakte ho, jaise case Integer i when i > 0 -> ....

Guard conditions ka order matter karta hai — switch upar se neeche cases check karta hai, isliye specific guard wale cases (jaise when i > 0) ko generic case se pehle rakhna zaroori hai, warna generic case pehle match ho jaayega.

• Type patterns — case Integer i -> ...
• Record patterns — case Point(int x, int y) -> ...
• Guard conditions — case Integer i when i > 0 -> ...
• case null -> — ab directly handle ho sakta hai

Object obj = 42;

String result = switch (obj) {
  case null -> "It's null";
  case Integer i when i > 0 -> "Positive integer: " + i;
  case Integer i -> "Non-positive integer: " + i;
  case String s -> "String: " + s;
  case Point(int x, int y) -> "Point at (" + x + "," + y + ")"; // record pattern bhi
  default -> "Unknown";
};

String concatenation (+ se jodna) ya String.format() dono thode clunky hain lambi strings ke liye. String Templates ek naya syntax lati hain — STR."Hello \{name}!" jaisa — jisme \{...} ke andar directly Java expressions daal sakte ho, aur wo automatically evaluate hoke result mein embed ho jaate hain.

Ye ek preview feature hai Java 21 mein (matlab --enable-preview flag ke saath compile/run karna padta hai, aur future versions mein change bhi ho sakta hai) — lekin ye dikhata hai Java string handling ko kaha le jaa raha hai: readable, type-safe, aur SQL-injection jaisi cheezein bhi easily prevent karne wale custom template processors (jaise SQL processor) ban sakte hain.

Interview mein pucha ja sakta hai STR kya hai — ye ek built-in "template processor" hai (StringTemplate.Processor interface implement karta hai). Developers apna khud ka processor bhi bana sakte hain, jaise ek jo automatically HTML-escape kare XSS se bachne ke liye.

String name = "Aarav";
int age = 25;

// Purana tareeka:
String s1 = "Hello " + name + ", you are " + age + " years old";
String s2 = String.format("Hello %s, you are %d years old", name, age);

// String Template (preview, Java 21):
String s3 = STR."Hello \{name}, you are \{age} years old";
// Expressions bhi chal sakti hain:
String s4 = STR."Next year you'll be \{age + 1}";

Jab ek task ko complete karne ke liye multiple sub-tasks parallel mein chalane padte hain (jaise ek user profile fetch karne ke liye alag-alag services se data, price aur inventory), unhe manually manage karna (ek fail ho jaaye to baaki cancel karna, sabka wait karna, errors handle karna) error-prone hota hai.

StructuredTaskScope in sub-tasks ko ek "structured" tareeke se treat karta hai — parent task tab tak khatam nahi hota jab tak saare child tasks (jo usne start kiye) khatam na ho jaayein, aur agar ek child fail ho, poora group automatically cancel ho sakta hai (fail-fast). Ye virtual threads ke saath milkar concurrent code ko bahut safer aur readable banata hai.

Ye traditional try-catch-finally ke saath manual thread management se bahut zyada readable hai — purane tareeke mein agar ek task fail ho jaaye, doosre tasks ko manually cancel karna padta tha aur thread leaks ka risk rehta tha, StructuredTaskScope ye sab automatically handle kar leta hai.

try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
  Future<String> user = scope.fork(() -> fetchUser());
  Future<String> orders = scope.fork(() -> fetchOrders());

  scope.join();           // dono ka wait karo
  scope.throwIfFailed();  // agar koi fail hua, exception throw karo

  System.out.println(user.resultNow() + orders.resultNow());
} // scope band hote hi saare threads cleanup ho jaate hain

Java 17 mein ZGC (Z Garbage Collector) experimental tha, low-latency ke liye design kiya gaya (pause times consistently 10ms se kam) — lekin ye "generational" nahi tha, matlab young aur old objects ko alag treat nahi karta tha, jisse kuch workloads mein efficiency kam ho jaati thi.

Java 21 mein ZGC "generational" ban gaya (dusre modern GCs jaise G1 ki tarah) — young generation (jaha zyadatar objects jaldi "die" ho jaate hain) ko zyada baar aur efficiently collect karta hai, old generation ko kam baar. Isse throughput aur memory efficiency dono behtar hue, bina low-latency guarantee khoye.

Interview mein pucha ja sakta hai ki generational ZGC kyun zaroori tha jab G1 already generational tha — jawaab: G1 generational hone ke bawajood ZGC jaisa ultra-low pause time nahi de sakta tha; Generational ZGC dono cheezein — low pause time AND generational efficiency — ek saath deta hai.

Kabhi-kabhi ek variable declare karna padta hai jiska use hi nahi karna (jaise catch (Exception e) mein agar e use hi nahi ho raha, ya record pattern mein sirf kuch fields chahiye baaki nahi). Java 21 preview mein underscore (_) ko "unnamed variable" ke roop mein use kar sakte ho — batata hai ki ye value jaan-boojh kar ignore ki ja rahi hai.

Record patterns mein bhi kaam aata hai — jaise agar Point(int x, int y) se sirf x chahiye, to case Point(int x, var _) likh sakte ho, matlab y ko explicitly "mujhe iski parwaah nahi" bata sakte ho, code padhne wale ko clarity milti hai.

Ye feature khaas taur par bade codebases mein useful hai jaha static analysis tools (jaise SonarQube) "unused variable" warnings dete hain — underscore (_) use karke tum explicitly bata dete ho ki variable jaan-boojh kar ignore ho raha hai, warning bhi clear ho jaati hai.

// catch block mein unused exception:
try {
  riskyOperation();
} catch (IOException _) {
  System.out.println("Kuch to gaya galat, details ki zaroorat nahi");
}

// Record pattern mein sirf zaroori field:
if (obj instanceof Point(int x, var _)) {
  System.out.println("x = " + x + " (y ignore kiya)");
}