Java Developer Interview Questions

Direct Answer

The == operator compares memory references, while equals() compares object values for logical equality.

Detailed Explanation

String s1 = new String("hello");
String s2 = new String("hello");

System.out.println(s1 == s2);      // false (different references in memory)
System.out.println(s1.equals(s2)); // true (logical content is identical)

String s3 = "hello";
String s4 = "hello";
System.out.println(s3 == s4);      // true (String pool reference sharing)

Common Interview Pitfalls

• Using == to compare Strings instead of using String.equals().
• Forgetting to override hashCode() when overriding equals().

Direct Answer

Java is strictly pass-by-value. Primitives pass a copy of the value; objects pass a copy of the reference address.

Detailed Explanation

public class PassTest {
    public static void main(String[] args) {
        int x = 10;
        modifyPrimitive(x);
        System.out.println(x); // Outputs 10

        Dog d = new Dog("Max");
        modifyObject(d);
        System.out.println(d.name); // Outputs "Buddy" (mutated heap object)

        reassignObject(d);
        System.out.println(d.name); // Outputs "Buddy" (reassignment failed to change caller)
    }

    static void modifyPrimitive(int val) { val = 20; }
    static void modifyObject(Dog dog) { dog.name = "Buddy"; }
    static void reassignObject(Dog dog) { dog = new Dog("Fido"); }
}

Common Interview Pitfalls

• Believing that mutating an object parameter modifies the reference pointer itself.
• Claiming Java passes objects by reference.

Direct Answer

Abstract classes model inheritance and state (is-a). Interfaces model behavior contracts (can-do) without state.

Detailed Explanation

public interface Flyable {
    void fly(); // Abstract by default
    default void land() {
        System.out.println("Landing...");
    }
}

public abstract class Animal {
    protected String name;
    public Animal(String name) { this.name = name; }
    public abstract void makeSound();
}

public class Eagle extends Animal implements Flyable {
    public Eagle(String name) { super(name); }
    public void makeSound() { System.out.println("Eagle screech!"); }
    public void fly() { System.out.println("Soaring high!"); }
}

Common Interview Pitfalls

• Assuming interfaces cannot have any method implementations (ignoring default/static methods).
• Thinking default methods allow interfaces to hold instance state.

Direct Answer

Polymorphism lets objects take many forms. Compile-time uses overloading; runtime uses overriding via dynamic dispatch.

Detailed Explanation

class Printer {
    // Compile-time polymorphism (Overloading)
    void print(String s) { System.out.println("String: " + s); }
    void print(int i) { System.out.println("Int: " + i); }
}

class Animal {
    void speak() { System.out.println("Generic Sound"); }
}

class Cat extends Animal {
    // Runtime polymorphism (Overriding)
    @Override
    void speak() { System.out.println("Meow"); }
}

public class PolyTest {
    public static void main(String[] args) {
        Animal myAnimal = new Cat();
        myAnimal.speak(); // Prints "Meow" (Runtime dynamic binding)
    }
}

Common Interview Pitfalls

• Confusing method overloading (different arguments, same class) with overriding (same arguments, subclasses).
• Thinking instance variables can be overridden polymorphically (only methods are overridden, variables are shadowed).

Direct Answer

HashMap uses hashing to map keys. Collisions resolve via linked lists, or red-black trees in Java 8+ if count >= 8.

Detailed Explanation

HashMap<String, Integer> map = new HashMap<>();
map.put("Apple", 1); // Key "Apple" hash computed, placed in bucket index
map.put("Banana", 2);

// Collision simulation: keys with different logical content but same hash
System.out.println(map.get("Apple")); // Retrieves value 1

Common Interview Pitfalls

• Believing HashMap is thread-safe (it is not; use ConcurrentHashMap in multi-threaded contexts).
• Forgetting that keys must override hashCode() and equals() correctly.

Direct Answer

Fail-fast iterators throw ConcurrentModificationException on modification. Fail-safe/weakly-consistent iterators do not.

Detailed Explanation

// Fail-fast example
List<String> list = new ArrayList<>(List.of("A", "B"));
Iterator<String> it = list.iterator();
while(it.hasNext()) {
    String val = it.next();
    list.add("C"); // Throws ConcurrentModificationException!
}

// Fail-safe example
List<String> safeList = new CopyOnWriteArrayList<>(List.of("A", "B"));
for (String val : safeList) {
    safeList.add("C"); // Allowed; runs without exceptions!
}

Common Interview Pitfalls

• Assuming ConcurrentModificationException only happens when multiple threads are involved (it can happen in a single thread).
• Using the collection add/remove methods inside a foreach loop instead of the Iterator.remove() method.

Direct Answer

map() performs 1-to-1 value transformation. flatMap() performs 1-to-many mapping and flattens nested streams.

