Lead Level Java Interview Questions

Q) How did you optimize the performance of your java application?

Situation: In one of my recent projects, we were working on a high-traffic e-
commerce platform. During peak sales events, the application experienced
latency issues, with response times exceeding acceptable SLAs. The system
relied heavily on database interactions, and our APIs were struggling to keep up
with the volume of incoming requests.

Task: My role was to analyze and optimize the performance of the application to
ensure it could handle the traffic spike efficiently without compromising user
experience.

Approach:
Database Optimization:
Refactored long-running SQL queries by:
 Adding proper indexes to frequently queried columns.
CREATE INDEX idx_product_id ON orders (product_id);
 Avoiding SELECT * and specifying only required columns
SELECT product_name, price FROM products WHERE product_id = ?;
 Rewriting joins and subqueries for efficiency.
Original Query (Using Subquery):
sqlCopy codeSELECT o.order_id, o.product_id, o.quantity
FROM orders o
WHERE o.customer_id IN (
SELECT customer_id
FROM customers
WHERE city = 'New York'
);
Optimized Query (Using Join):
sqlCopy codeSELECT o.order_id, o.product_id, o.quantity
FROM orders o
INNER JOIN customers c ON o.customer_id = c.customer_id
WHERE c.city = 'New York';
Why It’s Better:
  Join vs Subquery: Joins are generally faster because they process rows in
parallel and can leverage indexes better than subqueries.
 Introduced caching using Redis for frequently accessed data like
product catalog and user preferences, reducing the load on the
database.
@Autowired
private RedisTemplate<String, Object> redisTemplate;

public Product getProductById(String productId) {

String key = "product:" + productId;
if (redisTemplate.hasKey(key)) {
return (Product) redisTemplate.opsForValue().get(key);
} else {
Product product = productRepository.findById(productId).orElse(null);
redisTemplate.opsForValue().set(key, product);
return product;
}
}
Code-Level Optimizations:
 Reduced object creation by reusing existing objects wherever
possible (e.g., using StringBuilder instead of concatenating
strings in loops).
StringBuilder sb = new StringBuilder();
for (String part : parts) {
sb.append(part);
}
String result = sb.toString();
 Optimized loops and used parallel streams for CPU-intensive
tasks.
Traditional Loop (Sequential Processing)
List<Integer> numbers = new ArrayList<>();
for (int i = 1; i <= 1_000_000; i++) {
numbers.add(i);
}
Sequential Stream:
List<Double> results =
numbers.stream().map(Math::sqrt).collect(Collectors.toList());
Optimized Version Using Parallel Stream
List<Double> results =
numbers.parallelStream().map(Math::sqrt).collect(Collectors.toList());
 Minimized the usage of synchronized blocks by leveraging
ConcurrentHashMap and other thread-safe collections where
needed.
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
map.put("key", 1);
Improving API Performance:
 Introduced asynchronous processing using CompletableFuture for
non-critical tasks, such as logging and sending emails.
public void processOrder(Order order) {
// Process the order synchronously
saveOrderToDatabase(order);

// Send email asynchronously (non-blocking)

CompletableFuture.runAsync(() -> {
sendOrderConfirmationEmail(order);
});

// Log asynchronously
CompletableFuture.runAsync(() -> {
logOrderProcessing(order);
});
}
 Batched multiple smaller requests into a single API call to reduce network
overhead.
public List<Product> getProductsByIds(List<Long> ids) {
// Fetch all requested products in a single query
return productRepository.findAllById(ids);
}
  Added gzip compression for API responses to reduce payload size.
server.compression.enabled=true
server.compression.mime-types=application/json,application/xml,text/html,text/
plain
server.compression.min-response-size=1024
Enabled Compression: Reduces payload size, improving response time and
bandwidth usage.
Mime Types: Specifies which response types to compress.
Minimum Response Size: Avoids compressing very small responses (saves
CPU).
Scaling Infrastructure:
 Analyzed traffic patterns and implemented load balancing with multiple
application server instances.
 Deployed a content delivery network (CDN) for static resources like
