Infosys Java Developer Interview Questions for 5 Years Experience

Infosys is one of India's largest IT services companies and a dream destination for many Java developers looking to move into a stable, well-paying role with global client exposure. But their interview process for experienced developers — particularly those with 5 years of experience — goes well beyond basic Java syntax. They test Core Java internals, Spring Boot, microservices, SQL, design patterns, Stream API, and your ability to explain real decisions you made in production projects.

This guide covers the most frequently asked Infosys interview questions for Java developers with 4–6 years of experience, based on real candidate experiences from 2025–2026. Every question includes the kind of detailed answer that gets you through the technical rounds — not just the definition, but the depth Infosys interviewers are looking for.

Infosys Interview Process for Experienced Java Developers

Infosys typically conducts two technical rounds followed by a managerial round. For experienced candidates, the process generally looks like this:

• Round 1 — Technical Interview 1 — Core Java, OOP, Collections, Java 8 features, coding questions. Duration: 45–60 minutes.
• Round 2 — Technical Interview 2 — Spring Boot, microservices, SQL, design patterns, system design basics, project deep dive. Duration: 45–60 minutes.
• Round 3 — Managerial Round — Project experience, problem-solving approach, team scenarios, role and responsibilities. Duration: 30–45 minutes.
• Round 4 — HR Round — Compensation, notice period, relocation, joining date.

1. Java 8 — Stream API and Lambda Expressions

Coding questions on Lambda, Stream API and Collection framework are regularly asked at Infosys. This is the most common Java 8 topic. Be ready to both explain and write code.

// Lambda — anonymous function syntax
// Before Java 8
Runnable r = new Runnable() {
    public void run() { System.out.println("Running"); }
};

// Java 8 Lambda
Runnable r = () -> System.out.println("Running");

// Stream API — common operations asked at Infosys
List<Integer> numbers = Arrays.asList(5, 2, 8, 1, 9, 3, 7, 4, 6);

// Filter + collect
List<Integer> evens = numbers.stream()
    .filter(n -> n % 2 == 0)
    .collect(Collectors.toList());
// [2, 8, 4, 6]

// Map + sorted + collect
List<Integer> sortedDoubled = numbers.stream()
    .map(n -> n * 2)
    .sorted()
    .collect(Collectors.toList());

// findFirst after filter
Optional<Integer> firstGreaterThan5 = numbers.stream()
    .filter(n -> n > 5)
    .findFirst();

// count
long count = numbers.stream()
    .filter(n -> n > 5)
    .count(); // 4

// reduce
int sum = numbers.stream()
    .reduce(0, Integer::sum); // 45

// Collectors.groupingBy
List<String> words = Arrays.asList("apple", "banana", "cherry", "avocado", "blueberry");
Map<Character, List<String>> grouped = words.stream()
    .collect(Collectors.groupingBy(w -> w.charAt(0)));
// {a=[apple, avocado], b=[banana, blueberry], c=[cherry]}

2. Collections Framework — HashMap, List, Set Internals

Infosys asks candidates to explain the Collection Framework in full — List, Map, Set and their implementations.

// HashMap internal working — most asked
// - Backed by array of Node (buckets)
// - hashCode() determines bucket index
// - equals() resolves collisions within bucket
// - Java 8+: linked list converts to Red-Black Tree when bucket > 8 entries
// - Default capacity: 16 | Load factor: 0.75 | Resizes when 75% full

// Difference between HashMap, LinkedHashMap, TreeMap
// HashMap       → no order, O(1) get/put
// LinkedHashMap → insertion order maintained, O(1) get/put
// TreeMap       → sorted by key (natural/comparator), O(log n)

// ArrayList vs LinkedList
// ArrayList  → dynamic array, O(1) random access, O(n) insert/delete middle
// LinkedList → doubly linked list, O(n) access, O(1) insert/delete at known position

// HashSet vs LinkedHashSet vs TreeSet
// HashSet       → no order, O(1)
// LinkedHashSet → insertion order, O(1)
// TreeSet       → sorted, O(log n)

