Java Developer Interview Questions and FAQs 2026

// The equals() and hashCode() contract
// — MUST be consistent for HashMap to work.

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass())
        return false;
    User user = (User) o;
    return Objects.equals(email, user.email);
}

@Override
public int hashCode() {
    return Objects.hash(email);
}

// Interview tip:
// If equals() is overridden, hashCode() MUST be too.
// Otherwise HashMap lookups fail.

// Immutable class example

public final class Money {
    private final BigDecimal amount;
    private final String currency;

    public Money(BigDecimal amount, String currency) {
        this.amount = amount;
        this.currency = currency;
    }

    public BigDecimal getAmount() {
        return amount;
    }

    public String getCurrency() {
        return currency;
    }

    // no setters
    // final class → no subclass override
    // final fields → can't be reassigned
}

// Interview tip:
// Immutability is the foundation of thread safety.
// Java's String, Integer, LocalDate are all immutable.

// HashMap internals — interview favourite

// 1. Bucket array (default 16 buckets)
// 2. Key hashed → bucket index = hash & (n-1)
// 3. Collisions handled via linked list
// 4. After 8 entries in one bucket → converts
//    to Red-Black tree for O(log n)
// 5. Load factor 0.75 → resize (double) when
//    75% full

// Common questions:
// - Why is HashMap fast? O(1) average
// - Why 16 initial size? power of 2 for mask
// - What if two keys collide?
//   Same bucket, list or tree
// - When does resize happen?
//   At 75% capacity

Map<String, Integer> counts = new HashMap<>();
counts.merge("java", 1, Integer::sum);

// Streams API — commonly asked

List<String> names = List.of("Amit", "Priya", "Raj");

// Filter + map + collect
List<String> longNames = names.stream()
    .filter(n -> n.length() > 3)
    .map(String::toUpperCase)
    .collect(Collectors.toList());

// Group + count
Map<Integer, Long> byLength = names.stream()
    .collect(Collectors.groupingBy(
        String::length,
        Collectors.counting()
    ));

// Interview tip:
// Be ready to explain WHY you chose
// stream vs loop — readability matters,
// but so does performance.

// ExecutorService — modern thread management

ExecutorService pool = Executors.newFixedThreadPool(4);

// Submit returns a Future
Future<Integer> result = pool.submit(() -> {
    Thread.sleep(100);
    return 42;
});

// Get with timeout — avoid infinite waits
int value = result.get(2, TimeUnit.SECONDS);

pool.shutdown();
pool.awaitTermination(5, TimeUnit.SECONDS);

// Interview tip:
// Always explain:
// - why a pool (avoid thread creation cost)
// - how you sized it (CPU/IO-bound)
// - how you handle shutdown

// CompletableFuture — modern async

CompletableFuture<String> userFuture =
    CompletableFuture.supplyAsync(() -> fetchUser(id));

CompletableFuture<List<Order>> ordersFuture =
    CompletableFuture.supplyAsync(() -> fetchOrders(id));

// Combine two async results
CompletableFuture<String> combined =
    userFuture.thenCombine(ordersFuture, (user, orders) ->
        user + " has " + orders.size() + " orders"
    );

// Exception handling
String response = combined
    .exceptionally(ex -> "Error: " + ex.getMessage())
    .join();

// Interview tip:
// Show you understand chaining vs blocking.
// "thenCombine runs in parallel" is a strong answer.

@RestController
@RequestMapping("/api/orders")
public class OrderController {

    private final OrderService service;

    // Constructor injection — preferred
    public OrderController(OrderService service) {
        this.service = service;
    }

    @GetMapping("/{id}")
    public ResponseEntity<Order> get(@PathVariable Long id) {
        return service.findById(id)
            .map(ResponseEntity::ok)
            .orElse(ResponseEntity.notFound().build());
    }

    @PostMapping
    public ResponseEntity<Order> create(@RequestBody Order order) {
        Order saved = service.save(order);
        return ResponseEntity.status(201).body(saved);
    }
}

// Interview tip:
// Explain WHY constructor injection
// (immutability, testability).

// N+1 problem — a classic interview topic

// BAD — N+1 queries
List<Order> orders = orderRepo.findAll();
for (Order o : orders) {
    // One query per order — slow
    o.getCustomer().getName();
}

// GOOD — fetch join
@Query("""
    SELECT o FROM Order o
    JOIN FETCH o.customer
""")
List<Order> findAllWithCustomer();

// Or use @EntityGraph
// Interview tip:
// "How do you avoid N+1?" is almost
// guaranteed in Spring Boot interviews.

// @Transactional — what to explain

@Service
public class PaymentService {

    @Transactional
    public void transfer(Long from, Long to, BigDecimal amt) {
        accountRepo.debit(from, amt);
        accountRepo.credit(to, amt);
        // if credit fails, debit rolls back
    }
}

// Interview points:
// - Default propagation: REQUIRED
// - Rollback on RuntimeException by default
// - Does NOT rollback on checked exceptions
//   (unless rollbackFor specified)
// - Proxy-based — self-invocation bypasses it

Common mistakes in Java interviews:

□ Memorising definitions — no depth
□ Not knowing why equals/hashCode must be
  consistent
□ Confusing HashMap with Hashtable
□ Not understanding HashMap internals
□ Ignoring thread safety when using collections
□ Not knowing why N+1 is bad
□ Confusing @Component with @Bean
□ Not being able to explain DI benefits
□ Trying to memorise stream syntax without
  understanding when to use streams
□ Giving "it depends" without specifics

Every mistake above can be fixed by
preparing with real examples.

How to answer well:

Structure:
1. Direct answer — 1 sentence
2. Simple example
3. Real-world context (project / scale)

Example — "What is HashMap?"

Weak: "HashMap is a Map implementation."

Strong: "HashMap is a Map that uses hashing
to give O(1) average lookups. It stores
entries in buckets indexed by key hash,
handles collisions via lists that become
trees after 8 entries. I use it for
caching user sessions at work."

Structure beats memorisation.

Preparation tracker (per topic):

Topic: _________

□ Read fundamental
□ Wrote code example
□ Wrote 1 paragraph explanation
□ Practised out loud
□ Reviewed common pitfalls

Next topic:
1. 
2.