images and scripts to offload traffic from application servers.
Testing and Monitoring:
 Ran extensive load tests using Apache JMeter to simulate peak traffic
scenarios.
 Integrated Prometheus and Grafana for real-time monitoring of
application performance, focusing on metrics like response time, CPU, and
memory usage.
Profiling the Application:
 Used tools like JVisualVM and YourKit to identify bottlenecks in the code.
 Observed that certain database queries were taking an unusually long
time and that the garbage collector was frequently running due to high
object creation.

Result: After implementing these optimizations:

 The average API response time improved from 1.5 seconds to 300
milliseconds.
 The database load was reduced significantly due to caching and
optimized queries.
 The system successfully handled traffic spikes during peak sales
events without any downtime, improving user satisfaction and increasing
revenue by 15%.
Summary - Optimizing an application requires a combination of analyzing
bottlenecks, refactoring code, improving database interactions, and
scaling infrastructure. Monitoring and testing are crucial to ensure sustained
performance improvements.
Q) Can you talk about a time when you had to refactor legacy Java code
to improve scalability? What challenges did you face, and how did you
ensure the system could scale without breaking existing functionality?
Situation: In a previous project, I worked on a financial reporting application
that processed large volumes of transaction data daily. The legacy system used a
monolithic architecture with tightly coupled components, which became a
bottleneck as data volumes grew. Scalability was limited, and adding new
features risked breaking existing functionality.

Task: My task was to refactor the system to improve scalability while ensuring it
continued to meet existing requirements without disruptions.

Approach:
1. Understanding the Legacy Codebase:
o Conducted a thorough analysis of the system, reviewing
documentation (where available) and code to identify critical
workflows.
o Engaged with stakeholders to map out business-critical features
that could not be disrupted.
2. Modularization:
o Identified tightly coupled components and extracted them into
separate modules.
o Used Spring Boot to build independent services for critical
functionalities like data ingestion, reporting, and user management.
3. Database Refactoring:
o The legacy system relied on a single relational database that
became a bottleneck.
o Implemented database sharding to distribute data across multiple
instances.
o Introduced read replicas for reporting-heavy queries, reducing the
load on the primary database.
4. Introducing Microservices:
o Split the monolith into domain-driven microservices for
transaction processing, analytics, and notifications.
 o Used Apache Kafka for asynchronous communication between
services, ensuring loose coupling.
5. Backward Compatibility:
o Maintained backward compatibility by introducing an API Gateway.
The gateway translated old API calls to new microservices, allowing
existing clients to continue working.
o Wrote comprehensive integration tests to verify that the refactored
system produced the same outputs as the original for existing data.
6. Performance Testing and Optimization:shi
o Performed load testing using JMeter and Gatling to ensure the
refactored system could handle increasing transaction volumes.
o Optimized performance bottlenecks, such as by caching frequently
accessed data using Redis.
7. Incremental Deployment:
o Adopted a blue-green deployment strategy to minimize
downtime and allow rollbacks if issues arose.
o Monitored production behavior using Prometheus and Grafana
dashboards to ensure smooth operation.

Challenges:
1. Tight Deadlines: Balancing the need for scalability with time constraints
was challenging.
o Solution: Prioritized the most critical scalability bottlenecks first
and deferred less critical changes.
2. Complex Dependencies: The tightly coupled nature of legacy code led
to unexpected side effects during refactoring.
o Solution: Developed comprehensive unit and integration tests
before making changes.
3. Stakeholder Concerns: Business stakeholders were apprehensive about
potential disruptions.
o Solution: Conducted regular demos and maintained transparency
about progress and testing results.

Result:
 The refactored system scaled seamlessly, handling a 3x increase in
transaction volume without performance degradation.
 Response times improved by 40% due to database optimizations and
caching.
  The modular architecture made it easier to add new features, reducing
development time for new components by 30%.
 Stakeholders were satisfied with the smooth transition and uninterrupted
operations.

Key Takeaway: Refactoring legacy systems for scalability requires a balance

between careful planning, incremental changes, and robust testing to ensure
existing functionality remains unaffected. Communication with stakeholders is
critical to gaining trust and ensuring a successful transition.