Detailed Explanation

List<List<String>> nestedList = List.of(
    List.of("apple", "banana"),
    List.of("orange", "cherry")
);

// Map produces a Stream<Stream<String>> or Stream<List<String>>
List<Integer> lengths = nestedList.stream()
    .flatMap(List::stream) // Flattens to Stream<String>
    .map(String::length)   // Transforms Stream<String> to Stream<Integer>
    .collect(Collectors.toList());

System.out.println(lengths); // [5, 6, 6, 6]

Common Interview Pitfalls

• Using map() when the mapper function returns a Collection or Stream, resulting in a nested stream (Stream<Stream<T>>).
• Forgetting that flatMap() requires the lambda function to return an explicit Stream instance, not a Collection.

Direct Answer

Stream intermediate operations only build a pipeline; execution triggers only when a terminal operation is called.

Detailed Explanation

List<String> names = List.of("Alex", "David", "Brad", "Charlie");

Optional<String> firstFiltered = names.stream()
    .filter(name -> {
        System.out.println("Filter: " + name);
        return name.startsWith("C");
    })
    .map(name -> {
        System.out.println("Map: " + name);
        return name.toUpperCase();
    })
    .findFirst(); // Terminal operation

// Console Output:
// Filter: Alex
// Filter: David
// Filter: Brad
// Filter: Charlie
// Map: Charlie
// Note: Brad and Alex were not mapped because findFirst short-circuited the pipeline!

Common Interview Pitfalls

• Adding intermediate operations without a terminal operation, which results in zero execution.
• Assuming that a stream processes all elements through the first step before passing them to the next step (elements are actually pulled through the pipeline one-by-one).

Direct Answer

volatile forces threads to read/write directly from main memory, ensuring variable visibility and ordering.

Detailed Explanation

public class VolatileFlag implements Runnable {
    // Volatile ensures updates are visible immediately to other threads
    private volatile boolean running = true;

    public void run() {
        while (running) {
            // Keep running until flag changes in main memory
        }
        System.out.println("Stopped.");
    }

    public void stopRunning() {
        running = false; // Write flushed directly to main memory
    }
}

Common Interview Pitfalls

• Assuming volatile variable increment operations (like vVar++) are thread-safe (they require atomic classes or synchronization).
• Using volatile instead of synchronized/locks for complex transactional operations.

Direct Answer

Virtual threads are lightweight user-mode threads managed by the JVM to run millions of concurrent tasks efficiently.

Detailed Explanation

// Creating a virtual thread
Thread vThread = Thread.ofVirtual().start(() -> {
    System.out.println("Running in virtual thread: " + Thread.currentThread());
});

// Using a Virtual Thread Executor for concurrent tasks
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    IntStream.range(0, 10_000).forEach(i -> {
        executor.submit(() -> {
            Thread.sleep(Duration.ofMillis(100)); // Non-blocking context switch
            return i;
        });
    });
} // Auto-closes after all virtual threads finish

Common Interview Pitfalls

• Pooling virtual threads (pooling is a mechanism to limit expensive OS threads; virtual threads are cheap and should be created per-task instead).
• Pinning carrier threads by performing synchronized blocks or native calls containing blocking operations inside a virtual thread.

Direct Answer

JVM memory includes Stack (local frames), Heap (shared objects), Metaspace (class metadata), and PC/Native stacks.

Detailed Explanation

public class MemoryTest {
    // Class metadata and methods are loaded in Metaspace
    private int instanceVal = 10; // Stored in Heap inside the object

    public static void main(String[] args) {
        int x = 5; // Local primitive stored in Stack frame
        MemoryTest obj = new MemoryTest(); // Reference "obj" on Stack, instance on Heap
    }
}

Common Interview Pitfalls

• Assuming that Metaspace is part of the JVM heap (it is allocated in native off-heap memory since Java 8).
• Believing object references are stored on the heap (only the object instance resides on the heap; reference variables inside methods reside on the stack).

Direct Answer

G1 is a regional generational collector with tens-of-ms pauses. ZGC runs concurrently keeping pauses under 1ms.

Detailed Explanation

# JVM Flags to enable ZGC in Java 17+
java -XX:+UseZGC -jar my-application.jar

# JVM Flags to enable Generational ZGC in Java 21
java -XX:+UseZGC -XX:+ZGenerational -jar my-application.jar

Common Interview Pitfalls

• Believing ZGC pause times increase with heap size (ZGC pauses are independent of heap size).
• Configuring aggressive GC tuning flags on ZGC when it is designed to auto-tune.

Direct Answer

Records are immutable data carriers. The compiler auto-generates constructors, accessors, equals, and hashCode.

Detailed Explanation

// Simple record definition
public record UserDto(String username, String email) {}

