Accenture Java Interview Questions and Answers

Accenture Java Interview Questions and Answers is a comprehensive guide designed to help job seekers and Java developers prepare for technical interviews at Accenture, a global professional services company. This resource covers a wide range of Java-related topics and concepts commonly assessed during Accenture interviews.

Q1. Explain the concepts of named queries and native queries in the context of Spring Data JPA.

Ans: In Spring Data JPA, named queries and native queries provide two different approaches for defining queries to interact with a database. Let's explore each of them:

1. Named Queries:

Named queries in Spring Data JPA involve defining queries by giving them a unique name in the repository interface. These queries are then executed by calling the corresponding method in the repository.

Define a Named Query in the Entity Class:

@Entity

public class YourEntity {

    // Other entity fields and annotations...

    @NamedQuery(name = "YourEntity.findByName", query = "SELECT e FROM YourEntity e WHERE e.name = ?1")

    private String name;

    // Getter and setter methods...

}

Use the Named Query in Repository Interface:

public interface YourEntityRepository extends JpaRepository<YourEntity, Long> {

    List<YourEntity> findByName(String name);

}

Invoke the Named Query in Your Service or Controller:

@Service

public class YourEntityService {

    @Autowired

    private YourEntityRepository repository;

    public List<YourEntity> getEntitiesByName(String name) {

        return repository.findByName(name);

    }

}

2. Native Queries:

Native queries allow you to use native SQL queries directly. This is useful when you need to execute database-specific queries that cannot be expressed with JPQL.

Use Native Query in Repository Interface:

public interface YourEntityRepository extends JpaRepository<YourEntity, Long> {

    @Query(value = "SELECT * FROM your_entity_table WHERE name = ?1", nativeQuery = true)

    List<YourEntity> findByName(String name);

}

Invoke the Native Query in Your Service or Controller:

@Service

public class YourEntityService {

    @Autowired

    private YourEntityRepository repository;

    public List<YourEntity> getEntitiesByName(String name) {

        return repository.findByName(name);

    }

}

Important Points:

• Named queries are written in JPQL (Java Persistence Query Language).
• Native queries use the native SQL syntax of your database.
• Named queries are generally more portable across different database systems.
• Native queries may be necessary for complex queries or database-specific functionality.

Choose between named queries and native queries based on your specific use case and requirements.

 

Q2. What are Spring Boot actuators?

Ans: Spring Boot Actuators are a set of production-ready features that help monitor and manage Spring Boot applications. These features expose various operational information about the application, making it easier to understand its behavior and health. Actuators are particularly useful in production environments for monitoring, troubleshooting, and managing applications.

Key features of Spring Boot Actuators include:

Health Endpoint:

• The /actuator/health endpoint provides information about the health of the application. It indicates whether the application is running normally or if there are any issues.

Info Endpoint:

• The /actuator/info endpoint displays arbitrary application information. Developers can customize this endpoint to provide additional metadata about the application.

Metrics Endpoint:

• The /actuator/metrics endpoint exposes a wide range of metrics about the application's internals, such as memory usage, garbage collection, thread usage, and more.

Environment Endpoint:

• The /actuator/env endpoint provides information about the application's environment properties and configuration.

Application Endpoint:

• The /actuator/application endpoint exposes details about the application's configuration properties.

Logfile Endpoint:

• The /actuator/logfile endpoint gives access to the application's log file, allowing for easy inspection of logs.

Shutdown Endpoint:

• The /actuator/shutdown endpoint allows for a graceful shutdown of the application. It can be secured with proper authentication to prevent unauthorized shutdown requests.

Custom Endpoints:

• Developers can create custom endpoints by implementing their own actuators, extending the Actuator framework.

To enable Spring Boot Actuators, you need to include the spring-boot-starter-actuator dependency in your project's dependencies. Once enabled, you can access the actuator endpoints over HTTP.

Example of enabling Actuators in pom.xml:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

Spring Boot Actuators play a crucial role in providing insights into the runtime behavior of applications, enhancing the observability and management capabilities of Spring Boot applications in production environments

 