Q) How do you ensure that your team adheres to Java coding best
practices? Can you share an example where you successfully
implemented or enforced best practices for Java development in your
team?
How I Ensure Adherence to Java Coding Best Practices
1. Establish Clear Coding Standards:
o Created a well-defined style guide based on industry standards like
Google Java Style Guide or Oracle Java Code Conventions.
o Ensured the guide covered topics like naming conventions,
formatting, and best practices for OOP principles.
2. Leverage Automated Tools:
o Code Quality Checks: Integrated tools like Checkstyle, PMD, and
SonarQube into the CI/CD pipeline to identify violations early.
o Formatting: Configured IDEs with consistent formatting rules (e.g.,
Eclipse/IntelliJ IDEA code templates) and enforced their usage.
3. Code Reviews and Peer Learning:
o Conducted thorough code reviews focusing not only on functionality
but also on adherence to best practices.
o Encouraged peer reviews for knowledge sharing and reinforcing
standards.
4. Promote Testing Culture:
o Enforced writing unit tests with tools like JUnit and mocking
frameworks like Mockito.
o Introduced test coverage thresholds to ensure proper test coverage
for critical modules.
5. Training and Knowledge Sharing:
o Organized workshops and knowledge-sharing sessions on Java best
practices, design patterns, and common pitfalls.
 o Shared curated resources like books, blogs, and videos.

Example of Implementing Java Best Practices

Situation: In a previous project, my team faced challenges with inconsistent
coding styles and technical debt due to rushed development. This led to bugs
and reduced maintainability.
Task: As the tech lead, I needed to introduce and enforce coding best practices
to improve code quality and maintainability.

Action Plan:
1. Establishing Coding Standards:
o Collaborated with the team to create a style guide that addressed
common issues observed in our codebase.
o Integrated the guide into a project wiki for easy reference.

2. Automating Quality Checks:

o Introduced SonarQube to the CI/CD pipeline, defining rules for
detecting:
 Unused imports and variables.
 Code smells like duplicate code and overly complex methods.
 Potential bugs, such as null pointer dereferences.
o Configured thresholds for technical debt and code coverage.

3. Refactoring for Best Practices:

o Worked with the team to refactor parts of the codebase,
emphasizing:
 Proper use of design patterns like Singleton for shared
resources and Factory for object creation.
 Favoring Streams and Optional in Java 8+ for cleaner,
functional-style code.
4. Code Review Process:
o Established a robust code review process:

 Each PR required at least two approvals.

 Reviewers focused on adherence to standards, code
readability, and potential performance bottlenecks.
o Encouraged constructive feedback, avoiding a blame culture.

5. Building a Testing Culture:

 o Introduced TDD (Test-Driven Development) practices to the
team.
o Set a 75% minimum code coverage threshold for new code.

o Encouraged integration tests using Spring Boot's test utilities for

end-to-end validation.
6. Continuous Learning:
o Conducted a weekly "Tech Talk" session where developers shared
lessons learned or improvements made in their code.
o Introduced gamification to recognize adherence to best practices
(e.g., “Best Code of the Week” awards).

Result:
 Improved Code Quality: The average SonarQube code smell count
dropped by 60% within three months.
 Consistency: The entire codebase followed a unified style, making it
easier to onboard new developers.
 Maintainability: Refactored modules became easier to extend, reducing
feature delivery time by 25%.
 Team Morale: Developers felt more confident and motivated as they saw
tangible improvements in the code.

Key Takeaway: Adhering to Java coding best practices requires a combination of

clear guidelines, automated enforcement, team education, and a supportive
culture. Empowering the team with the right tools and processes leads to better
code quality and developer satisfaction.
Q) You are investigating an issue and written a JUnit test - it fails as
expected. So you start debugger and step over several times, but the
issue is not reproduced. Why can this happen?
This situation, where a JUnit test fails as expected but stepping through the code
in the debugger does not reproduce the issue, can occur due to timing-related
behaviors or environmental differences between normal execution and
debugging. Here are the common reasons:

1. Timing or Concurrency Issues

 Race Conditions: The issue might depend on the precise order of thread