// Thread-safe alternatives
// HashMap         → ConcurrentHashMap (bucket-level lock, lock-free reads)
// ArrayList       → CopyOnWriteArrayList (creates new copy on every write)
// Collections.synchronizedList() → full lock on every operation (avoid)

3. String vs StringBuilder vs StringBuffer

A very commonly asked basic question that trips many candidates because the answer requires knowing Java memory internals:

// String — immutable, stored in String Pool
String s1 = "Hello";
String s2 = "Hello";
System.out.println(s1 == s2);       // true — same pool reference
System.out.println(s1 == new String("Hello")); // false — new object in heap

// String concatenation in loop — NEVER do this
String result = "";
for (int i = 0; i < 1000; i++) {
    result += i; // creates 1000 new String objects → O(n²) memory and time
}

// StringBuilder — mutable, NOT thread-safe, best for single thread
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append(i); // modifies same object → O(n) time
}
String result = sb.toString();

// StringBuffer — mutable, thread-safe (synchronized methods), slower than StringBuilder
StringBuffer sbf = new StringBuffer();
sbf.append("thread-safe");

// When to use which:
// Constant string value → String
// Single thread, building string in loop → StringBuilder
// Multiple threads appending to same string → StringBuffer

4. Exception Handling Best Practices

// Exception hierarchy
// Throwable
// ├── Error (JVM level — don't catch: OutOfMemoryError, StackOverflowError)
// └── Exception
//     ├── RuntimeException (unchecked)
//     │   ├── NullPointerException
//     │   ├── IllegalArgumentException
//     │   └── ArrayIndexOutOfBoundsException
//     └── IOException (checked — compiler forces handling)

// ❌ Common bad practices
try {
    processData();
} catch (Exception e) {
    // Catching generic Exception — swallows all errors silently
    e.printStackTrace(); // log properly instead
}

// ✅ Best practices
try {
    processPayment(order);
} catch (PaymentGatewayException e) {
    log.error("Payment failed for order {}: {}", order.getId(), e.getMessage());
    throw new ServiceException("Payment processing failed", e); // preserve stack trace
} finally {
    cleanupResources(); // always runs — for closing connections, streams
}

// Custom exception — always create for domain errors
public class InsufficientBalanceException extends RuntimeException {
    private final double required;
    private final double available;

    public InsufficientBalanceException(double required, double available) {
        super(String.format("Insufficient balance. Required: %.2f, Available: %.2f",
                            required, available));
        this.required  = required;
        this.available = available;
    }
}

// Multi-catch — Java 7+
try {
    processData();
} catch (IOException | SQLException e) {
    log.error("Data processing failed", e);
}

5. Singleton Design Pattern — Including Thread-Safe Version

Design patterns especially Singleton with tricky questions are regularly asked at Infosys. Know all three variations:

// Version 1 — Eager initialization (simple but wastes memory if never used)
public class Config {
    private static final Config INSTANCE = new Config(); // created at class load
    private Config() {}
    public static Config getInstance() { return INSTANCE; }
}

// Version 2 — Lazy initialization (NOT thread-safe)
public class Config {
    private static Config instance;
    private Config() {}

    public static Config getInstance() {
        if (instance == null) {           // race condition here
            instance = new Config();
        }
        return instance;
    }
}

// Version 3 — Double-checked locking (thread-safe, lazy, recommended)
public class Config {
    private static volatile Config instance; // volatile prevents instruction reordering
    private Config() {}

    public static Config getInstance() {
        if (instance == null) {                    // first check (no lock — fast)
            synchronized (Config.class) {
                if (instance == null) {            // second check (with lock — safe)
                    instance = new Config();
                }
            }
        }
        return instance;
    }
}

// Version 4 — Bill Pugh (best — uses class loader guarantee)
public class Config {
    private Config() {}

    private static class ConfigHolder {
        private static final Config INSTANCE = new Config();
        // Inner class loaded only when getInstance() is called
    }

