Accenture Java interview Questions and Answers

Table of contents

• Given number is a prime number
• Singleton design pattern
• Longest substring
• Reverse a linked list in Java
• Two sorted arrays into a single sorted array
• ScenarioBased Java Interview Questions

Accenture is a leading global professional services company, providing a broad range of services and solutions in strategy, consulting, digital, technology, and operations. With a presence in over 120 countries, Accenture serves clients across various industries, helping them enhance their performance and create sustainable value for their stakeholders. The company’s comprehensive range of capabilities is powered by an extensive network of technology partners, enabling it to deliver innovative solutions that drive transformation and growth. Accenture’s commitment to fostering a culture of inclusion and diversity is also a cornerstone of its approach, ensuring that its workforce reflects the diverse perspectives of its global clientele.

Accenture’s scale is immense, employing more than 500,000 professionals worldwide, with a significant portion of its workforce based in India. In India alone, Accenture hires tens of thousands of new employees each year to support its rapidly growing operations and to maintain its competitive edge in the industry. This hiring spree includes a substantial number of Java developers, reflecting the high demand for skilled professionals in this programming language. Java developers at Accenture play a crucial role in developing, deploying, and maintaining robust and scalable applications that meet the evolving needs of clients.

For aspiring Java developers, preparing for interviews at Accenture involves understanding and mastering a range of technical and problem-solving skills. The following Java interview questions are designed to assess a candidate’s proficiency in Java, their ability to solve complex problems, and their understanding of best practices in software development. By familiarizing themselves with these questions, aspirants can gain a competitive edge, improve their technical acumen, and increase their chances of securing a position at Accenture. This preparation not only helps candidates perform well in interviews but also equips them with the knowledge and skills necessary to thrive in a dynamic and challenging work environment.

1. Write a Java program to check if a given number is a prime number.