execution. Debugging introduces delays, altering the thread timings and
masking the issue.
@Test
public void testRaceCondition() throws InterruptedException {
RaceConditionExample example = new RaceConditionExample();

Thread t1 = new Thread(example::incrementCounter);

Thread t2 = new Thread(example::incrementCounter);

t1.start();
t2.start();

t1.join();
t2.join();

// Race condition might cause test failure in normal run, but not in debug mode
assertEquals(2000, example.getCounter());
}
//Explanation:

// In normal execution, thread timings may cause inconsistent results.

// In debug mode, the delay introduced by breakpoints might prevent thread
interference, hiding the race condition.
 Thread Synchronization: Breakpoints or stepping may inadvertently
provide more time for threads to complete their tasks, hiding problems like
missed signals, deadlocks, or incorrect state.
 Timeouts: If the test relies on timeouts, the debugger's slower execution
can prevent timeouts from occurring.

2. Optimizations Skipped in Debug Mode

 JIT Compiler Behavior: When running normally, Java's Just-In-Time (JIT)
compiler optimizes the code for performance. In debug mode, some
optimizations are disabled, which can lead to differences in behavior.
o In a real-world scenario, the JIT compiler might optimize methods
differently during normal execution.Debug mode typically disables
these optimizations, so the behavior might not reproduce in the
debugger.
  Compiler Optimizations: Certain optimizations, such as inlining or
loop unrolling, are not applied during debugging. These optimizations
might cause or hide issues in normal execution.
1. Loop Unrolling
Definition: Loop unrolling expands the loop body to reduce the overhead of loop
control (e.g., incrementing counters and checking conditions).
Example:
javaCopy codepublic class LoopUnrollingExample {
public int sumArray(int[] arr) {
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
return sum;
}
}
Normal Execution: For a small array, the JVM might unroll the loop, effectively
transforming:
javaCopy codesum += arr[0];
sum += arr[1];
sum += arr[2];
This reduces the overhead of checking the loop condition repeatedly.
Debug Mode: Loop unrolling is typically disabled. Each iteration runs
separately, which ensures you can set breakpoints inside the loop.
Potential Issue:
 Bugs that depend on loop behavior (e.g., index out-of-bounds errors)
might behave differently if the loop is unrolled.
2. Method Inlining
Definition: Inlining replaces a method call with the actual code of the method.
This eliminates the overhead of method calls and can improve performance.
Normal Execution: The add() method might be inlined by the JVM, so
calculateSum() directly executes return 3 + 5;.
Debug Mode: Method inlining is often disabled to allow breakpoints inside the
add() method. This means the JVM will call the method normally.
Potential Issue:
  If the add() method has side effects or hidden bugs (e.g., logging,
modifying static state), these might behave differently depending on
whether the method is inlined or not.
public class InliningExample {
public int add(int a, int b) {
return a + b;
}

public int calculateSum() {

return add(3, 5); // Method call may be inlined during normal execution
}
}

3. Environment or State Changes

 Initialization Differences: The debugger might introduce or delay
initialization of certain variables, resulting in a different starting state for
the test.
 Side Effects: Adding breakpoints or logging in debug mode may
inadvertently modify the state of objects, causing the issue to disappear.
 External Dependencies: Interactions with external systems (e.g., file
systems, databases) might behave differently when debugging due to
timing or repeated calls.

4. Flaky Tests or Hidden Assumptions

 Order Dependence: The test might depend on the execution order of
other tests, which can change when run in isolation during debugging.
 Data Pollution: Tests may share data (e.g., static fields, in-memory
caches), leading to inconsistencies that debugging might inadvertently
reset.

Approach to Diagnose the Issue

1. Add Logs: Add more detailed logging to the failing test or suspected code
areas to capture the issue in normal execution.
2. Isolate the Problem: Run the test in isolation, outside of the debugger,
to confirm it is truly independent of other tests.
 3. Reproduce Without Debugger: Use tools like System.nanoTime() or
