Java interview questions

Table of Contents

• Lambdas vs anonymous class
• What is inlining
• What is invokedynamic
• Standard memory model
• Serialization and deserialization
• Platform vs virtual threads
• Chronicle-bytes

Lambdas vs Anonymous Classes

In Java, both anonymous classes and lambda expressions allow developers to define small blocks of behavior inline — typically to pass as callbacks or functional arguments. However, the way they are compiled and executed under the hood is quite different, with important implications for performance and memory efficiency.

An anonymous inner class is a full-fledged, unnamed class created at compile time. Each one generates a separate .class file (for example, OuterClass$1.class) that must be loaded and verified at runtime. This introduces additional overhead related to class loading, memory allocation, and object instantiation. Each use of an anonymous class typically results in a new object created on the heap.

On the other hand, lambda expressions are implemented more efficiently using theinvokedynamic instruction introduced in Java 7. Instead of creating a new class file, the JVM links the lambda to its corresponding functional interface at runtime, often reusing the same instance if no variables are captured from the enclosing scope. This means that lambdas typically have far less overhead in both memory and class-loading time.

Modern JVMs further optimize lambdas through techniques like method inlining — especially when a lambda is small or frequently invoked in a tight loop. In some cases, such as with method references, the compiler can even bypass object creation altogether, directly referencing the existing method.

In short, while anonymous classes provide flexibility and full object-oriented semantics, lambdas are lighter, more efficient, and better aligned with functional programming styles. They are preferred in modern Java for concise, performant, and cleaner code.

What is Inlining

Inlining is one of the most fundamental and powerful optimizations performed by the JVM's Just-In-Time (JIT) compiler. Inlining means replacing a method call with the method's actual body of code. Instead of performing a separate function call — which involves stack setup, jumps, and returns — the JIT copies the method's body directly into the caller at runtime.

1int square(int x) {
2    return x * x;
3}
4
5int compute(int a, int b) {
6    return square(a) + square(b);
7}

Without inlining, the compiled bytecode performs:

When the JIT compiler detects that square() is small and frequently called, it inlines the method. The resulting optimized code looks like this:

1int compute(int a, int b) {
2    return (a * a) + (b * b);
3}

By inlining, the JVM avoids unnecessary method calls and enables further optimizations. The benefits include:

However, inlining is not always beneficial. Excessive inlining can lead to code bloat, which increases the size of compiled machine code. This can:

In summary, inlining trades off a small increase in code size for a large potential gain in runtime performance. It's one of the JVM's most important optimizations for achieving the speed of native code while maintaining Java's flexibility and portability.

What is invokedynamic?

1Math.max(1, 2);      // invokestatic
2
3Object obj = "Hello";
4obj.toString();     // invokevirtual

1obj = someMethod()   # Type only known at runtime
2
3obj.doSomething()

1Runnable task = () -> System.out.println("Hello");

Standard memory model

In the JVM memory model, local variables declared inside a method (e.g.,MyObject obj) store references, which are essentially pointers to objects. These references are stored in the current thread's stack frame, making them thread-local and fast to access.

The actual objects themselves are typically allocated on the heap when using new. The heap is shared across threads and managed by the garbage collector, which handles memory allocation and reclamation automatically.

However, modern JVMs do not strictly follow this simple stack-versus-heap model due to aggressive runtime optimizations.

One important optimization is escape analysis. If the JVM determines that an object does not escape the scope of a method (for example, it is not returned or shared with other threads), it may allocate the object on the stack instead of the heap. This avoids heap allocation overhead and reduces pressure on the garbage collector.

Another optimization is scalar replacement, where the JVM eliminates the object allocation entirely. Instead of creating an object, its individual fields are broken down and stored directly in registers or on the stack, allowing for more efficient execution.

In summary, while the conceptual model is “references on the stack and objects on the heap,” modern JVMs dynamically optimize this behavior at runtime to reduce allocation costs and improve performance.

Serialization and Deserialization

Serialization is the process of converting an object's state into a byte stream, while deserialization is the reverse process of reconstructing an object from that byte stream. This mechanism is commonly used for persistence (saving objects to files or databases) and network communication (sending objects between different JVMs).

Serializable Interface: A marker interface (it contains no methods) that a class must implement to be eligible for serialization.

ObjectOutputStream: Used to serialize objects via the writeObject() method.

ObjectInputStream: Used to deserialize objects via the readObject() method.

transient Keyword: Marks fields that should not be serialized, such as sensitive data (e.g., passwords) or temporary values.

static Fields: These are not serialized because they belong to the class rather than individual object instances.

serialVersionUID: A unique identifier used for class versioning. If the sender and receiver have mismatched IDs, deserialization will fail with an InvalidClassException.

1import java.io.*;
2
3class User implements Serializable {
4    private static final long serialVersionUID = 1L;
5
6    private String name;
7    private transient String password; // Will not be serialized
8
9    public User(String name, String password) {
10        this.name = name;
11        this.password = password;
12    }
13
14    public static void main(String[] args) {
15        // Serialization
16        try (ObjectOutputStream oos =
17                 new ObjectOutputStream(new FileOutputStream("user.ser"))) {
18
19            User user = new User("Alice", "secret123");
20            oos.writeObject(user);
21
22        } catch (IOException e) {
23            e.printStackTrace();
24        }
25
26        // Deserialization
27        try (ObjectInputStream ois =
28                 new ObjectInputStream(new FileInputStream("user.ser"))) {
29
30            User user = (User) ois.readObject();
31            System.out.println(user.name);      // Prints "Alice"
32            System.out.println(user.password);  // Prints null (transient)
33
34        } catch (IOException | ClassNotFoundException e) {
35            e.printStackTrace();
36        }
37    }
38}

You can override writeObject() and readObject() within your class to add custom logic, such as encryption or validation during serialization and deserialization.

If a parent class implements Serializable, all of its subclasses are automatically serializable. However, if a parent class is not serializable, its no-argument constructor will be invoked during deserialization.

Externalizable Interface: An alternative that gives you full control over the serialization process. You must explicitly implement writeExternal() and readExternal().

Security Note: Deserializing untrusted data is a serious security risk and can lead to remote code execution vulnerabilities. It is recommended to use serialization filters (introduced in Java 9) or safer alternatives such as JSON or Protocol Buffers when handling untrusted data.

Platform Threads vs Virtual Threads

1// Create and start a virtual thread
2Thread.startVirtualThread(() -> {
3    System.out.println("Running in a virtual thread");
4});
5
6// Or use an ExecutorService
7try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
8
9    executor.submit(() -> {
10        System.out.println("Task executed");
11    });
12
13}

Chronicle Bytes

1import net.openhft.chronicle.bytes.Bytes;
2
3public class Example {
4    public static void main(String[] args) {
5        Bytes<?> bytes = Bytes.elasticHeapByteBuffer();
6        bytes.writeUtf8("Hello, World!");
7
8        String message = bytes.readUtf8();
9        System.out.println(message);
10        bytes.releaseLast();
11    }
12}