Q3. Describe a difference between an Abstract class and a class? Give an example where you might use an abstract class.

Ans: An abstract class is a class that cannot be instantiated on its own and may contain abstract methods (methods without a body) that must be implemented by its subclasses. In contrast, a regular class (or concrete class) can be instantiated, and all its methods have a concrete implementation.

Example:

Suppose you are designing a drawing application, and you want to represent various shapes like circles, rectangles, and triangles. You could use an abstract class to define a common interface for all shapes while providing a default implementation for certain shared behaviors.

// Abstract class representing a Shape

abstract class Shape {

    // Abstract method for calculating area

    public abstract double calculateArea();

    // Concrete method for displaying shape details

    public void displayDetails() {

        System.out.println("This is a shape.");

    }

}


// Concrete subclass representing a Circle

class Circle extends Shape {

    private double radius;

    public Circle(double radius) {

        this.radius = radius;

    }


    @Override

    public double calculateArea() {

        return Math.PI * radius * radius;

    }

}


// Concrete subclass representing a Rectangle

class Rectangle extends Shape {

    private double length;

    private double width;

    public Rectangle(double length, double width) {

        this.length = length;

        this.width = width;

    }

    @Override

    public double calculateArea() {

        return length * width;

    }

}

In this example, Shape is an abstract class defining the common interface for all shapes. It declares an abstract method calculateArea(), which must be implemented by its concrete subclasses (Circle and Rectangle). The Shape class also provides a concrete method displayDetails(), that can be shared by all subclasses.

Using an abstract class in this scenario allows you to define a common structure and behavior for various shapes while ensuring that each specific shape must implement its own unique area calculation method. This promotes code reuse and provides a clear structure for the hierarchy of shapes in your application.

 

Q4. What is a HashMap and what would you use it for?

Ans: A HashMap is a data structure in Java that implements the Map interface. It provides a collection of key-value pairs, where each key must be unique. It is part of the Java Collections Framework and is based on the hash table data structure.

Key Characteristics of HashMap:

Key-Value Pairs:

• Each element in a HashMap is a key-value pair.
• The key is used to access the associated value.

Unique Keys:

• Keys must be unique within a HashMap.
• Attempting to add a duplicate key will overwrite the existing value.

Ordering:

• The order of elements in a HashMap is not guaranteed.
• If you need ordering, consider using LinkedHashMap.

Null Values:

• Both keys and values in a HashMap can be null.

Common Methods of HashMap:

• put(key, value): Adds a key-value pair to the HashMap.
• get(key): Retrieves the value associated with a given key.
• containsKey(key): Checks if a key is present in the HashMap.
• remove(key): Removes the key-value pair associated with the given key.
• size(): Returns the number of key-value pairs in the HashMap.
• isEmpty(): Checks if the HashMap is empty.

Use Cases:

Fast Retrieval:

• Use HashMap when you need fast retrieval of values based on a unique key.

Associating Data:

• Use HashMap to associate additional data with objects without modifying their classes.

Caching:

• HashMaps can be used for caching. The key can be a request, and the value can be the corresponding response, helping to avoid redundant computations.

Storing Configuration:

• Use HashMap to store configuration parameters, where each parameter has a unique identifier.

Frequency Counting:

• Count the frequency of elements in a dataset using HashMap, where the elements are keys, and the counts are values.

Example Usage:

import java.util.HashMap;

import java.util.Map;

public class HashMapExample {

    public static void main(String[] args) {

        // Creating a HashMap

        Map<String, Integer> populationMap = new HashMap<>();

        // Adding key-value pairs

        populationMap.put("USA", 331);

        populationMap.put("India", 1380);

        populationMap.put("China", 1444);

        // Retrieving values

        System.out.println("Population of India: " + populationMap.get("India"));

        // Checking if a key exists

        if (populationMap.containsKey("USA")) {

            System.out.println("USA is in the map.");

        }

        // Iterating through the entries

        for (Map.Entry<String, Integer> entry : populationMap.entrySet()) {

            System.out.println(entry.getKey() + ": " + entry.getValue());

        }

    }

}