additional assertions to detect timing-related issues without stepping
through.
4. Simulate Debugging: Introduce artificial delays (Thread.sleep ) or
synchronization in the code to mimic the debugger's behavior and test if it
masks the issue.
5. Concurrency Tools: Use tools like ThreadMXBean or
FindBugs/SpotBugs to detect concurrency-related problems.
6. Stress Testing: Increase the load or frequency of the test using tools like
JMH to amplify timing issues.

Example
Failing Test:
@Test
void testConcurrentAccess() {
ExecutorService executor = Executors.newFixedThreadPool(2);
List<Integer> sharedList = Collections.synchronizedList(new ArrayList<>());

Runnable task = () -> sharedList.add(1);

executor.submit(task);
executor.submit(task);

executor.shutdown();
executor.awaitTermination(1, TimeUnit.SECONDS);

// Fails due to incorrect size calculation

assertEquals(2, sharedList.size());
}
Debugging Masks Issue: Stepping through delays thread execution, allowing
synchronized access to the shared list and preventing the bug. However, in
normal execution, a race condition might cause one thread's update to be lost.
Solution:
 Add logs to observe concurrent execution.
 Use proper synchronization or thread-safe collections like
CopyOnWriteArrayList .
Key Takeaway: The discrepancy occurs because debugging changes the
runtime behavior, especially around timing and state. Diagnosing such issues
requires careful use of logging, isolation, and tools to simulate normal execution
conditions.
Q) How do you conduct code reviews for Java code? Can you provide an
example where you gave feedback on a Java-specific design pattern or
coding practice? How did you ensure the developer understood and
implemented the changes?
How I Conduct Code Reviews for Java Code
1. Understand the Context:
o Begin by reading the purpose of the changes and the associated
requirements or ticket.
o Analyze the scope and impact of the changes to identify
dependencies or potential side effects.
2. Follow a Checklist:
o Code Correctness: Ensure the logic matches requirements and
covers edge cases.
o Adherence to Standards: Verify compliance with Java-specific
conventions, such as naming, formatting, and structure.
o Performance: Check for efficient use of Java constructs, data
structures, and algorithms.
o Readability: Assess code for clarity, maintainability, and
meaningful comments.
o Testing: Ensure sufficient unit and integration tests are included
with proper assertions and edge cases.
3. Focus on Core Concepts:
o Review design patterns for correctness and applicability.

o Validate the handling of concurrency, exceptions, and resource

management.
4. Provide Constructive Feedback:
o Use inline comments for specific issues and a summary for high-
level concerns.
o Provide actionable and precise suggestions, avoiding overly critical
language.
Examples of Multiple Java Design Patterns with Explanations

1. Singleton Pattern
public class ConfigurationManager {
private static ConfigurationManager instance;
private Properties properties;

private ConfigurationManager() {
properties = new Properties();
// Load properties from a file or other source
}

public static synchronized ConfigurationManager getInstance() {

if (instance == null) {
instance = new ConfigurationManager();
}
return instance;
}

public String getProperty(String key) {

return properties.getProperty(key);
}
}
 Use lazy initialization only when creating the instance is expensive.

2. Factory Pattern
public interface Notification {
void notifyUser();
}

public class SMSNotification implements Notification {

public void notifyUser() {
System.out.println("Sending SMS notification");
}
}
public class EmailNotification implements Notification {
public void notifyUser() {
System.out.println("Sending Email notification");
}
}

public class NotificationFactory {

public static Notification createNotification(String type) {
switch (type) {
case "SMS":
return new SMSNotification();
case "Email":
return new EmailNotification();
default:
throw new IllegalArgumentException("Unknown type: " + type);
}
}
}
Notification notification = NotificationFactory.createNotification("SMS");
notification.notifyUser();
 Avoid adding too many conditionals by leveraging an enum-based
factory.
 Use reflection for more dynamic object creation.

3. Strategy Pattern
public interface DiscountStrategy {
double applyDiscount(double price);
}

public class SeasonalDiscount implements DiscountStrategy {

public double applyDiscount(double price) {
 return price * 0.9; // 10% discount
}
}

public class ClearanceDiscount implements DiscountStrategy {

public double applyDiscount(double price) {
return price * 0.5; // 50% discount
}
}

