1Anonymous Classes6 2Hidden Classes2 3Sealed Classes & Interfaces12 4Java Modules (JPMS)2 5Reactive: Vert.x & RSocket8 6Advanced Topics41

6 topics71 Qs0%

Advanced Topics

Advanced JavaTopic 6 of 641 questions

Q1How are lambda expressions implemented at the bytecode level?

A lambda compiles to a private synthetic method plus an invokedynamic site bootstrapped by LambdaMetafactory, which lazily creates and caches the functional-interface implementation, avoiding a separate class file and repeated allocations per lambda.

Q2What are Method Handles, how do you obtain them, and how do they differ from reflection?

A MethodHandle is a strongly typed, directly invokable reference obtained via a Lookup and MethodType that is access-checked once and runs near direct-call speed, making it faster and safer than classic reflection for repeated dynamic invocation.

Q3Implement a gRPC logging interceptor, a rate-limiter interceptor, and a bidirectional streaming service (live stock prices).

Logging and rate-limiter interceptors are cross-cutting ServerInterceptors, while a bidi stream declares stream on both sides and uses a StreamObserver to send and receive continuously on one call.

Q4What is a .proto file and how does gRPC code generation work, and why is contract-first stronger than OpenAPI/Swagger?

A .proto is a typed, numbered contract that protoc compiles into real stubs and server classes, so mismatches fail at compile time instead of surprising you at runtime like hand-coded JSON can.

Q5What are the different OutOfMemoryError types, and what does each indicate?

Every OutOfMemoryError names the region that ran out, and knowing whether it is heap, Metaspace, direct memory, threads, or compressed class space tells you exactly where to look.

Q6What causes memory leaks in Java despite GC, and how do you diagnose one end-to-end?

A Java leak is live but unneeded references the GC cannot free, and you diagnose it by watching GC growth, taking a heap dump, and tracing the reference chain from the bloated objects back to the GC root.

Q7A service's RSS grows but heap dumps and GC logs look clean: how do you investigate an off-heap leak?

If RSS grows while heap dumps and GC logs are clean, the leak is off-heap, so switch from heap tools to Native Memory Tracking, jcmd, pmap, and async-profiler, and cap direct memory with MaxDirectMemorySize.

Q8What is off-heap memory, when do you use it, and what are the risks?

Off-heap memory lives outside the GC heap for large data, fast I/O, and native interop, but you own its lifetime, so you must free it explicitly or risk native leaks and crashes.

Q9What are memory-mapped files, how do they work, and when are they useful?

A memory-mapped file maps a file region into the process virtual address space via FileChannel.map, returning a MappedByteBuffer where the OS pages data on demand for zero-copy, high-throughput access.

Q10What are the ways to read a very large text file in Java, and their trade-offs?

Pick BufferedReader or Files.lines for simple streaming, FileChannel or mapping for maximum speed, but above all stream line-by-line and never load the whole file into memory.

Q11What are the major OpenJDK projects and what does each change?

Loom makes concurrency cheap, Valhalla makes small objects cheap, Panama bridges native code and adds SIMD, Amber simplifies the language, and Leyden makes startup fast.

Q12What are Records (Java 16), what does the compiler generate, can you add validation, and what are their constraints?

A record is a compiler-generated, immutable data carrier with automatic accessors, equals, hashCode, and toString, where a compact constructor validates before fields are set.

Q13Can gRPC be used in a serverless environment (AWS Lambda), and what are the limitations (cold starts, no connection pooling, no streaming, API Gateway only supports gRPC-Web)?

A Lambda can be a short-lived gRPC client for unary calls, but cold starts, unreliable connection pooling, no streaming, and API Gateway's lack of native gRPC make hosting gRPC servers in Lambda impractical.

Q14Design an LFU cache with O(1) get/put, and extend it with time-based frequency decay and TTL.

An O(1) LFU cache uses a key-to-node map, frequency-bucketed doubly linked lists, and a tracked min frequency, with optional decay to age popularity and TTL to expire stale entries.

Q15How do the major OpenJDK projects work together as a coherent platform evolution?

The OpenJDK projects compound: Loom makes concurrency cheap, Valhalla makes data cheap, Panama bridges native and SIMD, Amber simplifies the language, and Leyden makes startup fast, so understanding them together lets you design systems that are simple and high-performance at once.

Q16How do you add distributed tracing to a gRPC microservice (client/server interceptors injecting/extracting trace context, Jaeger/Zipkin/OpenTelemetry)?

Use a client interceptor to inject trace context into gRPC metadata and a server interceptor to extract it and start a child span, with OpenTelemetry propagating the trace and Jaeger or Zipkin visualizing it.

Q17How do you add gRPC-web browser support (Envoy proxy translating HTTP/1.1 ↔ HTTP/2)?

gRPC-Web lets browsers call gRPC services by using a variant wire format, and Envoy's grpc_web filter translates between gRPC-Web and native gRPC over HTTP/2 for the backend.

Q18How do you configure mTLS, a JWT auth interceptor, deadlines, compression, and keep-alive for gRPC in Spring Boot?

mTLS proves both identities and encrypts, a JWT interceptor authorizes each call, deadlines bound call time, gzip shrinks payloads, and keep-alive pings detect dead connections.