    public static Config getInstance() {
        return ConfigHolder.INSTANCE;
    }
}

6. Spring Boot — Auto-Configuration and Key Annotations

Infosys interviewers test whether you can explain Spring Boot project decisions clearly. Know the internals, not just how to use annotations.

// @SpringBootApplication = @Configuration + @EnableAutoConfiguration + @ComponentScan
// Auto-configuration scans META-INF/spring.factories in all classpath JARs
// Conditionally loads beans based on @Conditional annotations

// Key Spring Boot annotations — be ready to explain any of these
@RestController    // @Controller + @ResponseBody — returns JSON directly
@RequestMapping("/api/users")
@GetMapping("/{id}")        // GET /api/users/{id}
@PostMapping                // POST /api/users
@PutMapping("/{id}")        // PUT /api/users/{id}
@DeleteMapping("/{id}")     // DELETE /api/users/{id}

@PathVariable  // extract from URL path: /users/{id}
@RequestParam  // extract from query string: /users?name=Randhir
@RequestBody   // extract from request body (JSON → object)

@Autowired     // inject dependency (prefer constructor injection)
@Service       // business logic layer bean
@Repository    // data access layer bean — enables exception translation
@Component     // generic Spring-managed bean
@Configuration // configuration class — source of @Bean definitions

@Transactional // wrap method in a database transaction
// If any exception — rolls back all DB changes in the method

// Spring Boot Request lifecycle:
// HTTP Request
// → DispatcherServlet
// → HandlerMapping (finds correct controller method)
// → HandlerAdapter (calls controller)
// → Controller method executes
// → ResponseBody (serializes return value to JSON)
// → HTTP Response

7. REST API Design — Best Practices

// REST naming conventions
// Use nouns, not verbs — the HTTP method is the verb

// ✅ Correct REST endpoints
GET    /api/users           → get all users
GET    /api/users/{id}      → get user by ID
POST   /api/users           → create user
PUT    /api/users/{id}      → update user (full update)
PATCH  /api/users/{id}      → partial update
DELETE /api/users/{id}      → delete user

GET    /api/users/{id}/orders  → get orders for specific user

// ❌ Wrong — verbs in URL
GET /api/getUsers
POST /api/createUser
DELETE /api/deleteUser/{id}

// HTTP Status codes — know these
200 OK              → successful GET, PUT
201 Created         → successful POST (include Location header)
204 No Content      → successful DELETE
400 Bad Request     → invalid input, validation failed
401 Unauthorized    → not authenticated
403 Forbidden       → authenticated but no permission
404 Not Found       → resource does not exist
409 Conflict        → resource already exists
422 Unprocessable   → validation error (field-level)
500 Internal Server Error → unexpected server-side failure

// Versioning — always version your APIs
GET /api/v1/users
GET /api/v2/users  // breaking change? bump version

// Spring Boot REST controller example
@RestController
@RequestMapping("/api/v1/users")
public class UserController {

    private final UserService userService;

    // Constructor injection — preferred
    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public ResponseEntity<UserDto> getUser(@PathVariable Long id) {
        return ResponseEntity.ok(userService.findById(id));
    }

    @PostMapping
    public ResponseEntity<UserDto> createUser(@Valid @RequestBody CreateUserRequest request) {
        UserDto created = userService.create(request);
        URI location = URI.create("/api/v1/users/" + created.getId());
        return ResponseEntity.created(location).body(created);
    }
}

8. Microservices — Communication and Patterns

Infosys interviews include questions on microservices, Kafka, and Spring Boot at medium difficulty.

// Microservices communication types
// Synchronous — REST (HTTP) or gRPC
// Service A calls Service B and waits for response
// Problem: tight coupling — if B is slow, A is slow

// Asynchronous — Message queues (Kafka, RabbitMQ)
// Service A publishes event to topic
// Service B consumes from topic independently
// Advantage: decoupled, B being down does not affect A immediately

