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).

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.

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 -> ....

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.

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.

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.

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.

// 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)");
}