Q19How do you version gRPC without breaking existing clients (don't change field numbers, use optional fields, add new fields/methods/services, avoid removing/retyping)?

Evolve gRPC by adding new numbered optional fields, new methods, and new services, and never change, reuse, remove, or retype an existing field number.

Q20How does gRPC handle network failures differently from REST (deadlines, retries, circuit breaking), and how do you improve reliability?

gRPC bakes deadlines with cross-hop propagation, standardized status codes, and config-driven retries into the protocol, while REST relies on HTTP codes and external libraries; circuit breaking is added by a library or mesh in both.

Q21How does Java classloading work, and can two classes with the same name coexist in one JVM?

Class loaders form a delegating hierarchy (Bootstrap, Platform, Application), and a class's identity is its name plus its loader, so the same class name loaded by different loaders yields distinct, coexisting classes.

Q22How does sealing improve `instanceof` checks and exhaustive `switch` pattern matching?

Sealing makes the subtype set finite and known, so the compiler can prove a switch is exhaustive and force you to handle every case without a default.

Q23How does sealing interact with generics and wildcards?

Sealing closes the set of subtype classes while generics parameterize the data each carries, so the closed set and exhaustive matching hold regardless of type arguments or wildcards.

Q24How does ServiceLoader (the Java SPI mechanism) discover implementations?

ServiceLoader discovers implementations of an interface by reading META-INF/services files or module provides directives, and lazily instantiates them, decoupling consumers from concrete providers.

Q25Is listing all permitted subclasses optional if they're in the same file?

The `permits` clause is optional only when all permitted subtypes are in the same source file, where the compiler infers them automatically.

Q26What is GraalVM Native Image, how does it change the memory/startup model, and when do you use it?

GraalVM Native Image AOT-compiles a Java application into a standalone native binary with millisecond startup and low memory, at the cost of a closed-world assumption that forces dynamic features to be configured at build time.

Q27How does the Foreign Memory API's Arena provide explicit lifetime management vs DirectByteBuffer?

Arena frees its memory segments deterministically on close and bounds-checks every access, while a direct ByteBuffer frees off-heap bytes only when the garbage collector reclaims its wrapper, which is non-deterministic and less safe.

Q28How do you implement a gRPC service in Spring Boot, and how do service discovery and health checking integrate?

@GrpcService registers the server and @GrpcClient injects the stub, a registry or Kubernetes DNS resolves the service name, and the standard gRPC health protocol lets Kubernetes probe readiness natively.

Q29How does gRPC load balancing work, why does an L4 load balancer fail, and what are the fixes?

HTTP/2 multiplexing means one connection carries all requests, so an L4 LB pins them to one backend; fix it with an L7 LB that balances per stream or with client-side load balancing across discovered backends.

Q30How does virtual-thread pinning happen, and why replace synchronized with ReentrantLock in virtual-thread-heavy code?

Virtual threads unmount from carriers when they block, but blocking inside synchronized pins them to the carrier and wastes it, so in virtual-thread-heavy code you replace synchronized with ReentrantLock to let the thread unmount.

Q31What are Scoped Values (JEP 506, Java 25), and how are they a safer/faster alternative to ThreadLocal for virtual-thread workloads?

A scoped value is an immutable value bound for the duration of a run or call and automatically unbound afterward, giving the context-sharing of ThreadLocal without the mutability, leak risk, and per-thread cost that hurt virtual-thread workloads.

Q32What are gRPC status codes, how do they map to HTTP codes, and how do you return rich error details?

gRPC has its own status codes in the trailer, gateways map them to HTTP codes, and rich errors attach typed details via google.rpc.Status so clients get both a category and actionable specifics.

Q33What are Sequenced Collections (Java 21), and what gap did they fill?

Sequenced Collections give every ordered collection one uniform API for first, last, and reversed access, filling the gap where getting the first or last element and reversing differed inconsistently across List, Deque, and ordered sets and maps.

Q34What did Java 10 var add, and what are its limitations?

`var` lets the compiler infer a local variable's exact static type from its initializer; it is compile-time sugar, not dynamic typing, and works only on locals that are initialized.

Q35What is a Java Agent, how does it instrument bytecode at load time, and what tools are built on it?

A Java Agent uses the instrumentation API to rewrite class bytecode as it loads, via premain or agentmain and a ClassFileTransformer, so tools like APM, coverage, tracing, and hot-reload can add behavior without changing source code.

Q36What is gRPC (HTTP/2 + Protocol Buffers RPC), its advantages/disadvantages, use cases, and comparison with REST?

gRPC is contract-first binary RPC over HTTP/2 using Protocol Buffers, giving fast, strongly typed, streaming-capable service-to-service calls.

Q37What is Project Skara and why does it matter for contributors?

Project Skara moved the JDK from Mercurial to Git on GitHub and built the bots and tooling that make a familiar pull-request workflow work under OpenJDK's rules, lowering the barrier to contribute and speeding up reviews.

Q38What is Structured Concurrency / StructuredTaskScope, and how does it eliminate orphaned tasks and simplify cancellation?

StructuredTaskScope binds concurrent subtasks to a parent scope so they all finish before the parent returns, with shutdown-on-failure for fail-fast and shutdown-on-success for racing, eliminating orphaned tasks and making cancellation automatic.

Q39What is type erasure in generics, what does it make impossible, and what is the PECS rule?

Type erasure deletes generic types at runtime so new T, instanceof on a parameterized type, generic arrays, and generic-only overloads are impossible, and PECS says read with extends and write with super.

Q40When should you use var versus an explicit type?

Use `var` when the initializer makes the type obvious and avoid it when the type is the information the reader needs; and remember `var` is banned on fields, parameters, return types, and untyped lambda parameters.

Q41Why does gRPC rely on HTTP/2 instead of HTTP/1.1, and what breaks with HTTP/1.1 (no multiplexing/streaming/binary)?

gRPC needs HTTP/2's multiplexing, bidirectional streaming, binary framing, and trailers; HTTP/1.1 lacks all of these, so gRPC's streaming and concurrency model cannot run on it.