In this example, a HashMap is used to store the population of countries. Keys are country names, and values are population counts. The HashMap provides efficient retrieval based on country names.

 

Q5. What is the Singleton design pattern, and what problem does it aim to solve?

Ans: The Singleton design pattern is a creational pattern that ensures a class has only one instance and provides a global point of access to that instance. This pattern involves a single class responsible for creating, maintaining, and providing access to its sole instance.

Key Characteristics of the Singleton Pattern:

Single Instance:

• Ensures that a class has only one instance by providing a global point of access to it.

Lazy Initialization:

• The instance is created only when it is first requested, rather than at the time of class loading.

Global Access Point:

• Provides a global point of access to the single instance, allowing other objects to interact with it.

Private Constructor:

• The class typically has a private constructor to prevent instantiation by other classes.

Static Method or Variable:

• Often includes a static method (e.g., getInstance()) to access the instance.

Aim and Problem Solving:

The Singleton pattern aims to solve several problems related to object creation, access, and resource management:

Controlled Access:

• Ensures that a single instance is responsible for controlling access to a resource, such as a database connection or a configuration manager.

Resource Sharing:

• Facilitates the sharing of a single instance across multiple parts of an application, promoting efficient resource utilization.

Global Configuration:

• Provides a single point for managing global configuration settings, ensuring consistency throughout the application.

Reduced Memory Usage:

• Reduces memory usage by having only one instance of a class, especially when the class involves heavy initialization or resource allocation.

Avoids Duplicate Instances:

• Prevents the accidental creation of duplicate instances that could lead to inconsistencies or conflicts in the application.

Lazy Initialization:

• Supports lazy initialization, creating the instance only when it is needed, which can be beneficial for performance.

Global State Management:

• Manages global state within an application, serving as a centralized point for coordinating actions and maintaining state.

Example Scenario:

Consider a logging service in a large application. Using the Singleton pattern ensures that there is a single point of access to the logging service throughout the application. This prevents the unnecessary creation of multiple logging instances, maintains consistent logging behavior, and allows for centralized configuration.

In summary, the Singleton design pattern provides a solution for situations where having a single, globally accessible instance of a class is crucial for maintaining control, managing resources efficiently, and ensuring consistency across an application.

 

Q6. What are 4 access modifiers in Java?

Ans: In Java, there are four access modifiers that control the visibility of classes, methods, and variables within a program. These access modifiers determine which other classes can access a particular class, method, or variable. The four access modifiers in Java are:

Public (public):

• Members declared as public are accessible from any other class.
• There is no restriction on accessing public members.

public class MyClass {

    public int publicVariable;

    public void publicMethod() {

        // Code

    }

}

Private (private):

• Members declared as private are only accessible within the same class.
• They cannot be accessed directly from outside the class.

public class MyClass {

    private int privateVariable;

    private void privateMethod() {

        // Code

    }

}

Protected (protected):

• Members declared as protected are accessible within the same package and by subclasses, even if they are in a different package.
• They are not accessible by unrelated classes in a different package.

package mypackage;

public class MyBaseClass {

    protected int protectedVariable;

    protected void protectedMethod() {

        // Code

    }

}

package mypackage;

public class MyDerivedClass extends MyBaseClass {

    // Can access protectedVariable and protectedMethod here

}

Default (Package-Private, no modifier):

• If no access modifier is specified, the default access level is package-private.
• Members with default access are accessible within the same package but not from outside the package.

package mypackage;

class MyDefaultClass {

    int defaultVariable; // Default access

    void defaultMethod() {

        // Code

    }

}

package mypackage;

public class AnotherClassInSamePackage {

    // Can access defaultVariable and defaultMethod here

}

Remember that the access modifiers apply to classes, methods, and variables at the class level. Local variables within methods do not have access modifiers. Access control is an essential concept in object-oriented programming to encapsulate and protect the internal state of classes.

 

Q7. What are pillars of OOP?