// Kafka basics — commonly asked at Infosys
// Producer → publishes messages to a Topic
// Consumer → reads messages from a Topic
// Consumer Group → multiple consumers share the load
// Partition → topics are split into partitions for parallelism
// Offset → position of last message read by consumer

// Key microservices patterns Infosys asks about:

// 1. Circuit Breaker (Resilience4j)
@CircuitBreaker(name = "paymentService", fallbackMethod = "paymentFallback")
public PaymentResponse pay(Order order) {
    return paymentClient.process(order);
}
public PaymentResponse paymentFallback(Order order, Exception ex) {
    return PaymentResponse.queued(order.getId()); // graceful degradation
}

// 2. API Gateway — single entry point
// Handles: routing, authentication, rate limiting, load balancing
// Examples: Spring Cloud Gateway, Kong, AWS API Gateway

// 3. Service Discovery — Eureka
// Services register on startup → other services look up by name
// No hardcoded IPs — services can scale and move dynamically

// 4. Distributed Tracing — Sleuth + Zipkin
// Each request gets a trace ID that flows through all services
// Helps debug which service is slow in a chain of calls

9. SQL — Joins, Indexes, Complex Queries

SQL questions at Infosys cover Joins, Primary Key, Foreign Key and complex queries.

-- Second highest salary — almost always asked
SELECT MAX(salary) AS second_highest
FROM employees
WHERE salary < (SELECT MAX(salary) FROM employees);

-- Or using DENSE_RANK
SELECT salary FROM (
    SELECT salary, DENSE_RANK() OVER (ORDER BY salary DESC) AS rnk
    FROM employees
) ranked WHERE rnk = 2;

-- Get employees with no manager (top-level)
SELECT name FROM employees WHERE manager_id IS NULL;

-- Department wise highest salary
SELECT department, MAX(salary) AS max_salary
FROM employees
GROUP BY department
ORDER BY max_salary DESC;

-- INNER JOIN — only matching rows
SELECT e.name, d.department_name
FROM employees e
INNER JOIN departments d ON d.id = e.department_id;

-- LEFT JOIN — all employees, even without department
SELECT e.name, d.department_name
FROM employees e
LEFT JOIN departments d ON d.id = e.department_id;

-- Self join — employee and their manager
SELECT e.name AS employee, m.name AS manager
FROM employees e
JOIN employees m ON m.id = e.manager_id;

-- Index — when to use
CREATE INDEX idx_employees_dept ON employees(department_id);
-- Use when: column used in WHERE, JOIN, ORDER BY on large tables
-- Avoid when: column has low cardinality (gender, boolean)
-- Always: avoid functions on indexed columns in WHERE clause
-- ❌ WHERE YEAR(join_date) = 2024  → full scan
-- ✅ WHERE join_date >= '2024-01-01' AND join_date < '2025-01-01'  → index used

10. Multithreading and Thread Safety

// Thread creation — two ways
// 1. Extending Thread
class MyThread extends Thread {
    public void run() { System.out.println("Running in thread"); }
}
new MyThread().start();

// 2. Implementing Runnable (preferred — allows class to extend something else)
class MyTask implements Runnable {
    public void run() { System.out.println("Task running"); }
}
new Thread(new MyTask()).start();

// ExecutorService — proper way in production
ExecutorService executor = Executors.newFixedThreadPool(5);
executor.submit(() -> processOrder(order));
executor.shutdown();

// synchronized — mutual exclusion
public class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++; // only one thread at a time
    }

    public synchronized int getCount() { return count; }
}

// AtomicInteger — faster than synchronized for simple counters
AtomicInteger counter = new AtomicInteger(0);
counter.incrementAndGet(); // thread-safe, lock-free

// volatile — visibility guarantee (not atomicity)
private volatile boolean isRunning = true;
// All threads always read latest value from main memory

// Deadlock — how to explain it
// Thread A holds Lock 1, waits for Lock 2
// Thread B holds Lock 2, waits for Lock 1
// Both wait forever — deadlock
// Prevention: always acquire locks in the same order

