300+ Senior Java Developer Interview Questions and Answers

Different techniques for injecting beans in application context

• Constructor Injection

• Setter Injection

• Field Injection

• Method Injection

To accumulate heap to the JVM, specify the initial and maximum heap size using -Xms and -Xmx flags respectively.

• Use -Xms flag to specify the initial heap size, e.g. -Xms512m for 512 MB.

• Use -Xmx flag to specify the maximum heap size, e.g. -Xmx1024m for 1 GB.

• Example: java -Xms512m -Xmx1024m YourClassName

equals and hashcode are methods in Java used for comparing objects and generating hash codes respectively. Object class does implement equals method.

• equals method is used to compare two objects for equality. It is overridden in most classes to provide custom comparison logic.

• hashcode method is used to generate a unique integer value for an object. It is used in hash-based collections like HashMap.

• Object class does implement equals method, but it uses reference equality (==) f...read more

Analyzing database schema and query execution to identify performance issues

• Review database schema for normalization and indexing

• Analyze query execution plans for inefficiencies

• Consider optimizing data access patterns and query structure

• Use database profiling tools to identify bottlenecks

• Implement caching mechanisms for frequently accessed data

Yes, by implementing a RESTful API with different HTTP methods for each operation.

• Implement a RESTful API with different endpoints for each operation: GET for retrieving data, POST for supplying data, and DELETE for deleting data.

• For example, GET /data to retrieve data, POST /data to supply data, and DELETE /data/{id} to delete data by ID.

• Use proper HTTP methods and status codes to handle each operation effectively.

Example of using Java 8 features and stream api to get distinct elements in a list.

• Use the distinct() method of the Stream interface to get distinct elements in a list.

• The distinct() method returns a stream consisting of the distinct elements of the original stream.

• Example: List list = Arrays.asList("apple", "banana", "apple", "orange"); list.stream().distinct().forEach(System.out::println);

• Output: apple banana orange

Common issues faced while deploying a service to AWS

• Configuration errors leading to service downtime

• Security misconfigurations exposing sensitive data

• Performance issues due to improper resource allocation

• Network connectivity problems affecting service availability

• Lack of monitoring and logging causing difficulties in troubleshooting

• Incompatibility issues with other AWS services or third-party integrations

ConcurrentHashMap is a thread-safe implementation of the Map interface in Java.

• ConcurrentHashMap allows multiple threads to read and write to the map concurrently without the need for external synchronization.

• It is part of the java.util.concurrent package and provides better performance in multi-threaded environments compared to synchronized HashMap.

• Spring framework supports the use of ConcurrentHashMap for managing beans in a concurrent environment.

• Inversion of Control (IoC)...read more

Enable debugging log in Spring Boot application

• Add 'logging.level.root=DEBUG' in application.properties file

• Use '@Slf4j' annotation in the Java class to enable logging

• Set 'logging.level.org.springframework=DEBUG' for Spring framework debugging

Monolithic SOE is a single large application while Microservices architecture breaks down the application into smaller, independent services.

• Monolithic SOE is a single, self-contained application where all components are tightly coupled.

• Microservices architecture breaks down the application into smaller, independent services that communicate through APIs.

• Monolithic SOE is easier to develop and test but can be harder to scale and maintain.

• Microservices architecture allows for ...read more

Other principles for best coding practices include DRY, KISS, YAGNI, and design patterns.