Ans: The four pillars of Object-Oriented Programming (OOP) in Java are:

Encapsulation:

• Definition: Encapsulation is the bundling of data (attributes) and methods (functions) that operate on the data into a single unit known as a class.
• Purpose: It hides the internal details of an object and restricts access to some of its components. It helps in achieving data hiding and abstraction.

public class MyClass {

    private int myVariable; // Encapsulation - private variable  

    public void setMyVariable(int value) {

        myVariable = value;

    }

    public int getMyVariable() {

        return myVariable;

    }

}

Inheritance:

• Definition: Inheritance is the mechanism by which a new class (subclass/derived class) can inherit properties and behaviors from an existing class (superclass/base class).
• Purpose: It promotes code reusability and establishes a relationship between classes.

// Superclass

public class Animal {

    public void eat() {

        System.out.println("Animal is eating.");

    }

}


// Subclass inheriting from Animal

public class Dog extends Animal {

    // Can access the eat() method from Animal

}

Polymorphism:

• Definition: Polymorphism allows objects of different types to be treated as objects of a common type. It can be achieved through method overloading and method overriding.
• Purpose: It simplifies code and improves readability. It allows a single interface to represent different types of actions.

// Method Overloading

public class MathOperations {

    public int add(int a, int b) {

        return a + b;

    }

    public double add(double a, double b) {

        return a + b;

    }

}

// Method Overriding

public class Animal {

    public void makeSound() {

        System.out.println("Some generic sound");

    }

}

public class Dog extends Animal {

    @Override

    public void makeSound() {

        System.out.println("Bark");

    }

}

Abstraction:

• Definition: Abstraction is the process of hiding the complex implementation details and showing only the necessary features of an object.
• Purpose: It allows you to focus on the essential aspects of an object while ignoring unnecessary details.

// Abstract class with abstract method

public abstract class Shape {

    abstract void draw(); // Abstract method

}

// Concrete class implementing the abstract method

public class Circle extends Shape {

    @Override

    void draw() {

        System.out.println("Drawing a circle");

    }

}

These four pillars form the foundation of OOP principles and guide developers in designing modular, reusable, and maintainable code.

 

Q8. What are Java versions?

Ans: Java has undergone significant updates and releases since its inception. Here is a list of the major Java versions, along with some key features introduced in each version:

JDK 1.0 (January 23, 1996):

• initial release of Java with the core features of the language.

JDK 1.1 (February 19, 1997):

• introduced the Swing graphical API.
• added the Collections framework.
• enhanced networking capabilities.

J2SE 1.2 (December 8, 1998):

• renamed to Java 2 Platform, Standard Edition (J2SE)
• introduced the Collections framework.
• added the strictfp keyword for cross-platform precision.

J2SE 1.3 (May 8, 2000):

• improved performance with HotSpot JVM
• added the Java Naming and Directory Interface (JNDI).

J2SE 1.4 (February 6, 2002):

• added the assert keyword.
• introduced the java.util.logging package.
• enhanced the Collections framework with new classes and interfaces.

J2SE 5.0 (September 30, 2004):

• renamed to Java SE 5.
• introduced generics with the <T> syntax.
• added metadata annotations.
• introduced the enhanced for loop.
• introduced the enum keyword.

Java SE 6 (December 11, 2006):

• improved performance with updates to the HotSpot JVM.
• introduced scripting support with the inclusion of the Java Compiler API.
• added support for web services.

Java SE 7 (July 28, 2011):

• introduced the try-with-resources statement.
• added the diamond operator (<>) for type inference.
• introduced the Fork/Join framework for parallel programming.
• enhanced exception handling with multi-catch and improved type inference

Java SE 8 (March 18, 2014):

• introduced lambdas and the Streams API for functional programming.
• added the java.time package for modern date and time handling.
• introduced the java.util.Optional class for better handling of nullable values.
• included the Nashorn JavaScript engine.

Java SE 9 (September 21, 2017):

