isBlank() check करता है String खाली है या सिर्फ whitespace है — isEmpty() सिर्फ length 0 check करता है, लेकिन " " (सिर्फ spaces) के लिए isEmpty() false देगा, जबकि isBlank() true देगा। यह एक common bug source था Java 11 से पहले।

strip()/stripLeading()/stripTrailing() trim() जैसे ही हैं, लेकिन Unicode-aware हैं — trim() सिर्फ ASCII whitespace (space से कम या बराबर character code) समझता है, जबकि strip() Unicode whitespace भी handle करता है (जैसे non-breaking spaces)। Modern code में trim() की जगह strip() prefer किया जाता है।

lines() String को line-by-line एक Stream<String> में तोड़ता है (multi-line text के लिए useful, बिना manually split("\n") किए)। repeat(n) एक String को n बार repeat करके एक नया String बनाता है।

String s = "   ";
System.out.println(s.isEmpty());  // false (length > 0 hai)
System.out.println(s.isBlank());  // true (sirf whitespace hai)

String text = "Line1\nLine2\nLine3";
text.lines().forEach(System.out::println); // 3 lines print

System.out.println("Ab".repeat(3)); // "AbAbAb"

Java 11 से पहले पूरी file एक String में पढ़ने के लिए Files.readAllBytes() call करके manually new String(bytes, charset) करना पड़ता था, या Files.lines() से stream collect करना पड़ता था — थोड़ा boilerplate। Files.readString(path) यह सब एक line में कर देता है।

Files.writeString(path, content) similarly एक String को सीधा file में लिख देता है, बिना manually bytes convert किए। दोनों methods UTF-8 default use करते हैं (overload में custom Charset भी दे सकते हो)।

// Purana tareeka (Java 11 se pehle):
byte[] bytes = Files.readAllBytes(Paths.get("notes.txt"));
String content = new String(bytes, StandardCharsets.UTF_8);

// Java 11+:
String content2 = Files.readString(Paths.get("notes.txt"));
Files.writeString(Paths.get("output.txt"), "Hello Java 11!");

Java 9 में incubator (experimental) module के रूप में आया था, Java 11 में यह standard java.net.http package बन गया — पुराने HttpURLConnection (जो Java 1.1 से था, clunky और limited) का modern replacement।

नया client HTTP/2 support करता है (default), synchronous (send()) और asynchronous (sendAsync(), जो CompletableFuture return करता है) दोनों तरीके देता है, और fluent Builder pattern use करता है request बनाने के लिए — third-party libraries (जैसे Apache HttpClient या OkHttp) की ज़रूरत कम हो जाती है simple use-cases के लिए।

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.example.com/data"))
    .GET()
    .build();

HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.statusCode());
System.out.println(response.body());

Normally Java में पहले javac से compile करके .class file बनानी पड़ती थी, फिर java से run करते थे। Java 11 से एक single .java file को directly java command से run कर सकते हो, बिना explicit compile step के — java Hello.java। JVM खुद background में compile करके memory में ही run कर देता है (कोई .class file disk पर नहीं बनती)।

यह feature सिर्फ single-file programs के लिए है (multi-file projects के लिए नहीं) — quick scripts, prototyping, या सीखने के लिए बहुत useful है, क्योंकि दो commands (javac + java) की जगह एक ही command चलती है।

// Hello.java
public class Hello {
  public static void main(String[] args) {
    System.out.println("Direct run, no compile step!");
  }
}

// Terminal mein:
// $ java Hello.java
// Direct run, no compile step!

Collection.toArray(IntFunction<T[]> generator) एक नया overload है — पहले toArray(new String[0]) जैसा लिखना पड़ता था, अब toArray(String[]::new) जैसा cleaner method reference use कर सकते हो, जिसमें array size खुद collection decide कर लेता है।

Optional.isEmpty() add हुआ — पहले सिर्फ isPresent() था, और "अगर value नहीं है" check करने के लिए !optional.isPresent() लिखना पड़ता था। isEmpty() ज़्यादा readable है (negation avoid होता है)।

List<String> names = List.of("Riya", "Aman");
String[] arr = names.toArray(String[]::new); // naya, cleaner tareeka

Optional<String> opt = Optional.empty();
if (opt.isEmpty()) {
  System.out.println("Koi value nahi hai");
}

कभी-कभी एक existing Predicate (जैसे String::isBlank) को negate करना होता है — method reference को directly negate नहीं कर सकते (String::isBlank का negate() call नहीं हो सकता सीधे), इसलिए पहले lambda लिखना पड़ता था: s -> !s.isBlank()।

Predicate.not(predicate) एक static helper है जो इसको clean बना देता है — Predicate.not(String::isBlank) सीधा method reference को negate कर देता है, बिना extra lambda लिखे।

List<String> words = List.of("Java", "", "  ", "Code");

// Java 11 se pehle:
words.stream().filter(s -> !s.isBlank()).forEach(System.out::println);

// Java 11+, Predicate.not() ke saath:
words.stream().filter(Predicate.not(String::isBlank)).forEach(System.out::println);

Epsilon GC (JEP 318) एक "no-op" (कुछ नहीं करने वाला) garbage collector है — यह memory allocate तो करता है, लेकिन कभी collect (clean) नहीं करता। सुनने में अजीब लगता है, लेकिन performance testing (GC का overhead measure करना) या बहुत short-lived programs (जो खत्म होने से पहले memory खत्म ही नहीं करेंगे) के लिए useful है।

ZGC (JEP 333, इस version में experimental) एक scalable, low-latency garbage collector है जो GB से लेकर multi-TB heaps तक handle कर सकता है, pause times को 10ms से कम रखते हुए — बहुत बड़ी applications (जहाँ थोड़ा सा भी pause noticeable हो) के लिए design किया गया था। Interview में इन दोनों का नाम और एक-line purpose याद रखना काफी होता है — deep internals शायद ही पूछे जाते हैं।