• DRY (Don't Repeat Yourself) - Avoid duplicating code by creating reusable functions or classes.

• KISS (Keep It Simple, Stupid) - Write simple and easy-to-understand code rather than overcomplicating it.

• YAGNI (You Aren't Gonna Need It) - Only implement functionality that is needed at the present moment, avoiding unnecessary features.

• Design Patterns - Follow established design patterns like S...read more

Program to print even and odd numbers using two threads in Java

• Create two threads, one for even numbers and one for odd numbers

• Use a loop to generate numbers and check if they are even or odd

• Print the numbers using the respective threads

• Use synchronization to ensure alternate printing of even and odd numbers

Write code to remove number character before hash based on count of hash

• Count the number of hashes in the input string

• Loop through the string and remove the character before the hash based on the count of hashes

• Return the modified string

Immutable classes in Java are classes whose objects cannot be modified once they are created.

• Make the class final to prevent inheritance

• Make all fields private and final

• Do not provide setter methods for fields

• Ensure that any mutable objects within the class are also immutable

Use @Primary to specify a primary bean when multiple beans of the same type are present. Use @Qualifier to specify a specific bean when multiple beans of the same type are present.

• Use @Primary to indicate the primary bean to be used when multiple beans of the same type are present in the Spring application context.

• Use @Qualifier along with @Autowired to specify a specific bean to be injected when multiple beans of the same type are present.

• Example: @Primary annotation can be ...read more

OOPs is a programming paradigm based on the concept of objects. Abstraction is the process of hiding implementation details from the user.

• OOPs stands for Object-Oriented Programming.

• Abstraction is achieved through encapsulation and inheritance.

• IOC container is a framework for implementing Inversion of Control.

• Application context is a container for holding beans in Spring Framework.

Spring Boot has various exceptions for different scenarios.

• DataAccessException - for database access errors

• HttpMessageNotReadableException - for errors in HTTP message conversion

• MethodArgumentNotValidException - for validation errors in request parameters

• NoSuchBeanDefinitionException - for errors in bean configuration

• UnauthorizedException - for authentication and authorization errors

Code becomes less maintainable and can lead to unexpected behavior.

• Violates the principle of substitutability, leading to unexpected behavior in subclasses.

• May result in code that is harder to understand and maintain.

• Can lead to bugs and errors that are difficult to trace back to the violation of the principle.

• Example: If a subclass overrides a method in a way that changes its behavior significantly, it can break the Liskov Substitution principle.

Use stream API to filter employees by salary and find average of numbers in a list.

• Filter employees with salary > 50000 and sort in descending order using stream API

• Calculate average of numbers in a list using stream API

Spring Boot simplifies the development of Spring applications by providing out-of-the-box configurations and reducing boilerplate code.

• Spring Boot provides a quick and easy way to set up a Spring application with minimal configuration.

• It includes embedded servers like Tomcat, Jetty, or Undertow, eliminating the need for deploying WAR files.

• Auto-configuration feature in Spring Boot automatically configures the application based on dependencies in the classpath.

• Spring Boot Actu...read more

Optimizing database for handling large data involves indexing, partitioning, denormalization, and using appropriate data types.

• Use indexing on frequently queried columns to improve search performance.

• Partition large tables to distribute data across multiple storage devices for faster access.

• Denormalize data by reducing the number of joins needed for queries.

• Use appropriate data types to minimize storage space and improve query performance.

Composition is a strong relationship where the child object cannot exist independently of the parent object, while aggregation is a weak relationship where the child object can exist independently.

• Composition is a 'has-a' relationship, where the child object is a part of the parent object.

• Aggregation is a 'has-a' relationship, where the child object is not a part of the parent object.

• In composition, the child object is created and destroyed along with the parent object.

• In agg...read more

To create and consume endpoints with Spring Boot microservices, use Spring Web and RESTful APIs.

• Create a Spring Boot application with Spring Web dependency

• Define RESTful APIs using @RestController and @RequestMapping annotations

• Use HTTP methods like GET, POST, PUT, DELETE to handle requests

• Consume endpoints using RestTemplate or FeignClient

• Handle exceptions using @ExceptionHandler annotation

Use @ComponentScan annotation with excludeFilters to exclude class configuration in Spring

• Use @ComponentScan annotation with excludeFilters parameter to exclude specific classes from component scanning

• Specify the classes to be excluded using TypeFilter implementations like AnnotationTypeFilter or AssignableTypeFilter

• Example: @ComponentScan(basePackages = {"com.example"}, excludeFilters = @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = {ExcludedClass.class})...read more

Use @Embeddable and @EmbeddedId annotations to create a composite key in Spring Boot

• Create a new class for the composite key and annotate it with @Embeddable

• Define the composite key fields within the new class

• In the entity class, use @EmbeddedId annotation to reference the composite key class

Questions on microservice architecture, REST vs GraphQL, Java SOLID principles, and pagination.

• Microservice architecture involves breaking down a monolithic application into smaller, independent services.

• REST is an architectural style for building web services, while GraphQL is a query language for APIs.

• Java SOLID principles are a set of design principles for writing maintainable and scalable code.

• Pagination is the process of dividing large amounts of data into smaller, more ...read more

Yes, we can create our own immutable class in Java.

• Make the class final

• Make all fields private and final

• Do not provide any setter methods

• Provide only getter methods

• If any mutable object is used, return a copy of it instead of the original object

ClassLoader loads classes at runtime. JIT compiles bytecode to native machine code.

• ClassLoader loads classes dynamically at runtime

• It searches for classes in classpath and loads them into JVM memory

• JIT (Just-In-Time) compiler compiles bytecode to native machine code for faster execution

• It optimizes frequently executed code by compiling it at runtime

• JIT is enabled by default in most JVMs

JDK is a development kit that includes JRE, while JRE is a runtime environment for executing Java programs.

• JDK stands for Java Development Kit and includes tools for developing, debugging, and monitoring Java applications.

• JRE stands for Java Runtime Environment and includes the minimum set of tools required to run Java applications.

• JDK includes JRE, so if you have JDK installed, you also have JRE.

• JDK includes a compiler, while JRE does not.

• JDK is required for developing Java ...read more

I use JPA in my project by defining entity classes, annotating them with JPA annotations, creating repositories, and using JPQL queries.

• Define entity classes with @Entity annotation

• Annotate fields with @Column, @Id, @GeneratedValue, etc.

• Create repositories by extending JpaRepository interface

• Use JPQL queries for custom database operations

Microservices communicate through REST APIs and messaging queues in our project.

• Microservices communicate with each other using REST APIs for synchronous communication.

• Messaging queues like Kafka or RabbitMQ are used for asynchronous communication between microservices.

• Service discovery tools like Eureka or Consul are used to locate and communicate with other microservices.

• Microservices may also use gRPC for communication in some cases.

Communication between microservices is typically done through APIs, messaging queues, or service meshes.

• Microservices communicate with each other through APIs, which allow them to send and receive data over the network.

• Messaging queues like RabbitMQ or Kafka can be used for asynchronous communication between microservices.

• Service meshes like Istio or Linkerd can handle communication between microservices by managing traffic, security, and monitoring.

• RESTful APIs are commonly ...read more

The first step to begin a software is to identify the problem and gather requirements.

• Identify the problem that needs to be solved

• Gather requirements from stakeholders

• Analyze and prioritize requirements

• Design a solution architecture

• Choose appropriate technologies and tools

• Develop and test the software

• Deploy and maintain the software

Garbage collection is an automatic memory management process that frees up memory occupied by objects that are no longer in use.

• Garbage collection is performed by the JVM.

• It helps prevent memory leaks and improves application performance.

• There are different types of garbage collectors such as serial, parallel, CMS, and G1.

• Garbage collection can cause pauses in the application, which can be minimized by tuning the JVM parameters.

• It is important to write efficient and optimized...read more

Time complexities of data structures vary based on operations like insertion, deletion, search, etc.

• Arrays - O(1) for access, O(n) for insertion/deletion

• Linked Lists - O(n) for access, O(1) for insertion/deletion at head/tail

• Stacks - O(1) for push/pop operations

• Queues - O(1) for enqueue/dequeue operations

• Hash Tables - O(1) for average case search/insert/delete

• Binary Trees - O(log n) for search/insert/delete in balanced trees

• Heaps - O(log n) for insert/delete, O(1) for find-mi...read more

N tier and 2 tier architecture are software architecture patterns used in designing applications.

• 2 tier architecture involves a client and a server, where the client directly communicates with the server.

• N tier architecture involves multiple layers of servers, where each layer communicates with the layer above and below it.

• 2 tier architecture is simpler and faster, but less scalable and secure than N tier architecture.

• N tier architecture is more complex and slower, but more s...read more

A linked list is a linear data structure where elements are stored in nodes with pointers to the next node. A stack is a data structure that follows Last In First Out (LIFO) principle.

• Linked list: elements are connected through pointers, can be singly or doubly linked

• Stack: operations include push (add element) and pop (remove top element)

• Example: Linked list - 1 -> 2 -> 3 -> null, Stack - [3, 2, 1]

Method referencing is a way to refer to methods without invoking them directly.

• Used to simplify lambda expressions in Java

• Commonly used in functional interfaces

• Types of method referencing include static, instance, and constructor referencing

Explaining differences between multi-threading concepts and List Iterator

• The run() method is used to execute the thread's task, while the start() method is used to start the thread.

• Fail fast means to immediately stop the program when an error occurs, while fail safe means to continue running the program and handle the error.

• List Iterator is used to traverse a list in both forward and backward directions, while Iterator is used to traverse a collection in only forward directio...read more

Hash collusion is when two different inputs produce the same hash value.

• It is a security vulnerability in hash functions.

• Attackers can exploit this vulnerability to create a collision attack.

• For example, an attacker can create a malicious file with the same hash value as a legitimate file to bypass security checks.

pom.xml is a configuration file in a Maven project that defines project dependencies, build settings, and plugins.

• Defines project dependencies and their versions

• Specifies build settings such as source directory, target directory, and compiler version

• Configures plugins for various tasks like compiling code, running tests, packaging the project

• Helps in managing project lifecycle phases like clean, compile, test, package, install, deploy

I recently developed a REST API for a banking application to handle customer transactions.

• Implemented CRUD operations for customer accounts and transactions

• Used Spring Boot framework for building the API

• Secured API endpoints using OAuth 2.0 authentication

• Utilized Swagger for API documentation

Post mapping is used to create or update data, while get mapping is used to retrieve data. Yes, data can be updated using post mapping.

• Post mapping is used to create or update data in the server, while get mapping is used to retrieve data from the server.

• Post mapping is typically used for operations that modify data, such as creating a new resource or updating an existing one.

• Get mapping is used for operations that do not modify data, such as retrieving information or fetchin...read more

I use LinkedList for insertion and deletion as it provides constant time complexity.

• LinkedList provides constant time complexity for insertion and deletion operations.

• ArrayList provides linear time complexity for these operations.

• LinkedList is preferred when frequent insertion and deletion operations are required.

• ArrayList is preferred when frequent access to elements is required.

Tree data structure is a hierarchical data structure where each node has a value and children nodes.

• Optimizing tree traversal by using efficient algorithms like depth-first search or breadth-first search.

• Balancing the tree to ensure operations like insertion and deletion are efficient.

• Using memoization to store results of expensive computations in dynamic programming.

• Implementing efficient data structures like AVL trees or Red-Black trees for better performance.

Method reference is a shorthand syntax for lambda expressions, while functional interface is an interface with a single abstract method.

• Method reference is used to refer to methods or constructors without invoking them, providing a more concise way to write lambda expressions.

• Functional interface is an interface that has only one abstract method, which can be implemented using lambda expressions or method references.

• Example: Consumer consumer = System.out::println; is a metho...read more

Transactions in microservices are managed using distributed transactions or compensating transactions.

• Distributed transactions involve multiple microservices coordinating with a transaction manager to ensure data consistency across services.

• Compensating transactions involve each microservice having a compensating action to rollback changes if a transaction fails.

• Saga pattern is commonly used in microservices to manage long-running transactions by breaking them into smaller, i...read more