• introduced the module system (Project Jigsaw).
• added the jshell tool for interactive Java programming.
• introduced the Flow API for reactive programming.
• modularized the JDK.

Java SE 10 (March 20, 2018):

• introduced local-variable type inference with the var keyword.
• added the List.copyOf() and Set.copyOf() methods.

Java SE 11 (September 25, 2018):

• long-term support (LTS) release
• removed several deprecated features.
• introduced the var syntax for lambda parameters.
• introduced the String::isBlank method.

Java SE 12 to Java SE 17 (2019–2021):

• introduced features like switch expressions, text blocks, records, pattern matching, and more.
• Regular features are released every six months.

Keep in mind that the Java versioning and release strategy changed with Java SE 9, moving to a time-driven model with regular feature releases every six months. This allows developers to access new features and improvements more frequently.

 

Q9. Explain String Buffer and String Builder.

Ans: Both StringBuffer and StringBuilder are classes in Java that represent mutable sequences of characters. They are designed for situations where the contents of a string might need to be changed frequently without creating a new object for each modification. However, there is a key difference between them related to thread safety:

StringBuffer:

• Thread-Safe: StringBuffer is synchronized, making it thread-safe.
• Performance: Due to synchronization, it may have a performance overhead in a multi-threaded environment.
• Use Cases: Use StringBuffer when you need a mutable sequence of characters and thread safety is a concern.

StringBuilder:

• Not Thread-Safe: StringBuilder is not synchronized, making it faster in a single-threaded environment.
• Performance: It generally has better performance than StringBuffer.
• Use Cases: Use StringBuilder when you need a mutable sequence of characters and you are working in a single-threaded environment or handling synchronization manually.

Common Methods: Both StringBuffer and StringBuilder classes provide similar methods for modifying the content of the sequence, such as append(), insert(), delete(), reverse(), etc.

Choosing Between StringBuffer and StringBuilder:

• If you are working in a single-threaded environment or handling synchronization manually, prefer to use StringBuilder for better performance.
• If you are working in a multi-threaded environment and thread safety is a concern, use StringBuffer.

In general, StringBuilder is more commonly used in modern applications, especially when thread safety is not a primary concern. The performance difference might not be noticeable in many scenarios, and the simplicity and speed of StringBuilder make it a preferred choice in many situations.

 

Q10. Explain List and Set Interface.

Ans: In Java, List and Set are both interfaces that belong to the Java Collections Framework. They represent collections of objects, but there are fundamental differences in their characteristics and use cases.

List Interface:

• Ordered Collection:
  • A List is an ordered collection, meaning that the elements are stored in the order in which they are inserted.
• Duplicates Allowed:
  • A List allows duplicate elements, meaning the same element can be added multiple times.
• Common Implementations:
  • Common implementations of the List interface include ArrayList, LinkedList, and Vector.

Example of using a List:

List<String> myList = new ArrayList<>();

myList.add("Apple");

myList.add("Banana");

myList.add("Orange");

Set Interface:

• Unordered Collection:
  • A Set is an unordered collection, meaning that it does not guarantee any specific order of elements.
• No Duplicates Allowed:
  • A Set does not allow duplicate elements. If you try to add the same element more than once, it won't be added.
• Common Implementations:
  • Common implementations of the Set interface include HashSet, LinkedHashSet, and TreeSet.

Example of using a Set: 

Set<String> mySet = new HashSet<>();

mySet.add("Apple");

mySet.add("Banana");

mySet.add("Orange");

Choosing Between List and Set:

• Use a List when you need to maintain the order of elements, and duplicates are allowed.
• Use a Set when order is not important, and you want to ensure that each element is unique.

Example of Using Both:

List<String> myList = new ArrayList<>();

myList.add("Apple");

myList.add("Banana");

myList.add("Apple"); // Duplicate allowed in List



Set<String> mySet = new HashSet<>();

mySet.add("Apple");

mySet.add("Banana");

mySet.add("Apple"); // Duplicate not allowed in Set

In many cases, the choice between List and Set depends on the specific requirements of your application and the characteristics of the data you are working with.