11. JVM Internals and Garbage Collection

// JVM components:
// Class Loader → loads .class files (Bootstrap, Extension, Application)
// Method Area  → class metadata, static variables
// Heap         → all objects (Young Gen + Old Gen)
// Stack        → one per thread, method frames, local variables
// Execution Engine → Interpreter + JIT Compiler + GC

// Heap memory structure
// Young Generation:
//   Eden Space    → new objects created here
//   Survivor S0, S1 → objects that survived Minor GC
// Old Generation  → objects that survived multiple GC cycles (tenured)
// Metaspace       → class metadata (replaced PermGen in Java 8)

// GC types:
// Minor GC → cleans Young Generation (fast, frequent)
// Major GC → cleans Old Generation (slower, less frequent)
// Full GC  → cleans entire heap (slowest — avoid in production)

// G1GC — default since Java 9
// Divides heap into equal-sized regions
// Collects regions with most garbage first
// Target pause time: -XX:MaxGCPauseMillis=200

// Common JVM flags for Infosys projects:
// -Xms512m       → initial heap size
// -Xmx4g         → max heap size
// -XX:+UseG1GC   → use G1 collector
// -verbose:gc    → log GC activity

12. OOP Pillars — With Project Examples

Infosys asks OOP explanation of each pillar and specifically asks about involvement of any pillar in your project. Always connect each concept to a real example from your work.

// 1. Encapsulation — hide internal data, expose through methods
public class BankAccount {
    private double balance; // private — cannot access directly
    private String accountNumber;

    public double getBalance() { return balance; } // controlled access

    public void deposit(double amount) {
        if (amount <= 0) throw new IllegalArgumentException("Amount must be positive");
        balance += amount; // validation before modification
    }
}
// "In my project, I used encapsulation in the UserService class where
//  user credentials were private and only exposed through validated setters."

// 2. Inheritance — reuse and extend parent behaviour
public class Animal { public void breathe() { System.out.println("breathing"); } }
public class Dog extends Animal { public void bark() { System.out.println("woof"); } }
// Dog inherits breathe() and adds bark()

// 3. Polymorphism — same interface, different behaviour
public abstract class Notification {
    public abstract void send(String message);
}
public class EmailNotification extends Notification {
    public void send(String msg) { // send via email }
}
public class SMSNotification extends Notification {
    public void send(String msg) { // send via SMS }
}

// Runtime polymorphism — decided at runtime
Notification notifier = new EmailNotification();
notifier.send("Hello"); // calls EmailNotification.send()

// 4. Abstraction — hide complexity, expose only what is necessary
public interface PaymentGateway {
    PaymentResult processPayment(Order order); // what it does
    // HOW it does it is hidden in the implementation
}
// Client code uses PaymentGateway without knowing if it is Razorpay or Stripe

13. Hibernate and JPA — Commonly Asked at Infosys

// JPA — specification (interface)
// Hibernate — most popular JPA implementation

// Entity mapping
@Entity
@Table(name = "employees")
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "first_name", nullable = false, length = 50)
    private String firstName;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "department_id")
    private Department department;

    @OneToMany(mappedBy = "employee", cascade = CascadeType.ALL)
    private List<Project> projects;
}

// FetchType — important interview question
// LAZY  → related data loaded on demand (when accessed) — default for collections
// EAGER → related data loaded immediately with parent — can cause N+1 problem

// N+1 problem and fix
// ❌ N+1 — one query for employees + one per employee for department
List<Employee> employees = employeeRepo.findAll();
employees.forEach(e -> System.out.println(e.getDepartment().getName())); // N queries

// ✅ Fix — FETCH JOIN in JPQL
@Query("SELECT e FROM Employee e JOIN FETCH e.department")
List<Employee> findAllWithDepartment();
// One query with JOIN — no N+1

// Cascade types
// CascadeType.PERSIST → save child when parent saved
// CascadeType.MERGE   → update child when parent updated
// CascadeType.REMOVE  → delete child when parent deleted
// CascadeType.ALL     → all of the above