public class PriceCalculator {

private DiscountStrategy strategy;

public PriceCalculator(DiscountStrategy strategy) {

this.strategy = strategy;
}

public double calculatePrice(double price) {

return strategy.applyDiscount(price);
}
}
PriceCalculator calculator = new PriceCalculator(new SeasonalDiscount());
System.out.println("Final Price: " + calculator.calculatePrice(100.0));
 Use a context class (e.g., PriceCalculator ) to encapsulate the strategy.
 Avoid hardcoding strategies; use dependency injection to pass them
dynamically.

4. Observer Pattern
import java.util.ArrayList;
import java.util.List;

public class Subject {

 private List<Observer> observers = new ArrayList<>();
private String state;

public void attach(Observer observer) {

observers.add(observer);
}

public void detach(Observer observer) {

observers.remove(observer);
}

public void setState(String state) {

this.state = state;
notifyObservers();
}

private void notifyObservers() {

for (Observer observer : observers) {
observer.update(state);
}
}
}

public interface Observer {

void update(String state);
}

public class ConcreteObserver implements Observer {

private String name;

public ConcreteObserver(String name) {

this.name = name;
 }

public void update(String state) {

System.out.println(name + " received update: " + state);
}
}
Subject subject = new Subject();
Observer observer1 = new ConcreteObserver("Observer 1");
Observer observer2 = new ConcreteObserver("Observer 2");

subject.attach(observer1);
subject.attach(observer2);

subject.setState("New State");
 Use Java’s java.util.Observable and Observer for built-in support
(deprecated but still instructive).
 Ensure observers unsubscribe to prevent memory leaks.

5. Decorator Pattern
public interface Pizza {
String getDescription();
double getCost();
}

public class BasicPizza implements Pizza {

public String getDescription() {
return "Basic Pizza";
}

public double getCost() {

return 5.0;
}
}

public abstract class PizzaDecorator implements Pizza {

protected Pizza pizza;

public PizzaDecorator(Pizza pizza) {

this.pizza = pizza;
}

public String getDescription() {

return pizza.getDescription();
}

public double getCost() {

return pizza.getCost();
}
}

public class CheeseTopping extends PizzaDecorator {

public CheeseTopping(Pizza pizza) {
super(pizza);
}

public String getDescription() {

return super.getDescription() + ", Cheese";
}

public double getCost() {

return super.getCost() + 2.0;
}
}
public class PepperoniTopping extends PizzaDecorator {
public PepperoniTopping(Pizza pizza) {
super(pizza);
}

public String getDescription() {

return super.getDescription() + ", Pepperoni";
}

public double getCost() {

return super.getCost() + 3.0;
}
}
Pizza pizza = new BasicPizza();
pizza = new CheeseTopping(pizza);
pizza = new PepperoniTopping(pizza);

System.out.println("Description: " + pizza.getDescription());

System.out.println("Cost: " + pizza.getCost());
 Avoid excessive decorator chaining by grouping common behaviors.
 Prefer composition over inheritance for flexibility.

6. Proxy Pattern
public interface Image {
void display();
}

public class RealImage implements Image {

private String fileName;

public RealImage(String fileName) {

this.fileName = fileName;
 loadImageFromDisk();
}

private void loadImageFromDisk() {

System.out.println("Loading " + fileName);
}

public void display() {

System.out.println("Displaying " + fileName);
}
}

public class ProxyImage implements Image {

private RealImage realImage;
private String fileName;

public ProxyImage(String fileName) {

this.fileName = fileName;
}

public void display() {

if (realImage == null) {
realImage = new RealImage(fileName);
}
realImage.display();
}
}
Image image = new ProxyImage("test.jpg");
image.display(); // Loads and displays
image.display(); // Only displays
 Use proxies for lazy loading, security checks, or access control.
 Ensure the proxy doesn't introduce significant overhead.
Question: What is Meta Space in Java.
What if you return constant hash code of 1 from hash code method.
Synchronized member method versus static synchronized method.
How would you read a large file efficiently without running out of
memory?