Core java set 1

1. What is the difference between HashMap and ConcurrentHashMap?

●​ HashMap:
○​ Not thread-safe.
○​ Allows one null key and multiple null values.
○​ Fast performance in single-threaded environments.
●​ ConcurrentHashMap:
○​ Thread-safe and designed for concurrent access.
○​ Does not allow null keys or values.
○​ Uses segment-level locking or CAS (Compare and Swap) operations for
better concurrency.

2. Explain the Java Memory Model (JMM).

●​ The Java Memory Model defines how threads interact through memory and
ensures visibility of changes across threads.
●​ Key concepts:
Heap: Shared memory area where objects are stored.

Stack: Each thread has its own stack for local variables and method calls.

Visibility: Ensures changes made by one thread are visible to others (using
volatile, synchronized, etc.).

Happens-Before Relationship: Guarantees the order of operations

between threads.

3. What is the difference between wait() and sleep()?

●​ wait():
○​ Part of the Object class.
○​ Releases the lock on the object and waits for another thread to call
notify() or notifyAll().
○​ Used in synchronization contexts.
●​ sleep():
○​ Part of the Thread class.
○​ Pauses the current thread for a specified time without releasing any locks.
○​ Used for time-based pauses.

4. How does the volatile keyword work in Java?

The volatile keyword ensures visibility of changes to variables across threads.

 It prevents thread-caching of the variable and ensures reads/writes are done
directly from/to main memory.
However, it does not provide atomicity (e.g., for compound operations like
increment).

5. What is the difference between ArrayList and LinkedList?

●​ ArrayList:
○​ Backed by a dynamic array.
○​ Fast random access (O(1)).
○​ Slower insertions/deletions in the middle (O(n)).
●​ LinkedList:
○​ Backed by a doubly-linked list.
○​ Slower random access (O(n)).
○​ Faster insertions/deletions in the middle (O(1)).

6. What is the purpose of the transient keyword?

●​ The transient keyword is used to indicate that a field should not be serialized
during object serialization.
●​ Example: Sensitive data like passwords can be marked as transient to avoid
being saved in serialized form.

7. Explain the difference between Comparator and Comparable.

●​ Comparable:
○​ Interface used to define the natural ordering of objects.
○​ Implemented by the class itself (compareTo() method).
●​ Comparator:
○​ Interface used to define custom ordering.
○​ Implemented in a separate class (compare() method).
○​ Allows multiple sorting strategies.

8. What is the difference between String, StringBuilder, and

StringBuffer?

●​ String:
○​ Immutable and thread-safe.
○​ Every modification creates a new object.
●​ StringBuilder:
 ○​ Mutable and not thread-safe.
○​ Faster for single-threaded operations.
●​ StringBuffer:
○​ Mutable and thread-safe (synchronized methods).
○​ Slower than StringBuilder due to synchronization.

9. What is the diamond problem in Java, and how does Java handle it?

●​ The diamond problem occurs in multiple inheritance when a class inherits from
two classes that have a common ancestor.
●​ Java handles it by not supporting multiple inheritance for classes. However, it
allows multiple inheritance for interfaces (default methods) and ensures clarity
by requiring the implementing class to override ambiguous methods.

10. What is the difference between fail-fast and fail-safe iterators?

●​ Fail-Fast:
○​ Throws ConcurrentModificationException if the collection is modified
while iterating.
○​ Example: ArrayList, HashMap.
●​ Fail-Safe:
○​ Does not throw exceptions and works on a clone of the collection.
○​ Example: ConcurrentHashMap, CopyOnWriteArrayList.

11. What is the purpose of the finally block in exception handling?

●​ The finally block is used to execute code that must run regardless of whether
an exception is thrown or not.
●​ It is often used for resource cleanup (e.g., closing files, database connections).

12. What is the difference between Checked and Unchecked exceptions?

●​ Checked Exceptions:
○​ Checked at compile-time.
○​ Must be handled using try-catch or declared in the method signature
(throws).
○​ Example: IOException, SQLException.
●​ Unchecked Exceptions:
○​ Checked at runtime.
○​ Do not need to be explicitly handled.
○​ Example: NullPointerException, ArithmeticException.
13. What is the try-with-resources statement?