public class PrimeNumberCheck {
    public static boolean isPrime(int number) {
        if (number <= 1) {
            return false;
        }
        for (int i = 2; i <= Math.sqrt(number); i++) {
            if (number % i == 0) {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        int number = 29;
        if (isPrime(number)) {
            System.out.println(number + " is a prime number.");
        } else {
            System.out.println(number + " is not a prime number.");
        }
    }
}

Explanation:

• The isPrime method checks if a given number is a prime number.
• Numbers less than or equal to 1 are not prime, so the method returns false for them.
• For numbers greater than 1, it checks divisibility from 2 up to the square root of the number.
• If any divisor is found, the method returns false; otherwise, it returns true.
• The main method tests this functionality with the number 29 and prints the result.

2. How would you implement a Singleton design pattern in Java?

public class Singleton {
    private static Singleton instance;

    private Singleton() {
        // private constructor to prevent instantiation
    }

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

Explanation:

• The Singleton pattern ensures that only one instance of a class is created.
• The Singleton class has a private static variable instance to hold the single instance.
• The constructor is private to prevent external instantiation.
• The getInstance method checks if the instance is null. If it is, it creates a new instance. Otherwise, it returns the existing instance.

Read more: Arrays in Java interview Questions and Answers

3. Write a Java program to find the longest substring without repeating characters in a given string.

import java.util.HashMap;

public class LongestSubstring {
    public static int lengthOfLongestSubstring(String s) {
        int n = s.length();
        int maxLength = 0;
        HashMap<Character, Integer> map = new HashMap<>();

        for (int start = 0, end = 0; end < n; end++) {
            char currentChar = s.charAt(end);
            if (map.containsKey(currentChar)) {
                start = Math.max(map.get(currentChar) + 1, start);
            }
            map.put(currentChar, end);
            maxLength = Math.max(maxLength, end - start + 1);
        }
        return maxLength;
    }

    public static void main(String[] args) {
        String s = "abcabcbb";
        System.out.println("The length of the longest substring without repeating characters is: " + lengthOfLongestSubstring(s));
    }
}

Explanation:

• The lengthOfLongestSubstring method finds the length of the longest substring without repeating characters.
• It uses a HashMap to store the last seen index of each character.
• Two pointers, start and end, are used to track the current window of characters.
• As the end pointer moves, the start pointer adjusts to ensure no characters are repeated in the current window.
• The maximum length of the window is updated and returned.
• The main method tests this functionality with the string “abcabcbb” and prints the result.

4. How can you reverse a linked list in Java without using recursion?

class Node {
    int data;
    Node next;

    Node(int data) {
        this.data = data;
        this.next = null;
    }
}

public class LinkedList {
    Node head;

    public void reverse() {
        Node prev = null;
        Node current = head;
        Node next = null;
        while (current != null) {
            next = current.next;
            current.next = prev;
            prev = current;
            current = next;
        }
        head = prev;
    }

    public void printList() {
        Node temp = head;
        while (temp != null) {
            System.out.print(temp.data + " ");
            temp = temp.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.head = new Node(1);
        list.head.next = new Node(2);
        list.head.next.next = new Node(3);
        list.head.next.next.next = new Node(4);

        System.out.println("Original list:");
        list.printList();

        list.reverse();

        System.out.println("Reversed list:");
        list.printList();
    }
}

Explanation:

• The reverse method reverses a singly linked list iteratively.
• Three pointers, prev, current, and next, are used to reverse the direction of the list nodes.
• prev is initially null, current is the head of the list, and next is used to temporarily store the next node.
• In a loop, the next pointer is updated to the next node, current.next is set to prev, and prev and current are moved one step forward.
• After the loop, head is updated to prev.
• The main method creates a linked list, prints it, reverses it, and prints the reversed list.

Read more: TCS Java Interview Questions

5. Write a Java program to merge two sorted arrays into a single sorted array.

import java.util.Arrays;

public class MergeSortedArrays {
    public static int[] merge(int[] arr1, int[] arr2) {
        int n1 = arr1.length;
        int n2 = arr2.length;
        int[] mergedArray = new int[n1 + n2];

        int i = 0, j = 0, k = 0;
        while (i < n1 && j < n2) {
            if (arr1[i] <= arr2[j]) {
                mergedArray[k++] = arr1[i++];
            } else {
                mergedArray[k++] = arr2[j++];
            }
        }

        while (i < n1) {
            mergedArray[k++] = arr1[i++];
        }

        while (j < n2) {
            mergedArray[k++] = arr2[j++];
        }

        return mergedArray;
    }

    public static void main(String[] args) {
        int[] arr1 = {1, 3, 5, 7};
        int[] arr2 = {2, 4, 6, 8};
        int[] mergedArray = merge(arr1, arr2);

        System.out.println("Merged array: " + Arrays.toString(mergedArray));
    }
}

Explanation:

• The merge method merges two sorted arrays into a single sorted array.
• It takes two input arrays, arr1 and arr2, and creates a new array mergedArray to hold the merged result.
• Three pointers, i, j, and k, are used to track the current position in arr1, arr2, and mergedArray, respectively.
• In a loop, the method compares the current elements of arr1 and arr2, adding the smaller element to mergedArray and moving the corresponding pointer forward.
• After the loop, any remaining elements in arr1 or arr2 are copied to mergedArray.
• The main method tests this functionality with two sorted arrays and prints the merged result.

Scenario-Based Java Interview Questions

1. Describe a situation where you had to optimize a Java application for performance. What steps did you take, and what was the outcome?

Answer: In a previous project, I was tasked with optimizing a Java-based web application that was experiencing significant performance issues, particularly during peak usage times. The application suffered from slow response times and frequent timeouts.

Steps Taken:

1. Profiling and Monitoring: I started by using profiling tools like JProfiler to identify performance bottlenecks. I monitored CPU usage, memory consumption, and response times.
2. Database Optimization: I discovered that several SQL queries were inefficient, causing delays. I optimized these queries by adding appropriate indexes, rewriting complex joins, and reducing the number of queries by implementing batch processing.
3. Code Refactoring: I identified redundant code and optimized loops and algorithms to reduce time complexity. I also removed unnecessary synchronization to improve thread performance.
4. Caching: Implemented caching strategies using tools like Ehcache to reduce the load on the database and improve response times for frequently accessed data.
5. Garbage Collection Tuning: Adjusted JVM garbage collection settings to reduce pause times and improve memory management.

Outcome: These optimizations resulted in a significant improvement in application performance. Response times were reduced by 50%, and the application could handle a higher number of concurrent users without timing out. Overall, user satisfaction and system stability improved markedly.

Read more: List Class in Salesforce Apex

2. Imagine you are given a legacy Java application that has numerous bugs and performance issues. How would you approach debugging and improving the application?

Answer: Approach:

1. Initial Assessment: Conduct a thorough assessment to understand the current state of the application. This includes reviewing documentation (if available), talking to stakeholders, and understanding the application’s functionality and architecture.
2. Set Up a Testing Environment: Create a dedicated testing environment that mirrors production to safely replicate issues without impacting users.
3. Automated Testing: Implement automated testing if not already in place. This includes unit tests, integration tests, and regression tests to ensure new changes do not introduce new bugs.
4. Bug Tracking: Use a bug tracking system to document and prioritize bugs. Address critical and high-priority bugs first.
5. Performance Profiling: Use profiling tools to identify performance bottlenecks. Focus on optimizing critical areas of the application.
6. Refactoring: Gradually refactor the codebase to improve readability, maintainability, and performance. This includes breaking down large classes and methods, improving code structure, and adhering to design patterns.
7. Continuous Integration: Set up a continuous integration pipeline to automate building, testing, and deploying the application.

Outcome: This structured approach ensures systematic debugging and improvement of the legacy application. It not only resolves existing bugs and performance issues but also lays a foundation for more sustainable and maintainable code in the future.

3. You are tasked with designing a scalable Java-based microservices architecture. What considerations would you take into account, and how would you ensure high availability and fault tolerance?

Answer: Considerations:

1. Service Design: Define clear boundaries for each microservice based on business capabilities. Ensure services are loosely coupled and highly cohesive.
2. API Gateway: Use an API Gateway to handle requests, routing, and provide a single entry point for clients.
3. Load Balancing: Implement load balancers to distribute incoming traffic across multiple instances of microservices to ensure scalability and high availability.
4. Service Discovery: Use a service discovery mechanism (e.g., Eureka, Consul) to enable services to find and communicate with each other dynamically.
5. Data Management: Use decentralized data management, where each microservice manages its own database. This ensures that services are independent and can scale individually.
6. Fault Tolerance: Implement fault tolerance mechanisms like circuit breakers (using Hystrix) to prevent cascading failures and retries to handle transient failures.
7. Containerization: Use Docker to containerize services for consistent deployment across environments. Orchestrate containers using Kubernetes for automated scaling, deployment, and management.
8. Logging and Monitoring: Implement centralized logging (using ELK stack) and monitoring (using Prometheus and Grafana) to track the health and performance of services.
9. Security: Ensure security at every layer, including API authentication and authorization, encrypted communication, and secure storage.

High Availability and Fault Tolerance:

• Deploy microservices across multiple availability zones and regions to ensure high availability.
• Use redundancy and failover mechanisms to handle service failures.
• Implement auto-scaling to handle varying loads and ensure services remain responsive during peak times.

Outcome: This approach ensures that the Java-based microservices architecture is scalable, highly available, and resilient to failures, providing a robust solution for handling large-scale applications.

Read more: Scenario Based Java Interview Questions [2024]

4. Explain a time when you had to work with a team to integrate Java components with a non-Java system. What challenges did you face, and how did you overcome them?

Answer: In a previous project, our team needed to integrate a Java-based backend system with a third-party CRM system that was built using .NET.

Challenges:

1. Interoperability: Ensuring seamless communication between Java and .NET components.
2. Data Formats: Handling different data formats and protocols used by both systems.
3. Authentication: Implementing a secure authentication mechanism that both systems could support.

Approach:

1. RESTful APIs: We decided to use RESTful APIs for communication, as they are language-agnostic and widely supported. We developed APIs in the Java backend and consumed them in the .NET system.
2. JSON Data Format: Standardized on using JSON as the data format for API requests and responses to ensure compatibility and ease of parsing.
3. OAuth Authentication: Implemented OAuth 2.0 for secure authentication and authorization. Both systems were configured to handle OAuth tokens for validating requests.
4. Middleware: Developed a middleware service to handle data transformation and protocol translation between the systems.

Outcome: The integration was successful, enabling seamless data exchange between the Java backend and the .NET CRM system. This enhanced the overall functionality of our application, providing users with a unified experience. The project also improved my understanding of cross-platform integration and the importance of standardizing communication protocols.

Java Interview Questions for Freshers Part 1

5. How would you handle a situation where a critical bug is found in production, and you are the only Java developer available to fix it? Describe your approach to resolving the issue under pressure.

Answer: Approach:

1. Immediate Assessment: Quickly assess the impact and severity of the bug. Determine which parts of the application are affected and the potential consequences for users.
2. Communication: Inform stakeholders (e.g., project manager, team leads, and customer support) about the issue and its potential impact. Keep them updated on the progress of the fix.
3. Reproduction: Reproduce the bug in a controlled environment to understand its cause. This helps in diagnosing the issue accurately.
4. Debugging: Use debugging tools to trace the code and identify the root cause. Check recent changes in the codebase that might be related to the bug.
5. Implementing the Fix: Develop and test a fix for the bug. Ensure that the fix resolves the issue without introducing new problems.
6. Testing: Perform thorough testing, including unit tests, integration tests, and regression tests, to ensure the fix works correctly and does not affect other parts of the application.
7. Deployment: Deploy the fix to the production environment following the standard deployment procedures to minimize downtime.
8. Monitoring: Monitor the application post-deployment to ensure the issue is resolved and the application is functioning correctly.

Outcome: This structured approach ensures that the critical bug is resolved efficiently and effectively, minimizing the impact on users and maintaining the stability of the production environment. It also demonstrates the ability to handle high-pressure situations and deliver reliable solutions under tight deadlines.

List Class in Salesforce Apex