// Usage
UserDto user = new UserDto("alice", "alice@example.com");
System.out.println(user.username()); // Getter (no "get" prefix)
System.out.println(user); // UserDto[username=alice, email=alice@example.com]

Common Interview Pitfalls

• Trying to define instance variables inside a record body (only static variables are permitted).
• Thinking records are deeply immutable (if a record has a mutable list field, the list contents can still be mutated).

Direct Answer

Sealed classes restrict which subclasses can extend them, enabling precise API boundaries and exhaustive switches.

Detailed Explanation

// Sealed interface restricting implementations
public sealed interface Shape permits Circle, Square {}

public final class Circle implements Shape {
    public double radius() { return 5.0; }
}

public final class Square implements Shape {
    public double side() { return 4.0; }
}

// Exhaustive switch in Java 21
public double getArea(Shape shape) {
    return switch (shape) {
        case Circle c -> Math.PI * c.radius() * c.radius();
        case Square s -> s.side() * s.side();
        // No default needed because compiler knows Circle and Square cover all cases!
    };
}

Common Interview Pitfalls

• Forgetting that subclasses of a sealed class must explicitly declare one of the three modifiers: final, sealed, or non-sealed.
• Thinking sealed classes can permit subclasses outside their module or package.

Direct Answer

JUnit 5 lifecycle annotations are @BeforeAll, @BeforeEach, @AfterEach, and @AfterAll, replacing JUnit 4 equivalents.

Detailed Explanation

@TestInstance(TestInstance.Lifecycle.PER_METHOD) // Default lifecycle
public class LifecycleTest {

    @BeforeAll
    static void initAll() {
        System.out.println("Starting test suite...");
    }

    @BeforeEach
    void init() {
        System.out.println("Setting up test parameters...");
    }

    @Test
    void myTest() {
        System.out.println("Executing test...");
    }

    @AfterEach
    void tearDown() {
        System.out.println("Cleaning up mock states...");
    }

    @AfterAll
    static void tearDownAll() {
        System.out.println("Shutdown test runner.");
    }
}

Common Interview Pitfalls

• Forgetting that @BeforeAll and @AfterAll methods must be declared static under default PER_METHOD lifecycle settings.
• Mixing JUnit 4 annotations (like @Before) in a JUnit 5 (Jupiter) test project, causing tests to run without initialization.

Direct Answer

Testcontainers spins up disposable Docker containers in JUnit to run integration tests against real databases.

Detailed Explanation

@SpringBootTest
@Testcontainers
class IntegrationTest {

    @Container
    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:15")
        .withDatabaseName("testdb")
        .withUsername("testuser")
        .withPassword("testpass");

    @DynamicPropertySource
    static void configureProperties(DynamicPropertyRegistry registry) {
        registry.add("spring.datasource.url", postgres::getJdbcUrl);
        registry.add("spring.datasource.username", postgres::getUsername);
        registry.add("spring.datasource.password", postgres::getPassword);
    }

    @Test
    void testDatabaseConnection() {
        assertTrue(postgres.isRunning());
    }
}

Common Interview Pitfalls

• Hardcoding static ports inside Testcontainers setup, causing collisions in concurrent CI builds.
• Re-starting containers for every test file instead of using the Singleton Container pattern for shared speed.

Direct Answer

Build an LRU cache by extending LinkedHashMap, overriding removeEldestEntry, and wrapping in synchronizedMap.

Detailed Explanation

public class LruCache<K, V> {
    private final int capacity;
    private final Map<K, V> cacheMap;

    public LruCache(int capacity) {
        this.capacity = capacity;
        // Access-order set to true
        this.cacheMap = Collections.synchronizedMap(new LinkedHashMap<K, V>(capacity, 0.75f, true) {
            @Override
            protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
                return size() > capacity; // Remove when size exceeds capacity
            }
        });
    }

    public V get(K key) { return cacheMap.get(key); }
    public void put(K key, V value) { cacheMap.put(key, value); }
}

Common Interview Pitfalls

• Forgetting that access-order must be explicitly set (the default is insertion-order, which makes it an FIFO cache, not LRU).
• Failing to synchronize map operations in multi-threaded environments, leading to corrupted pointers in LinkedHashMap's doubly linked list.

Direct Answer

Thread-safe counters use locks or AtomicLong. Under high write contention, LongAdder is faster via striped cells.

Detailed Explanation

// High Performance High Contention Counter
public class HighPerformanceCounter {
    private final LongAdder adder = new LongAdder();

    public void increment() {
        adder.increment(); // Distributes writes over cells
    }

    public long getValue() {
        return adder.sum(); // Merges cell counts
    }
}

Common Interview Pitfalls

• Using volatile long for counter increments (volatile does not make incrementing atomic).
• Using AtomicLong under thousands of threads doing writes, where LongAdder would be dramatically faster.