●​ Introduced in Java 7, it ensures that resources (e.g., streams, connections) are

automatically closed after use.
●​ Resources must implement the AutoCloseable interface.
●​ Example:
●​ java
●​ Copy
try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
// Use the resource
} catch (IOException e) {
e.printStackTrace();
●​ }

14. What is the difference between == and .equals()?

●​ ==:
○​ Compares object references (memory addresses).
○​ Used for primitive types and object references.
●​ .equals():
○​ Compares the actual content of objects.
○​ Must be overridden in custom classes for meaningful comparison.

15. What are Java 8 features you have worked with?

●​ Lambda Expressions: Concise way to represent anonymous functions.

●​ Stream API: Functional-style operations on collections.
●​ Default Methods: Allow adding new methods to interfaces without breaking
existing implementations.
●​ Optional: Wrapper class to handle null values more gracefully.
●​ Date and Time API: Introduced LocalDate, LocalTime, etc., for better date-time
handling.

16. What is the difference between parallelStream() and stream()?

●​ stream():
○​ Processes elements sequentially.
●​ parallelStream():
○​ Processes elements in parallel using multiple threads.
○​ Useful for large datasets but requires thread-safe operations
 17. What is the purpose of the spliterator in Java?

●​ Spliterator (Splittable Iterator) is used for traversing and partitioning elements

of a source (e.g., collections).
●​ It is designed for parallel processing and is used internally by the Stream API.

18. What is the difference between ClassNotFoundException and

NoClassDefFoundError?

●​ ClassNotFoundException:
○​ Occurs when the classloader cannot find the class at runtime (e.g., during
Class.forName()).
●​ NoClassDefFoundError:
○​ Occurs when the JVM cannot find the class definition at runtime, even
though it was present during compile-time.

20. How does garbage collection work in Java?

●​ Garbage Collection (GC) automatically reclaims memory by removing objects

that are no longer reachable.
●​ Key components:
○​ Young Generation: Where new objects are allocated (Eden, Survivor
spaces).
○​ Old Generation: Where long-lived objects are stored.
○​ Garbage Collectors: Serial, Parallel, CMS, G1, ZGC, etc.

5. Explain the concept of Java's exception handling mechanism.

Answer: Java uses a try-catch-finally mechanism to handle exceptions.

●​ try: Contains the code that might throw an exception.

●​ catch: Contains the code to handle the exception. Multiple catch blocks can be
used for different types of exceptions.
●​ finally: This block is always executed, whether an exception is thrown or not, and
is typically used to release resources (like closing files or database connections).

There are two types of exceptions:

●​ Checked exceptions: These are exceptions that must be declared in the method
signature using the throws keyword or handled within the method (e.g.,
IOException).
 ●​ Unchecked exceptions: These are runtime exceptions (e.g.,
NullPointerException, ArrayIndexOutOfBoundsException) and don't
need to be explicitly handled

6. What is the purpose of the final keyword in Java?

Answer:

●​ final class: A class declared as final cannot be subclassed.

●​ final method: A method declared as final cannot be overridden by subclasses.
●​ final variable: A variable declared as final cannot be reassigned after
initialization.

7. Explain the difference between synchronized and volatile in Java.

Answer:

●​ synchronized: It is used to ensure that only one thread can access a particular
block of code or method at a time, ensuring thread safety. It locks an object to
prevent simultaneous access.
●​ volatile: It is used to ensure that the value of a variable is always read from the
main memory, and not from the thread's local cache. It ensures visibility of
changes to a variable across different threads.

8. What is the difference between HashMap and TreeMap?

Answer:

●​ HashMap: It stores key-value pairs in a hash table. It does not guarantee any
specific order of elements. It allows null values and null keys.
●​ TreeMap: It stores key-value pairs in a red-black tree and sorts the keys
according to their natural order (or by a custom comparator). It does not allow
null keys but allows null values.