14. Agile and Scrum Process

Infosys asks about Agile environment and the step-by-step process. Be ready to explain your team's actual workflow:

• Sprint — fixed time box (typically 2 weeks) for delivering working software. Every sprint ends with a potentially shippable product increment.
• Sprint Planning — team selects items from the product backlog and commits to completing them in the sprint.
• Daily Standup — 15-minute daily meeting: what I did yesterday, what I will do today, any blockers.
• Sprint Review — demo working software to stakeholders at end of sprint. Gather feedback.
• Sprint Retrospective — team reflects on process: what went well, what to improve.
• User Story — requirement written from user perspective: "As a user, I want to reset my password, so that I can regain access to my account." Has acceptance criteria.
• Story Points — relative effort estimation (Fibonacci: 1, 2, 3, 5, 8, 13). Not hours — complexity and uncertainty.

Connect your answer to real experience: "In my current project we run 2-week sprints. I participate in planning, daily standups, and take ownership of 3–5 story points per sprint on average."

15. Coding Questions — Most Asked at Infosys

Infosys coding problems are typically LeetCode Medium level or slightly easier. They expect correct, working solutions.

// 1. Reverse a String
public String reverseString(String s) {
    return new StringBuilder(s).reverse().toString();
    // Or two pointer:
    char[] arr = s.toCharArray();
    int left = 0, right = arr.length - 1;
    while (left < right) {
        char temp = arr[left]; arr[left] = arr[right]; arr[right] = temp;
        left++; right--;
    }
    return new String(arr);
}

// 2. Check if string is palindrome
public boolean isPalindrome(String s) {
    s = s.toLowerCase().replaceAll("[^a-z0-9]", "");
    int left = 0, right = s.length() - 1;
    while (left < right) {
        if (s.charAt(left) != s.charAt(right)) return false;
        left++; right--;
    }
    return true;
}

// 3. Find second largest number in array
public int secondLargest(int[] arr) {
    int first = Integer.MIN_VALUE, second = Integer.MIN_VALUE;
    for (int num : arr) {
        if (num > first) { second = first; first = num; }
        else if (num > second && num != first) { second = num; }
    }
    return second;
}

// 4. Count occurrences of each character
public Map<Character, Integer> charCount(String s) {
    Map<Character, Integer> map = new LinkedHashMap<>();
    for (char c : s.toCharArray()) {
        map.merge(c, 1, Integer::sum);
    }
    return map;
}

// 5. Fibonacci — iterative (preferred for large n)
public int fibonacci(int n) {
    if (n <= 1) return n;
    int a = 0, b = 1;
    for (int i = 2; i <= n; i++) {
        int temp = a + b; a = b; b = temp;
    }
    return b;
}

// 6. Using Stream API — find all employees earning > 50000
List<Employee> result = employees.stream()
    .filter(e -> e.getSalary() > 50000)
    .sorted(Comparator.comparing(Employee::getName))
    .collect(Collectors.toList());

Infosys Interview Tips From Real Candidates

• Always connect answers to your project — specific examples are more convincing than generic knowledge. Say "In my project at [company], we used X because Y" not just "X is used for Y."
• Know your resume cold — every technology you list is fair game. If your resume says Kafka, expect Kafka questions. Only list what you can speak about confidently.
• Think out loud during coding — Infosys interviewers want to see how you approach a problem. Narrate your thinking, mention edge cases, state time complexity.
• Prepare for the project deep-dive — the managerial round will ask about your current project architecture, your specific role and contributions, challenges you faced, and how you resolved them.
• Be honest about what you do not know — saying "I have not worked with that directly but here is how I would approach it" is far better than bluffing through an answer.

Related Interview Preparation Guides

• → Java Interview Questions for 6+ Years Experience
• → SQL Queries Asked in Java Interviews
• → SQL Interview Questions for Senior Developers
• → Array Coding Interview Problems
• → String Coding Interview Problems
• → Common Developer Interview Questions and Answers