10. What are Lambda expressions in Java?

Answer: Lambda expressions, introduced in Java 8, provide a clear and concise

way to represent a method or function as an argument to a method. They are
primarily used to define the behavior of functional interfaces (interfaces with a
single abstract method).
13. What are Java Streams?

Answer: Java Streams (introduced in Java 8) are part of the java.util.stream

package and allow functional-style operations on sequences of elements (e.g.,
collections). Streams can be used for operations like filtering, mapping, sorting,
and reducing data, making them very useful for handling large datasets in a
concise and readable manner.

Example:

java

Copy

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

numbers.stream().filter(n -> n % 2 ==
0).forEach(System.out::println); // Prints even number

14. What is the difference between throw and throws in Java?

Answer:

throw is used to explicitly throw an exception within a

method.​
java​
Copy​
throw new Exception("Error occurred");

●​

throws is used in the method signature to declare that the

method may throw exceptions.​
java​
Copy​
public void myMethod() throws IOException {

// Method implementation

●​ }
Java 8
2. What is a lambda expression?

●​ A lambda expression is an anonymous function that can be passed around as a

method argument or stored in a variable.
●​ Syntax: (parameters) -> expression or (parameters) -> { statements; }
●​ Example:
●​ java
●​ Copy
List<String> list = Arrays.asList("a", "b", "c");
●​ list.forEach(s -> System.out.println(s));

3. What is a functional interface?

●​ A functional interface is an interface with exactly one abstract method.

●​ Examples: Runnable, Comparator, Predicate, Consumer, Supplier.
●​ Java 8 introduced the @FunctionalInterface annotation to enforce this rule at
compile-time.

4. What is the difference between Predicate, Consumer, and Supplier?

●​ Predicate:
○​ Represents a boolean-valued function.
○​ Method: boolean test(T t).
○​ Example: Filtering a list.
●​ Predicate<Integer> isEven = n -> n % 2 == 0;
●​ Consumer:
○​ Represents an operation that accepts a single input and returns no result.
○​ Method: void accept(T t).
○​ Example: Printing elements.
○​ java
○​ Copy
○​ Consumer<String> print = s -> System.out.println(s);
●​ Supplier:
○​ Represents a supplier of results.
○​ Method: T get().
○​ Example: Generating random numbers.
○​ java
○​ Copy
○​ Supplier<Double> random = Math::random;
5. What is the Stream API?

●​ The Stream API is used to process collections of objects in a functional style.

●​ Key features:
○​ Lazy Evaluation: Operations are performed only when needed.
○​ Pipeline: Multiple operations can be chained together.
○​ Parallel Processing: Supports parallel execution using parallelStream().

6. What is the difference between map() and flatMap()?

●​ map():
○​ Transforms each element of a stream into another object.
○​ Example:
○​ java
○​ Copy
List<String> names = Arrays.asList("John", "Doe");
List<Integer> nameLengths = names.stream()
.map(String::length)
○​ .collect(Collectors.toList());
●​ flatMap():
○​ Flattens nested structures (e.g., List<List<T>> to List<T>).
○​ Example:
○​ List<List<String>> nestedList = Arrays.asList(
○​ Arrays.asList("a", "b"),
○​ Arrays.asList("c", "d")
○​ );
○​ List<String> flatList = nestedList.stream()
○​ .flatMap(List::stream)
○​ .collect(Collectors.toList());

7. What is Optional in Java 8?

●​ Optional is a container class that may or may not contain a non-null value.
●​ It is used to avoid NullPointerException and make the code more readable.
●​ Example:
Optional<String> optional = Optional.ofNullable(getName());
String name = optional.orElse("Default Name");

8. What are default methods in interfaces?

 ●​ Default methods allow adding new methods to interfaces without breaking
existing implementations.
●​ They are defined using the default keyword.
●​ Example:
●​ interface Vehicle {
●​ void start();
●​ default void stop() {
●​ System.out.println("Vehicle stopped");
●​ }
●​ }
9. What are method references?
●​ Method references are shorthand notations for lambda expressions calling
existing methods.
●​ Types:
○​ Static method: ClassName::staticMethod
○​ Instance method: instance::method
○​ Constructor: ClassName::new
●​ Example:
●​ List<String> names = Arrays.asList("John", "Doe");
●​ names.forEach(System.out::println);

11. How does parallelStream() work?

●​ parallelStream() splits the stream into multiple substreams and processes

them in parallel using multiple threads.
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.parallelStream()
.mapToInt(n -> n)
.sum();

12. What is the new Date and Time API in Java 8?

●​ Java 8 introduced the java.time package to address the shortcomings of the

old Date and Calendar classes.
●​ Key classes:
○​ LocalDate: Represents a date (year, month, day).
○​ LocalTime: Represents a time (hour, minute, second).
○​ LocalDateTime: Combines date and time.
○​ ZonedDateTime: Represents a date-time with a time zone.
15. What is the difference between limit() and skip() in Streams?

●​ limit(n):
○​ Returns a stream with the first n elements.
●​ skip(n):
○​ Returns a stream after skipping the first n elements.

16. What is the purpose of peek() in Streams?

●​ peek() is used for debugging or performing intermediate operations without

modifying the stream.
●​ Example:
List<String> names = Arrays.asList("John", "Doe");

List<String> result = names.stream()

.peek(System.out::println)

.collect(Collectors.toList());

6. What is the difference between map() and flatMap() in Streams?

Answer:

●​ map(): Transforms each element of the stream into another object, returning a stream of transformed
elements.
●​ flatMap(): Similar to map(), but it flattens the result into a single stream. This is useful when the
transformation results in nested collections.

List<List<String>> namesList = Arrays.asList(

Arrays.asList("Alice", "Bob"),

Arrays.asList("Charlie", "David")

);

// Using map

namesList.stream()

.map(names -> names.stream())

.forEach(System.out::println); // Outputs nested streams

// Using flatMap
namesList.stream()

.flatMap(names -> names.stream())

.forEach(System.out::println); // Outputs all names in a single stream

spring framework
1. What is the Spring Framework, and what are its key features?

●​ Spring Framework is an open-source application framework for Java that

provides comprehensive infrastructure support for developing Java applications.
●​ Key features:
○​ Dependency Injection (DI): Promotes loose coupling.
○​ Aspect-Oriented Programming (AOP): Separates cross-cutting concerns.
○​ Spring MVC: For building web applications.
○​ Transaction Management: Supports declarative and programmatic
transaction management.
○​ Spring Boot: Simplifies Spring application development.
○​ Spring Security: Provides authentication and authorization.
○​ Spring Data: Simplifies database access.

2. What is Dependency Injection (DI), and how does Spring implement it?

●​ Dependency Injection is a design pattern where objects are provided with their
dependencies instead of creating them internally.
●​ Spring implements DI using:
○​ XML Configuration: Defining beans in an XML file.
○​ Annotation-Based Configuration: Using annotations like @Autowired,
@Component, @Service, etc.
○​ Java-Based Configuration: Using @Configuration and @Bean annotations.

3. What is the difference between @Component, @Service, @Repository, and

@Controller?

●​ @Component: A generic stereotype for any Spring-managed bean.

●​ @Service: Indicates that the class is a service layer component (business logic).
●​ @Repository: Indicates that the class is a DAO (Data Access Object) and
provides exception translation for database operations.
●​ @Controller: Indicates that the class is a Spring MVC controller.

4. What is the difference between @Autowired and @Resource?

●​ @Autowired:
○​ Part of the Spring framework.
○​ Injects by type by default.
○​ Can be used with @Qualifier to specify the bean name.
 ●​ @Resource:
○​ Part of Java EE (JSR-250).
○​ Injects by name by default.
○​ Can fall back to type-based injection if no name is specified.

5. What is the Spring Bean lifecycle?

●​ The Spring Bean lifecycle consists of the following phases:

1.​ Instantiation: The bean is created using its constructor or factory method.
2.​ Population of Properties: Dependencies are injected using setter methods
or fields.
3.​ Bean Post-Processing: Custom logic can be applied using
BeanPostProcessor.
4.​ Initialization: The @PostConstruct method or InitializingBean's
afterPropertiesSet() method is called.
5.​ Usage: The bean is ready for use.
6.​ Destruction: The @PreDestroy method or DisposableBean's destroy()
method is called before the bean is removed.

6. What is the difference between BeanFactory and ApplicationContext?

●​ BeanFactory:
○​ Basic container for bean management.
○​ Lazy-loads beans.
○​ Does not support annotation-based configuration.
●​ ApplicationContext:
○​ Extends BeanFactory with additional features.
○​ Eagerly loads beans by default.
○​ Supports annotation-based configuration, AOP, and internationalization.

10. What is the difference between @Controller and @RestController?

●​ @Controller:
○​ Used in Spring MVC to handle web requests.
○​ Returns a view name or ModelAndView.
●​ @RestController:
○​ A combination of @Controller and @ResponseBody.
○​ Used in RESTful web services to return JSON/XML responses directly.

11. What is Spring Boot, and how does it simplify Spring development?
 ●​ Spring Boot is an extension of the Spring framework that simplifies the
development of production-ready applications.
●​ Key features:
○​ Auto-configuration: Automatically configures beans based on
dependencies.
○​ Embedded servers: Includes Tomcat, Jetty, etc.
○​ Starter dependencies: Simplifies dependency management.
○​ Actuator: Provides production-ready features like health checks and
metrics.

12. What is the difference between @SpringBootApplication and

@EnableAutoConfiguration?

●​ @SpringBootApplication:
○​ A combination of @Configuration, @EnableAutoConfiguration, and
@ComponentScan.
○​ Used to mark the main class of a Spring Boot application.
●​ @EnableAutoConfiguration:
○​ Enables Spring Boot's auto-configuration mechanism.

13. What is Spring Security, and how does it work?

●​ Spring Security is a framework for securing Spring-based applications.

●​ Key features:
○​ Authentication: Verifies user identity.
○​ Authorization: Controls access to resources.
○​ CSRF protection: Prevents Cross-Site Request Forgery attacks.
○​ Session management: Manages user sessions.

14. What is the difference between Authentication and Authorization?

●​ Authentication: Verifies the identity of a user (e.g., username/password).

●​ Authorization: Determines what a user is allowed to do (e.g., roles and
permissions).

15. What is Spring Data, and how does it simplify database access?

●​ Spring Data is a project that simplifies database access by providing a

consistent API for different data sources (e.g., JPA, MongoDB, Redis).
●​ Key features:
 ○​ Repository abstraction: Reduces boilerplate code.
○​ Query methods: Automatically generates queries based on method
names.
○​ Pagination and sorting: Simplifies handling large datasets.

16. What is the difference between CrudRepository and JpaRepository?

●​ CrudRepository:
○​ Provides basic CRUD operations (create, read, update, delete).
●​ JpaRepository:
○​ Extends CrudRepository and adds JPA-specific methods (e.g., flush(),
saveAndFlush()).

17. What is the purpose of the @Transactional annotation?

●​ The @Transactional annotation is used to define transaction boundaries in

Spring.
●​ It ensures that a group of operations either complete successfully or roll back in
case of an error.
●​ Example:
@Transactional
public void transferMoney(Account from, Account to, double amount) {
from.withdraw(amount);
to.deposit(amount);
}

19. What is the purpose of the @Profile annotation?

●​ The @Profile annotation is used to conditionally load beans based on the active
profile.
●​ Example:
@Configuration
@Profile("dev")
public class DevConfig {
// Beans for development environment
}

20. What is the difference between @Qualifier and @Primary?

●​ @Qualifier:
○​ Used to resolve ambiguity when multiple beans of the same type exist.
●​ @Primary:
 ○​ Indicates that a bean should be given preference when multiple
candidates are available.

22. What is the difference between @RequestParam and @PathVariable?

●​ @RequestParam:
○​ Used to extract query parameters from the URL.
○​ Example: /users?id=123
●​ @PathVariable:
○​ Used to extract values from the URI template.
○​ Example: /users/{id}

23. What is the purpose of the @ExceptionHandler annotation?

●​ The @ExceptionHandler annotation is used to handle exceptions thrown by

controller methods.
@ExceptionHandler(UserNotFoundException.class)
public ResponseEntity<String> handleUserNotFound(UserNotFoundException ex) {
return new ResponseEntity<>(ex.getMessage(), HttpStatus.NOT_FOUND);
}

24. What is the difference between @Configuration and @Component?

●​ @Configuration:
○​ Indicates that the class is a source of bean definitions.
○​ Can contain @Bean methods.
●​ @Component:
○​ A generic stereotype for any Spring-managed bean.

What is the purpose of the @Value annotation?

●​ The @Value annotation is used to inject values from properties files or

environment variables.
●​ Example:
@Value("${app.name}")
private String appName;
spring boot
1. What is Spring Boot, and how does it simplify Spring development?

●​ Spring Boot is an extension of the Spring framework that simplifies the

development of production-ready applications.
●​ Key features:
○​ Auto-configuration: Automatically configures beans based on
dependencies.
○​ Embedded servers: Includes Tomcat, Jetty, etc.
○​ Starter dependencies: Simplifies dependency management.
○​ Actuator: Provides production-ready features like health checks and
metrics.
○​ Externalized configuration: Supports properties files, YAML, environment
variables, etc.

2. What is the difference between @SpringBootApplication and

@EnableAutoConfiguration?

●​ @SpringBootApplication:
○​ A combination of @Configuration, @EnableAutoConfiguration, and
@ComponentScan.
○​ Used to mark the main class of a Spring Boot application.
●​ @EnableAutoConfiguration:
○​ Enables Spring Boot's auto-configuration mechanism.
○​ Automatically configures beans based on the classpath and properties

3. What are Spring Boot starters, and how do they work?

●​ Spring Boot starters are dependency descriptors that simplify dependency

management.
●​ They group related dependencies into a single artifact.
●​ Example:
○​ spring-boot-starter-web: Includes dependencies for building web
applications (e.g., Spring MVC, Tomcat).
○​ spring-boot-starter-data-jpa: Includes dependencies for JPA and
database access.

4. What is the purpose of the application.properties/application.yml

file?
 ●​ The application.properties or application.yml file is used to configure
Spring Boot applications.
●​ It supports properties like server port, database connection, logging levels, etc.
●​
server.port=8081
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=secret

7. What is the purpose of the @SpringBootTest annotation?

●​ The @SpringBootTest annotation is used for integration testing in Spring Boot.

●​ It loads the full application context and allows testing of all layers (controllers,
services, repositories).

11. What is the purpose of the @Profile annotation?

●​ The @Profile annotation is used to conditionally load beans based on the active
profile.
●​ Example:

13. How do you enable Actuator endpoints in Spring Boot?

●​ Add the spring-boot-starter-actuator dependency.

●​ Configure endpoints in application.properties:

18. What is the purpose of the @Transactional annotation?

●​ The @Transactional annotation is used to define transaction boundaries in

Spring.
●​ It ensures that a group of operations either complete successfully or roll back in
case of an error.
@Transactional
public void transferMoney(Account from, Account to, double amount) {
from.withdraw(amount);
to.deposit(amount);
}

21. What is the purpose of the @SpringBootApplication annotation?

●​ The @SpringBootApplication annotation is a combination of:

○​ @Configuration: Marks the class as a configuration class
 ○​ @EnableAutoConfiguration: Enables auto-configuration.
○​ @ComponentScan: Scans for components, services, and repositories.

22. What is the purpose of the @EnableCaching annotation?

●​ The @EnableCaching annotation is used to enable caching in a Spring Boot

application.
●​ It requires a cache manager bean (e.g., ConcurrentMapCacheManager).

24. What is the purpose of the @ExceptionHandler annotation?

●​ The @ExceptionHandler annotation is used to handle exceptions thrown by

controller methods.