In Java, there are several ways to iterate through a `Map`.

Each way has its own

use case, and the choice depends on how you want to access the key-value pairs or
keys/values individually. Here's a breakdown of the different ways you can iterate
over a `Map`:

### 1. **Using `forEach` with Lambda Expression (Java 8 and later)**

This is a modern and concise way of iterating through a `Map` using the `forEach`
method with a lambda expression. It processes each `Map.Entry` (key-value pair)
directly.

```java
Map<String, Integer> map = new HashMap<>();
map.put("Naresh", 123);
map.put("Kurnool", 112);

map.forEach((key, value) -> System.out.println(key + ": " + value));

```

### 2. **Using `entrySet()`**

The `entrySet()` method returns a set view of the mappings in the `Map`. You can
then iterate through the entries using an enhanced for loop or an iterator.

#### Using Enhanced For Loop:

```java
Map<String, Integer> map = new HashMap<>();
map.put("Naresh", 123);
map.put("Kurnool", 112);

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

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

#### Using Iterator:

```java
Map<String, Integer> map = new HashMap<>();
map.put("Naresh", 123);
map.put("Kurnool", 112);

Iterator<Map.Entry<String, Integer>> iterator = map.entrySet().iterator();

while (iterator.hasNext()) {
Map.Entry<String, Integer> entry = iterator.next();
System.out.println(entry.getKey() + ": " + entry.getValue());
}
```

### 3. **Using `keySet()`**

You can iterate over just the keys of the `Map` using the `keySet()` method. After
getting the key, you can retrieve the value using `map.get(key)`.

```java
Map<String, Integer> map = new HashMap<>();
map.put("Naresh", 123);
map.put("Kurnool", 112);
for (String key : map.keySet()) {
Integer value = map.get(key);
System.out.println(key + ": " + value);
}
```

### 4. **Using `values()`**

If you are only interested in the values of the `Map`, you can use the `values()`
method, which returns a collection of values. You can then iterate through this
collection.

```java
Map<String, Integer> map = new HashMap<>();
map.put("Naresh", 123);
map.put("Kurnool", 112);

for (Integer value : map.values()) {

System.out.println(value);
}
```

### 5. **Using `Stream` API (Java 8 and later)**

You can convert the map to a stream and then use methods such as `forEach`,
`filter`, `map`, etc., to iterate over and process the map.

```java
Map<String, Integer> map = new HashMap<>();
map.put("Naresh", 123);
map.put("Kurnool", 112);

map.entrySet().stream()
.forEach(entry -> System.out.println(entry.getKey() + ": " +
entry.getValue()));
```

### 6. **Using `Iterator` with `keySet()` or `values()`**

You can also use an `Iterator` to iterate over the keys or values. This is
particularly useful when you want to modify the collection while iterating.

#### Using Iterator with Keys:

```java
Map<String, Integer> map = new HashMap<>();
map.put("Naresh", 123);
map.put("Kurnool", 112);

Iterator<String> keyIterator = map.keySet().iterator();

while (keyIterator.hasNext()) {
String key = keyIterator.next();
Integer value = map.get(key);
System.out.println(key + ": " + value);
}
```

#### Using Iterator with Values:

```java
Map<String, Integer> map = new HashMap<>();
map.put("Naresh", 123);
map.put("Kurnool", 112);

Iterator<Integer> valueIterator = map.values().iterator();

while (valueIterator.hasNext()) {
Integer value = valueIterator.next();
System.out.println(value);
}
```

### 7. **Using `forEach` with Method Reference (Java 8 and later)**

If you just need to print the key-value pairs and don't need to manipulate the
data, you can use method references with the `forEach` method.

```java
Map<String, Integer> map = new HashMap<>();
map.put("Naresh", 123);
map.put("Kurnool", 112);

map.forEach((key, value) -> System.out.println(key + ": " + value));

```

Alternatively, if you only need the values and have a custom method to print them,
you can use:

```java
map.forEach(this::printEntry);
```

### Summary of Iteration Methods:

| Method | Use Case |

|----------------------|--------------------------------------------------------|
| `forEach` with Lambda | Simple, concise, modern Java 8+ approach |
| `entrySet()` | Iterate over both keys and values |
| `keySet()` | Iterate over only keys |
| `values()` | Iterate over only values |
| `Stream API` | Perform complex transformations or filtering |
| `Iterator` | Allows modifying the map during iteration (used with
`entrySet()`, `keySet()`, or `values()`) |

### Choosing the Right Method:

- **`entrySet()`** is the most common and efficient way to iterate over both keys
and values.
- **`keySet()`** and **`values()`** are useful when you only need keys or values
separately.
- **Stream API** and **`forEach`** with lambdas are best for functional-style
operations or when you need to perform actions like filtering or mapping.

====================================
No, `freqmap.forEach(System.out::println)` will **not work** for a `Map` because
`System.out::println` is a method reference that works for a single object (such as
an element in a collection), not for a key-value pair (which is what a `Map.Entry`
is in a `Map`).
### Why It Won't Work:
- `freqmap.forEach(System.out::println)` works only when the map is a `Collection`
(such as a `List`, `Set`, etc.), where each element can be directly printed.
However, in a `Map`, each entry is a key-value pair (`Map.Entry<K, V>`).
- `System.out::println` doesn't know how to handle both key and value at the same
time.

### Correct Usage:

To print each key-value pair of a `Map` using a method reference, you need to
handle both the key and the value together, which you can do by either:
1. Using a lambda expression, or
2. Creating a method that can print both the key and value, then using a method
reference.

### Solution 1: Using Lambda Expression

```java
freqmap.forEach((k, v) -> System.out.println(k + ": " + v));
```

### Solution 2: Using Method Reference (via helper method)

You can create a helper method like so:

```java
public static void printEntry(Object k, Object v) {
System.out.println(k + ": " + v);
}
```

And then use the method reference:

```java
freqmap.forEach(YourClassName::printEntry);
```

### In Summary:
- `System.out::println` works for printing single elements (e.g., items in a `List`
or `Set`).
- For `Map`, you need to handle key-value pairs properly, either via a lambda
expression or a helper method with a method reference.
==================================
Yes, the `toString()` method is unnecessary in your code. The reason is that the
`StringBuilder`'s `reverse()` method already returns a `StringBuilder` object, but
in this case, it’s being concatenated with a `String` (from `input.substring(6)`).

Java allows direct concatenation of a `StringBuilder` and a `String`, so when you

use `+` to concatenate the reversed part, the `StringBuilder` is automatically
converted to a `String` during the concatenation.

Thus, you can omit the `toString()` method.

### Updated Code:

```java
var result = new StringBuilder(input.substring(0, 6)).reverse() +
input.substring(6);
```

### Explanation:
- `new StringBuilder(input.substring(0, 6)).reverse()`: This creates a
`StringBuilder` from the first 6 characters, reverses them, and returns a
`StringBuilder`.
- When you concatenate it with `input.substring(6)`, Java automatically converts
the `StringBuilder` to a `String`, so calling `toString()` explicitly is redundant.

### Final Answer:

`toString()` is not required here. You can simplify the code by removing it.
=============================
The statement "Comparable is a functional interface while Comparator is not" is
actually **incorrect**. Let's clarify:

### 1. **Comparable Interface**:

- **Functional Interface?** Yes, `Comparable` is a **functional interface**.
- A **functional interface** is an interface that has exactly one abstract method.
- `Comparable` defines a single abstract method:
```java
int compareTo(T o);
```
- Since `Comparable` has only one abstract method, it qualifies as a functional
interface.

### 2. **Comparator Interface**:

- **Functional Interface?** Yes, `Comparator` is also a **functional interface**.
- `Comparator` defines a **single abstract method**:
```java
int compare(T o1, T o2);
```
- Although `Comparator` also has default methods (`thenComparing`, `reversed`,
etc.), it still qualifies as a functional interface because the rule for a
functional interface is **one abstract method**, not how many methods it has in
total.

### Key Differences:

- **Comparable**: Used to define the natural order of objects (i.e., how they are
compared to one another by default).
- **Comparator**: Allows you to define multiple ways to compare objects (you can
have many different `Comparator` implementations for different sorting orders).

### Why the Confusion?

The confusion arises because `Comparator` has many **default methods** in addition
to its single abstract method. The existence of default methods doesn't change its
status as a functional interface. The rule is still based on having **one abstract
method**.

### Summary:
- **Both `Comparable` and `Comparator` are functional interfaces** in Java because
they both have exactly **one abstract method**.
===================================
You're correct that `Comparator` has an `equals()` method, and it’s worth
explaining why this is the case.

### 1. **`equals()` in `Comparator`**:

The `equals()` method is inherited from the `Object` class, and **every class in
Java (including interfaces) inherits this method**. This means that even though
`Comparator` is a functional interface and primarily defines the `compare()`
method, it also inherits the `equals()` method from the `Object` class. The
`equals()` method is **not defined explicitly** in `Comparator` itself.

Here’s the key point:

- `equals()` is not intended to be overridden or used in the context of comparison
in the `Comparator` interface.
- The presence of `equals()` is a result of inheritance from `Object`, which all
classes and interfaces inherit by default.

### 2. **Why is `equals()` not relevant in `Comparator`?**

The `equals()` method in `Comparator` is **not typically used** for comparisons.
The `compare()` method is the method that is used for comparing two objects.

- **`compare()`**: This method is the one you implement to define the comparison
logic between two objects.
- **`equals()`**: This method is inherited from `Object`, and it's used for
checking reference equality (whether two objects are the same in memory). It's not
usually used in the context of comparing objects based on certain criteria (which
is the purpose of `compare()` in `Comparator`).

### 3. **Why does `Comparator` have `equals()`?**

`Comparator` doesn't have any special version of `equals()`. It just inherits it
from `Object` because, as mentioned earlier, all Java objects (including interfaces
like `Comparator`) automatically inherit `equals()` from the `Object` class.

If you implement a custom comparator and want to use it in collections, you don’t
need to override `equals()` unless you need to customize how two comparator
instances are compared.

### 4. **What Happens if You Override `equals()` in `Comparator`?**

If you decide to override `equals()` in a `Comparator`, it would define how two
`Comparator` instances are compared, but this is **not typical** and is unrelated
to the `compare()` method. Overriding `equals()` in a `Comparator` would be rare
and specific to certain use cases (like comparing `Comparator` objects themselves,
not the objects they are comparing).

### 5. **Final Answer:**

The `equals()` method in `Comparator` comes from the `Object` class, and it’s not
meant to be used in the typical comparison logic. The method **doesn't affect the
core functionality** of the `Comparator`, which is focused on the `compare()`
method for ordering objects.

### In summary:
- **`equals()` in `Comparator`** is inherited from `Object`, and it's not
specifically relevant to the comparison logic between objects.
- The `compare()` method is the method used for defining how objects should be
compared.
==========================
If you want to achieve the same logic of **concatenating elements** that are "zero-
like" (e.g., empty strings or `null` for `String` arrays and spaces or specific
characters for `char` arrays) followed by the rest of the elements for **String
arrays** and **char arrays**, the approach will be similar, but we need to handle
the data types correctly.

Let's break down the two cases:

### Case 1: **String Array**

For a `String` array, let's assume that "zeros" are empty strings (`""`), and we
want to move all empty strings to the front while keeping the rest of the strings
intact.

```java
package com.InterviewPrep;
import java.util.Arrays;
import java.util.stream.Stream;

public class ExtractZerosFromStringArray {

public static void main(String[] args) {
String[] a = {"apple", "", "banana", "", "orange", ""};

// Concatenate empty strings first, then the rest of the strings

String[] result = Stream.concat(
Arrays.stream(a).filter(s -> s.isEmpty()), // filter empty strings
Arrays.stream(a).filter(s -> !s.isEmpty())) // filter non-empty
strings
.toArray(String[]::new); // Convert to array

System.out.println(Arrays.toString(result));
}
}
```

### Explanation:
- **Filtering empty strings**: `Arrays.stream(a).filter(s -> s.isEmpty())` filters
out the empty strings (zeros).
- **Filtering non-empty strings**: `Arrays.stream(a).filter(s -> !s.isEmpty())`
filters out the non-empty strings.
- The two filtered streams are then concatenated using `Stream.concat()`, and the
result is collected back into an array.

### Output:
```
[, , , apple, banana, orange]
```

### Case 2: **Char Array**

For a `char` array, let's assume that "zero-like" elements are spaces (`' '`), and
we want to move all spaces to the front while keeping the rest of the characters
intact.

```java
package com.InterviewPrep;

import java.util.Arrays;
import java.util.stream.IntStream;

public class ExtractSpacesFromCharArray {

public static void main(String[] args) {
char[] a = {'a', ' ', 'b', ' ', 'c', ' '};

// Concatenate spaces first, then the rest of the characters

char[] result = IntStream.concat(
Arrays.stream(a).filter(c -> c == ' '), // filter spaces
Arrays.stream(a).filter(c -> c != ' ')) // filter non-space
characters
.toArray(); // Convert to char array

System.out.println(Arrays.toString(result));
}
}
```
### Explanation:
- **Filtering spaces**: `Arrays.stream(a).filter(c -> c == ' ')` filters out the
spaces.
- **Filtering non-space characters**: `Arrays.stream(a).filter(c -> c != ' ')`
filters out the non-space characters.
- The two filtered streams are then concatenated using `IntStream.concat()`, and
the result is collected back into a `char[]`.

### Output:
```
[ , , , a, b, c]
```

### Key Notes:

1. For **String arrays**, the filtering condition is based on whether the string is
empty (`""`).
2. For **char arrays**, the filtering condition is based on whether the character
is a space (`' '`).
3. The `Stream.concat()` method is used to merge two streams (the ones with
spaces/zeros and the ones with non-zero/characters).
4. We use `toArray()` to convert the final stream back into the appropriate array
type.

Let me know if you need any further clarifications!

=====================================
To concatenate two lists in Java and print the result, you can use `addAll` to
combine the lists into a new list, or use streams. Here are a few approaches to
concatenate and print `nonSpaces` and `spaces`:

### Approach 1: Using `addAll` and a new `ArrayList`

```java
List<Character> result = new ArrayList<>(nonSpaces); // Create a new list with
nonSpaces
result.addAll(spaces); // Add spaces to the list

// Print the concatenated result

System.out.println(result);
```

This will concatenate the two lists and print them.

### Approach 2: Using Streams (if you prefer functional programming)

```java
List<Character> result = Stream.concat(nonSpaces.stream(), spaces.stream())
.collect(Collectors.toList());

// Print the concatenated result

System.out.println(result);
```

### Explanation:
1. **Using `addAll`**: The `addAll` method is a simple and efficient way to
concatenate two lists into a new list.
2. **Using Streams**: `Stream.concat(nonSpaces.stream(), spaces.stream())` merges
the two streams, and `collect(Collectors.toList())` collects the result back into a
list.
Both approaches will give you the concatenated list of characters, and when you
print the list, it will print all characters from both lists in the order they
appear.
=======================================
To get the values only from a `Map` in Java, you can use the following approaches:

### 1. **Using `map.values()` (Direct Approach)**:

The `Map.values()` method returns a collection of all the values in the map. You
can simply convert this collection into a list or iterate over it. Here's how you
can achieve it:

#### Example 1: **Using `Map.values()`** (Direct Approach)

```java
package com.InterviewPrep;

import java.util.*;
import java.util.stream.Collectors;

public class GetValuesOnlyFromMap {

public static void main(String[] args) {
Map<Integer, String> ma = new HashMap<>();
ma.put(1, "Naresh");
ma.put(2, "Mahesh");
ma.put(3, "Krishna");
ma.put(4, "AdinathGiri");
ma.put(5, "Ashok");
ma.put(6, "Surya");

// Using Map.values() to get all values from the map

Collection<String> values = ma.values();

// Print the values

System.out.println(values);
}
}
```

### Output:
```text
[Naresh, Mahesh, Krishna, AdinathGiri, Ashok, Surya]
```

In this example, `ma.values()` returns a collection of all the values in the map.
If you want to get the values as a `List`, you can simply convert it using
`Collectors.toList()` or by creating a `List` directly like this:

```java
List<String> values = new ArrayList<>(ma.values());
```

---

### 2. **Using Streams (`map.values().stream()`)**:

If you want to use Java Streams, you can convert the collection of values into a
stream, and then collect them into a list or perform any other stream operations.

#### Example 2: **Using Streams**

```java
package com.InterviewPrep;

import java.util.*;
import java.util.stream.Collectors;

public class GetValuesOnlyFromMap {

public static void main(String[] args) {
Map<Integer, String> ma = new HashMap<>();
ma.put(1, "Naresh");
ma.put(2, "Mahesh");
ma.put(3, "Krishna");
ma.put(4, "AdinathGiri");
ma.put(5, "Ashok");
ma.put(6, "Surya");

// Using stream() to collect values into a list

List<String> values = ma.values().stream().collect(Collectors.toList());

// Print the values

System.out.println(values);
}
}
```

### Output:
```text
[Naresh, Mahesh, Krishna, AdinathGiri, Ashok, Surya]
```

In this case, `ma.values().stream()` creates a stream from the collection of

values, and `Collectors.toList()` collects them into a `List<String>`.

---

### 3. **Normal Approach (Iteration)**:

You can also iterate over the `Map` entries and manually collect the values.

#### Example 3: **Using a Normal `for` Loop**

```java
package com.InterviewPrep;

import java.util.*;

public class GetValuesOnlyFromMap {

public static void main(String[] args) {
Map<Integer, String> ma = new HashMap<>();
ma.put(1, "Naresh");
ma.put(2, "Mahesh");
ma.put(3, "Krishna");
ma.put(4, "AdinathGiri");
ma.put(5, "Ashok");
ma.put(6, "Surya");

// Normal approach using iteration

List<String> values = new ArrayList<>();
 for (Map.Entry<Integer, String> mdta : ma.entrySet()) {
values.add(mdta.getValue()); // Get value from entry and add to list
}

// Print the values

System.out.println(values);
}
}
```

### Output:
```text
[Naresh, Mahesh, Krishna, AdinathGiri, Ashok, Surya]
```

This method loops over each entry in the map and adds the value to the `values`
list.

---

### Summary:
- **Direct Approach**: Use `ma.values()` to get a collection of values directly.
- **Using Streams**: Use `ma.values().stream()` and collect them with
`Collectors.toList()`.
- **Normal Iteration**: Use a `for` loop to iterate over map entries and extract
values.

All approaches are valid, but using `Map.values()` is the simplest if you're only
interested in values.
================================
### Autoboxing and Unboxing in Java

**Autoboxing** and **unboxing** are features in Java that allow automatic

conversion between primitive types (e.g., `int`, `double`, etc.) and their
corresponding wrapper classes (e.g., `Integer`, `Double`, etc.). This conversion
happens implicitly and is a powerful feature that simplifies code when dealing with
collections or objects that expect object types.

### What is Autoboxing?

**Autoboxing** is the automatic conversion of a **primitive type** to its

corresponding **wrapper class**. For example, converting an `int` to an `Integer`,
or a `double` to a `Double`.

### What is Unboxing?

**Unboxing** is the reverse process: converting an **object of a wrapper class** to

its corresponding **primitive type**. For example, converting an `Integer` to an
`int`, or a `Double` to a `double`.

### Examples of Autoboxing and Unboxing

#### Example 1: Autoboxing

Autoboxing occurs when a primitive type is assigned to a wrapper class object or
when a primitive type is passed where an object is expected.

```java
public class AutoboxingExample {
public static void main(String[] args) {
 // Autoboxing: Primitive int to Integer
int primitiveInt = 10;
Integer boxedInteger = primitiveInt; // Autoboxing

System.out.println("Boxed Integer: " + boxedInteger);

}
}
```

**Output**:
```
Boxed Integer: 10
```

In the above example, the primitive `int` is automatically converted (autoboxed)

into an `Integer` object.

#### Example 2: Unboxing

Unboxing happens when a wrapper class object is used in a context where a primitive
type is expected.

```java
public class UnboxingExample {
public static void main(String[] args) {
// Unboxing: Integer to primitive int
Integer boxedInteger = 20; // Autoboxing
int primitiveInt = boxedInteger; // Unboxing

System.out.println("Primitive int: " + primitiveInt);

}
}
```

**Output**:
```
Primitive int: 20
```

In this example, the `Integer` object is automatically converted (unboxed) to a

primitive `int`.

#### Example 3: Autoboxing with Collections

Autoboxing allows primitive values to be automatically wrapped when stored in

collections that only accept objects (e.g., `List`, `Set`, etc.).

```java
import java.util.*;

public class AutoboxingWithCollections {

public static void main(String[] args) {
List<Integer> list = new ArrayList<>();

// Autoboxing: Primitive int automatically converted to Integer

list.add(5); // Adding primitive int to the list

System.out.println("List contains: " + list);

}
}
```

**Output**:
```
List contains: [5]
```

Here, the primitive `int` (5) is automatically autoboxed into an `Integer` when
added to the `List<Integer>`.

#### Example 4: Unboxing with Collections

Unboxing can occur when values are retrieved from a collection and used as
primitive types.

```java
import java.util.*;

public class UnboxingWithCollections {

public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(10); // Autoboxing

// Unboxing: Retrieving Integer and converting to primitive int

int number = list.get(0); // Unboxing

System.out.println("Unboxed value: " + number);

}
}
```

**Output**:
```
Unboxed value: 10
```

In this example, the `Integer` stored in the `List` is unboxed to a primitive `int`
when retrieved.

### Example 5: Autoboxing and Unboxing with Arithmetic Operations

Autoboxing and unboxing can also happen automatically during arithmetic operations.
Here's an example where the wrapper class `Integer` and the primitive `int` are
used together:

```java
public class ArithmeticWithAutoboxing {
public static void main(String[] args) {
Integer boxedInteger = 50; // Autoboxing
int primitiveInt = 20;

// Unboxing and then performing arithmetic

int result = boxedInteger + primitiveInt; // Unboxing and arithmetic

System.out.println("Result of addition: " + result);

}
}
```
**Output**:
```
Result of addition: 70
```

Here, the `Integer` object is unboxed to an `int` before the addition, and the
result is stored in a primitive `int`.

### Key Points:

- **Autoboxing**: The automatic conversion of a primitive type (like `int`,
`double`, etc.) to its corresponding wrapper class (like `Integer`, `Double`,
etc.).
- **Unboxing**: The automatic conversion of a wrapper class object to its
corresponding primitive type.
- **Usage**: Autoboxing and unboxing are useful when working with collections (like
`List` or `Set`) that can only store objects, and when you need to perform
arithmetic operations without manually converting between primitives and objects.

### Benefits:
- Autoboxing and unboxing reduce boilerplate code and make Java code more concise
and easier to read.
- They allow the seamless use of primitive types in collections, which typically
expect objects.
=============================
No, **collections in Java** cannot hold **primitive types** directly. Collections
like `List`, `Set`, `Queue`, etc., only store **objects** (reference types), not
**primitive types**.

### Why Collections Cannot Hold Primitives:

Java collections (such as `ArrayList`, `HashSet`, `HashMap`, etc.) are designed to
work with objects because Java's generic system (`<T>`) only works with reference
types, not primitives.

For example, the following is **not allowed**:

```java
List<int> list = new ArrayList<>(); // This won't compile!
```

You cannot use `int`, `char`, `double`, etc., directly as the type for a
collection. The reason is that **primitive types** are not objects; they are basic
data types with specific memory layouts, and collections can only store reference
types (objects) in Java.

### Solution: **Wrapper Classes** (Autoboxing)

To solve this, Java provides **wrapper classes** for all the primitive types. These
wrapper classes are **objects** and allow you to store primitive values in
collections. For example:

- `int` -> `Integer`

- `char` -> `Character`
- `boolean` -> `Boolean`
- `double` -> `Double`

### Example:

```java
import java.util.*;
public class PrimitiveInCollections {
public static void main(String[] args) {
// Using wrapper class Integer to hold int values in a collection
List<Integer> list = new ArrayList<>();
list.add(10); // Autoboxing: int 10 is converted to Integer

// Using wrapper class Double to hold double values in a collection

Set<Double> set = new HashSet<>();
set.add(3.14); // Autoboxing: double 3.14 is converted to Double

// Print the collections

System.out.println("List: " + list);
System.out.println("Set: " + set);
}
}
```

**Output:**
```
List: [10]
Set: [3.14]
```

### How This Works:

- **Autoboxing**: Java automatically converts the **primitive types** (`int`,
`double`) to their corresponding **wrapper classes** (`Integer`, `Double`) when
adding them to collections.
- **Unboxing**: Similarly, when values are retrieved from the collection, they are
automatically converted back to the primitive types if needed.

### Wrapper Classes for Primitives:

Here are the **wrapper classes** for all the primitive types:

| Primitive Type | Wrapper Class |

|----------------|----------------|
| `int` | `Integer` |
| `boolean` | `Boolean` |
| `char` | `Character` |
| `double` | `Double` |
| `float` | `Float` |
| `long` | `Long` |
| `short` | `Short` |
| `byte` | `Byte` |
| `void` | `Void` |

### Benefits of Using Wrapper Classes in Collections:

1. **Collections Can Store Values**: Collections like `ArrayList`, `HashSet`, etc.,
can only hold objects. By using wrapper classes, we can store primitive values as
objects.
2. **Autoboxing/Unboxing**: Java automatically handles the conversion between
primitive types and their corresponding wrapper classes, so you don't have to
manually convert between them.
3. **Nullability**: Unlike primitive types (which always have a default value),
wrapper classes can be set to `null`, making them more flexible for certain use
cases like optional values in collections.

### Example with `Map`:

```java
import java.util.*;

public class MapExample {

public static void main(String[] args) {
// Using wrapper class Integer to store int as key and value
Map<Integer, Integer> map = new HashMap<>();
map.put(1, 100); // Autoboxing: int 1 and 100 are converted to Integer

System.out.println("Map: " + map);

}
}
```

**Output:**
```
Map: {1=100}
```

### Conclusion:
- Collections cannot hold **primitive types** directly. They can only hold
**objects** (reference types).
- You can use **wrapper classes** like `Integer`, `Character`, `Boolean`, etc., to
store primitive values in collections.
- Java provides **autoboxing** and **unboxing** to automatically convert between
primitive types and their corresponding wrapper classes, making it easier to work
with collections.
===============================
In Java, **ExecutorService** is a higher-level replacement for the traditional way
of managing threads using `Thread` and `Runnable`. It provides a more flexible and
efficient way to manage the execution of tasks concurrently. `ExecutorService` is
part of the `java.util.concurrent` package and is a more powerful abstraction for
managing a pool of threads and executing asynchronous tasks.

### Key Features of `ExecutorService`:

1. **Thread Pool Management**:

- `ExecutorService` provides an abstraction for managing a pool of worker
threads, making it easier to execute tasks asynchronously.
- The thread pool helps to avoid the overhead of creating and destroying threads
frequently, improving application performance and resource management.

2. **Task Submission**:
- You can submit tasks (usually instances of `Runnable` or `Callable`) to an
`ExecutorService`, which executes them asynchronously, either immediately or when a
thread becomes available.
- You can submit tasks using methods like `submit()` or `invokeAll()`.

3. **Graceful Shutdown**:
- An `ExecutorService` can be gracefully shut down using the `shutdown()`
method, which allows previously submitted tasks to complete, and prevents new tasks
from being submitted. The `shutdownNow()` method attempts to stop currently
executing tasks.

4. **Callable Support**:
- Unlike `Runnable`, which does not return a result, `Callable` tasks can return
results or throw exceptions. The `submit()` method can be used to execute
`Callable` tasks, and it returns a `Future` object that can be used to retrieve the
result once the task completes.
5. **Handling Results**:
- `ExecutorService` allows you to manage the result of tasks through `Future`
objects. A `Future` represents the result of an asynchronous computation and
provides methods to check if the task is complete or cancel it.
- You can call `future.get()` to block the current thread and wait for the
result of a `Callable` task.

### Common Methods in `ExecutorService`:

1. **submit()**:
- Used to submit tasks for execution. Returns a `Future` object.
```java
Future<?> submit(Runnable task);
Future<T> submit(Callable<T> task);
```

2. **invokeAll()**:
- Submits a collection of tasks and blocks until all tasks are complete.
```java
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks);
```

3. **invokeAny()**:
- Submits a collection of tasks and blocks until one of the tasks completes. It
returns the result of the first completed task.
```java
<T> T invokeAny(Collection<? extends Callable<T>> tasks);
```

4. **shutdown()**:
- Initiates an orderly shutdown in which previously submitted tasks are
executed, but no new tasks will be accepted.
```java
void shutdown();
```

5. **shutdownNow()**:
- Attempts to stop all actively executing tasks, halts the processing of waiting
tasks, and returns a list of the tasks that were waiting to be executed.
```java
List<Runnable> shutdownNow();
```

6. **isShutdown()** and **isTerminated()**:

- You can check whether the executor has been shut down or whether all tasks
have finished.
```java
boolean isShutdown();
boolean isTerminated();
```

### Types of Executors Implementing ExecutorService:

1. **FixedThreadPool**:
- A thread pool with a fixed number of threads. If all threads are busy, tasks
are queued until a thread becomes available.
- Example: Use `Executors.newFixedThreadPool(int nThreads)` to create a fixed-
size pool.
 ```java
ExecutorService executor = Executors.newFixedThreadPool(10);
```

2. **CachedThreadPool**:
- A thread pool that creates new threads as needed, but will reuse previously
constructed threads when available.
- Example: Use `Executors.newCachedThreadPool()` to create a cached thread pool.
```java
ExecutorService executor = Executors.newCachedThreadPool();
```

3. **SingleThreadExecutor**:
- A thread pool that uses a single worker thread to process tasks sequentially.
- Example: Use `Executors.newSingleThreadExecutor()` to create a single-threaded
pool.
```java
ExecutorService executor = Executors.newSingleThreadExecutor();
```

4. **ScheduledThreadPoolExecutor**:
- An extension of `ExecutorService` that supports scheduling tasks to run after
a delay or periodically.
- Example: Use `Executors.newScheduledThreadPool(int corePoolSize)` to create a
scheduled thread pool.
```java
ScheduledExecutorService scheduledExecutor =
Executors.newScheduledThreadPool(10);
scheduledExecutor.scheduleAtFixedRate(task, initialDelay, period,
TimeUnit.SECONDS);
```

### Example of Using `ExecutorService`:

```java
import java.util.concurrent.*;

public class ExecutorServiceExample {

public static void main(String[] args) throws InterruptedException,
ExecutionException {
// Create an ExecutorService with a fixed pool of 2 threads
ExecutorService executorService = Executors.newFixedThreadPool(2);

// Submit a Runnable task

executorService.submit(() -> {
System.out.println("Task 1 executed by: " +
Thread.currentThread().getName());
});

// Submit a Callable task that returns a result

Future<Integer> future = executorService.submit(() -> {
System.out.println("Task 2 executed by: " +
Thread.currentThread().getName());
return 123;
});

// Get the result of the Callable task

Integer result = future.get(); // This will block until the task completes
System.out.println("Result from Task 2: " + result);
 // Shut down the executor service
executorService.shutdown();
}
}
```

### Key Concepts:

- **Task Submission**: Tasks (either `Runnable` or `Callable`) are submitted to the
`ExecutorService`, and the service takes care of assigning them to available
threads from the pool.
- **Future**: `Future` represents the result of an asynchronous computation,
allowing you to check if the task is done or retrieve its result.
- **Thread Pool**: The `ExecutorService` manages a pool of threads, improving
performance by reusing threads rather than creating new ones for every task.
- **Shutdown**: It's important to shut down the `ExecutorService` when it’s no
longer needed to release resources. You can use `shutdown()` or `shutdownNow()` for
graceful termination.

### Conclusion:
The `ExecutorService` is a flexible and efficient way to manage thread execution in
Java, especially when dealing with concurrent tasks. It abstracts away much of the
complexity of managing threads manually, offering powerful features like thread
pooling, task scheduling, and result management. By using it, you can improve the
scalability and efficiency of your concurrent applications.
============================
To create a thread in Java using the `Runnable` interface, follow these steps:

1. **Implement the `Runnable` Interface**: The `Runnable` interface represents a

task that can be executed concurrently by a thread. You implement the `run()`
method of this interface with the code that you want the thread to execute.

2. **Create a Thread Object**: Once the `Runnable` is implemented, you create a

`Thread` object and pass the `Runnable` instance to the `Thread` constructor.

3. **Start the Thread**: To execute the `Runnable`, you call the `start()` method
on the `Thread` object. This will internally call the `run()` method of your
`Runnable` instance.

### Example Code:

```java
public class RunnableExample {
public static void main(String[] args) {
// Step 1: Create a Runnable task
Runnable task = new Runnable() {
@Override
public void run() {
// Code to be executed by the thread
System.out.println("Task is running in thread: " +
Thread.currentThread().getName());
}
};

// Step 2: Create a Thread and pass the Runnable

Thread thread = new Thread(task);

// Step 3: Start the thread to execute the run() method

thread.start();
 // Optionally, create and start another thread
Thread anotherThread = new Thread(task);
anotherThread.start();
}
}
```

### Explanation:
1. **Runnable Implementation**: The `task` is an instance of an anonymous class
that implements the `Runnable` interface. Inside the `run()` method, the code you
want the thread to execute is defined. In this case, it simply prints the current
thread's name.

2. **Thread Creation**: A new `Thread` object is created, passing the `Runnable`

instance (`task`) as a parameter. This associates the `Runnable` task with the
thread.

3. **Starting the Thread**: Calling `start()` on the `Thread` object triggers the
execution of the `run()` method of the `Runnable` in a new thread of execution.

### Output:
The output will be something like this:
```
Task is running in thread: Thread-0
Task is running in thread: Thread-1
```

Each time you call `start()`, a new thread is created and executed. The
`Thread.currentThread().getName()` method returns the name of the thread executing
the `run()` method, showing that each thread runs independently.

### Important Notes:

- **`run()` method**: When you invoke the `start()` method, it internally calls the
`run()` method. **Do not call the `run()` method directly** on the `Thread` object,
as it will not create a new thread but simply execute the code in the current
thread.
- **Thread Lifecycle**: After calling `start()`, the thread goes through various
states: from **new** to **runnable**, and eventually to **terminated** when the
task completes.
- **Concurrency**: Since threads run concurrently, you can have multiple threads
performing different tasks at the same time.
================================
Sure! If you want to create a class that implements the `Runnable` interface, you
need to follow these steps:

1. **Implement the `Runnable` interface**: Your class should implement the

`Runnable` interface and override the `run()` method. The `run()` method contains
the code that will be executed by the thread when it starts.

2. **Create and start a thread**: After implementing the `Runnable` interface, you
need to create a `Thread` object and pass your class instance (which implements
`Runnable`) to the `Thread` constructor. Then, you can start the thread.

### Example of a Class Implementing `Runnable` Interface:

```java
class MyRunnable implements Runnable {
@Override
 public void run() {
// Code to be executed by the thread
System.out.println("Task is running in thread: " +
Thread.currentThread().getName());
}
}

public class RunnableExample {

public static void main(String[] args) {
// Step 1: Create an instance of the class that implements Runnable
MyRunnable task = new MyRunnable();

// Step 2: Create a Thread and pass the Runnable object

Thread thread1 = new Thread(task);
Thread thread2 = new Thread(task);

// Step 3: Start the threads to execute the run() method

thread1.start();
thread2.start();
}
}
```

### Explanation:

1. **`MyRunnable` Class**: This class implements the `Runnable` interface and

overrides the `run()` method. Inside the `run()` method, you define the code that
you want to be executed by the thread. In this case, it prints the thread's name
using `Thread.currentThread().getName()`.

2. **Creating and Starting Threads**:

- An instance of `MyRunnable` is created and assigned to the `task` variable.
- Two `Thread` objects (`thread1` and `thread2`) are created, each of which
takes the `task` (an instance of `Runnable`) as a parameter.
- The `start()` method is called on both `thread1` and `thread2`, which causes
the `run()` method to be executed by two separate threads concurrently.

### Output:

The output will show that both threads are executing concurrently, for example:

```
Task is running in thread: Thread-0
Task is running in thread: Thread-1
```

This shows that both threads are executing the `run()` method in parallel.

### Key Points:

- **`Runnable` Interface**: The `Runnable` interface only contains a single method
`run()` which is meant to hold the code you want to execute in a thread.
- **Thread Creation**: The `Thread` class is used to create a new thread, and the
`Runnable` object is passed to its constructor. When `start()` is called, the
`run()` method is executed in a new thread.
- **Concurrency**: By creating multiple `Thread` objects, each running the same
`Runnable` code, you can execute tasks concurrently in different threads.
===========================
### Composition and Aggregation in Java:
Both **composition** and **aggregation** are types of **association** between
objects in object-oriented programming (OOP). They describe relationships between
classes and represent how one class can "own" or "contain" objects of another
class.

Here is a detailed explanation of each:

---

### 1. **Composition**:

- **Definition**: Composition is a strong type of association where one class is

**part of another class**. The lifetime of the composed objects is tied to the
parent class. If the parent class is destroyed, the composed objects are also
destroyed.

- **Characteristics of Composition**:
- **Strong relationship**: The contained objects cannot exist without the parent
class.
- **Parent owns the child**: The child class objects are owned and created by the
parent class.
- **Lifecycle dependency**: When the parent object is destroyed, the child
objects are also destroyed.

- **Example**: A `Car` has `Engine`. If a `Car` is destroyed, the `Engine` should

also be destroyed because an engine can't exist without the car.

#### Composition Example Code:

```java
class Engine {
public void start() {
System.out.println("Engine starting...");
}
}

class Car {
private Engine engine; // Car owns the engine, part-whole relationship

public Car() {
this.engine = new Engine(); // Engine is created when Car is created
}

public void drive() {

engine.start();
System.out.println("Car is driving...");
}
}

public class Main {

public static void main(String[] args) {
Car car = new Car(); // Car object created
car.drive(); // Drive the car which also starts the engine
}
}
```

#### Explanation:
- **Car** has an **Engine** (part-whole relationship).
- When a `Car` object is created, it creates its own `Engine` object (composition).
- If the `Car` object is destroyed, its `Engine` is also destroyed.

---

### 2. **Aggregation**:

- **Definition**: Aggregation is a **weaker association** compared to composition.

It represents a relationship where one object "has" another object, but both
objects can exist independently. The lifetime of the aggregated objects is not
dependent on the parent object.

- **Characteristics of Aggregation**:
- **Weak relationship**: The contained objects can exist independently of the
parent.
- **Parent does not own the child**: The child objects can be shared by multiple
parents or can exist outside the parent class.
- **Independent lifecycle**: The child objects can continue to exist even if the
parent object is destroyed.

- **Example**: A `Department` has multiple `Employee` objects. The employees can

exist independently of the department, and they can belong to other departments
too.

#### Aggregation Example Code:

```java
class Employee {
private String name;

public Employee(String name) {

this.name = name;
}

public void showEmployeeDetails() {

System.out.println("Employee: " + name);
}
}

class Department {
private String departmentName;
private Employee employee; // Department has an Employee, but Employee can
exist independently

public Department(String departmentName, Employee employee) {

this.departmentName = departmentName;
this.employee = employee;
}

public void showDepartmentDetails() {

System.out.println("Department: " + departmentName);
employee.showEmployeeDetails(); // Show details of employee
}
}

public class Main {

public static void main(String[] args) {
Employee employee = new Employee("John Doe"); // Employee object created
independently
 Department department = new Department("HR", employee); // Employee is
aggregated into the department

department.showDepartmentDetails(); // Department shows employee details

}
}
```

#### Explanation:
- **Department** has an **Employee** (aggregation).
- The `Employee` object is created independently and passed to the `Department`
object.
- The `Employee` can exist outside the `Department` object, and can be part of
other departments or objects. Destroying the `Department` doesn't destroy the
`Employee`.

---

### Key Differences Between Composition and Aggregation:

| **Characteristic** | **Composition** |
**Aggregation** |
|-------------------------|-----------------------------------------------------|--
---------------------------------------------------|
| **Strength of Relationship** | Strong (whole-part relationship) |
Weaker (has-a relationship) |
| **Lifecycle Dependency** | The child object’s lifetime depends on the parent |
The child object can exist independently |
| **Example** | Car has Engine |
Department has Employee |
| **Object Ownership** | Parent owns the child object |
Parent does not own the child object |
| **Example Scenario** | Car and Engine (Engine cannot exist without Car) |
Department and Employee (Employee can exist outside Department) |

---

### Conclusion:

- **Composition** is used when one class is a part of another class, and the
existence of the part is dependent on the whole. It represents a strong
relationship.
- **Aggregation** is a weaker form of association where one class contains a
reference to another class, but both objects can exist independently of each other.

Understanding the difference between these relationships helps you design better
object-oriented systems by clarifying the ownership and lifetime behavior of
objects.
====================================
In Java, **arrays** and **collections** can store both **primitive types** (like
`int`, `char`, etc.) and **objects** (like instances of classes). However, the way
they store primitives and objects is slightly different.

### 1. **Arrays in Java:**

- **Arrays of Primitives**: You can directly store primitive types in an array.
- **Arrays of Objects**: You can store object references in an array. When you
create an array of objects, the array holds references to the objects, not the
actual objects.
#### Example of Arrays with Primitives and Objects:

```java
public class ArraysExample {
public static void main(String[] args) {
// Array of primitive types
int[] intArray = {1, 2, 3, 4, 5};
System.out.println("Array of Primitives:");
for (int num : intArray) {
System.out.println(num); // Directly stores primitive values
}

// Array of objects
String[] strArray = {"Hello", "World", "Java"};
System.out.println("\nArray of Objects:");
for (String str : strArray) {
System.out.println(str); // Stores object references
}
}
}
```

#### Explanation:
- **Array of Primitives**: `int[] intArray = {1, 2, 3, 4, 5};`
- Here, the array directly holds primitive `int` values.

- **Array of Objects**: `String[] strArray = {"Hello", "World", "Java"};`

- Here, the array holds **references to String objects**.

#### Output:

```
Array of Primitives:
1
2
3
4
5

Array of Objects:
Hello
World
Java
```

### 2. **Collections in Java:**

- **Collections cannot store primitives directly**: Collections (like `List`,
`Set`, etc.) cannot store primitive types directly. They store **objects** (which
are instances of classes).
- **Autoboxing**: Java provides autoboxing, which automatically converts
primitive types to their corresponding wrapper classes (e.g., `int` to `Integer`,
`char` to `Character`, etc.) when you add them to a collection.

#### Example of Collections with Primitives (via Autoboxing) and Objects:

```java
import java.util.*;

public class CollectionsExample {

 public static void main(String[] args) {
// Collection of wrapper classes (autoboxing happens here)
List<Integer> intList = new ArrayList<>();
intList.add(1); // int is automatically converted to Integer
intList.add(2);
intList.add(3);

System.out.println("List of Primitives (via Autoboxing):");

for (Integer num : intList) {
System.out.println(num); // Holds Integer objects, not primitives
}

// Collection of Objects (String in this case)

List<String> strList = new ArrayList<>();
strList.add("Hello");
strList.add("World");
strList.add("Java");

System.out.println("\nList of Objects:");
for (String str : strList) {
System.out.println(str); // Holds String objects
}
}
}
```

#### Explanation:
- **Autoboxing**: In the `intList`, primitive `int` values are automatically
converted to `Integer` objects when added to the `List`.
- `List<Integer> intList = new ArrayList<>();` can hold `Integer` objects, not
primitive `int`. But due to autoboxing, primitive values like `1`, `2`, etc., are
automatically converted to `Integer` objects.

- **List of Objects**: In the `strList`, objects are directly added to the

collection (`String` objects in this case).

#### Output:

```
List of Primitives (via Autoboxing):
1
2
3

List of Objects:
Hello
World
Java
```

### Key Differences:

| **Feature** | **Arrays** |
**Collections** |
|---------------------------|-------------------------------------------------|----
---------------------------------------------|
| **Primitives** | Can store primitive types directly (e.g., `int[]`) |
Cannot store primitives directly, needs wrapper classes (e.g., `List<Integer>`) |
| **Objects** | Can store objects (e.g., `String[]`) |
Can store objects (e.g., `List<String>`) |
| **Autoboxing** | Not needed (can store primitives directly) |
Autoboxing is needed (e.g., `int` becomes `Integer`) |
| **Storage Type** | Holds the value directly (primitives) or reference
to objects | Holds references to objects (primitives are converted to wrapper
objects) |

### Summary:
- **Arrays** can store both **primitive values** and **object references**.
- **Collections** (such as `List`, `Set`) **cannot store primitives directly** but
store **object references**. With **autoboxing**, primitive types are automatically
converted to their respective wrapper classes (e.g., `int` to `Integer`, `char` to
`Character`, etc.) when added to collections.
==============================
In a **many-to-many** relationship, each entity in one table can be associated with
multiple entities in another table, and vice versa. This is one of the most common
relationships in databases and is typically implemented using a third table (often
called a **junction table** or **associative table**) that holds the foreign keys
from both tables to establish the relationship.

### Example:

Consider a **Student** and **Course** scenario:

- A **student** can enroll in multiple **courses**.

- A **course** can have multiple **students** enrolled in it.

This creates a **many-to-many** relationship between **students** and **courses**.

### Tables in Database:

1. **Student Table**:
- `student_id` (Primary Key)
- `student_name`

2. **Course Table**:
- `course_id` (Primary Key)
- `course_name`

3. **Enrollment Table** (Junction Table):

- `student_id` (Foreign Key)
- `course_id` (Foreign Key)

The `Enrollment` table stores combinations of student-course pairs, indicating that

a specific student is enrolled in a specific course. This way, we can associate
each student with many courses and each course with many students.

### Diagram:

```
Student Table:
+------------+---------------+
| student_id | student_name |
+------------+---------------+
| 1 | Alice |
| 2 | Bob |
| 3 | Charlie |
+------------+---------------+

Course Table:
+------------+---------------+
| course_id | course_name |
+------------+---------------+
| 101 | Math |
| 102 | Science |
| 103 | History |
+------------+---------------+

Enrollment Table (Junction Table):

+------------+------------+
| student_id | course_id |
+------------+------------+
| 1 | 101 |
| 1 | 102 |
| 2 | 101 |
| 3 | 103 |
+------------+------------+
```

### Explanation:
- The **Student Table** contains the list of all students.
- The **Course Table** contains all available courses.
- The **Enrollment Table** connects the two, linking each student to the courses
they are enrolled in by storing the `student_id` and `course_id`.

### SQL Example to Query Many-to-Many Relationship:

1. **Find all courses a student is enrolled in**:

```sql
SELECT course_name
FROM Course
JOIN Enrollment ON Course.course_id = Enrollment.course_id
WHERE Enrollment.student_id = 1;
```

This would give all the courses that the student with `student_id = 1` (Alice) is
enrolled in.

2. **Find all students enrolled in a specific course**:

```sql
SELECT student_name
FROM Student
JOIN Enrollment ON Student.student_id = Enrollment.student_id
WHERE Enrollment.course_id = 101;
```

This would return all the students enrolled in the course with `course_id = 101`
(Math).

### Why Use a Many-to-Many Relationship?

- **Efficiency**: It avoids redundancy by allowing you to store data only once in

the `Student` and `Course` tables, with the `Enrollment` table linking them.
- **Flexibility**: A student can enroll in multiple courses without duplicating
student data, and a course can have multiple students without repeating course
data.
- **Normalization**: It maintains the integrity of the data model by keeping the
data normalized, minimizing data duplication and inconsistency.

### Many-to-Many in Object-Oriented Programming (OOP):

In OOP, a many-to-many relationship can be represented by using collections (such

as `List` or `Set`) within objects.

For example:
- A **Student** object can have a `List<Course>`.
- A **Course** object can have a `List<Student>`.

In this case, both objects have references to each other, indicating the many-to-
many relationship between them.

### Example in Java:

```java
public class Student {
private int studentId;
private String studentName;
private List<Course> courses; // Many-to-many relationship with Course

// getters and setters

}

public class Course {

private int courseId;
private String courseName;
private List<Student> students; // Many-to-many relationship with Student

// getters and setters

}
```

### Conclusion:
A **many-to-many** relationship is a connection where multiple records in one table
can relate to multiple records in another table. It is typically modeled with a
**junction table** or **associative table**. This kind of relationship is
fundamental in many real-world applications, such as social media platforms (users
and posts), e-commerce systems (products and orders), and educational systems
(students and courses).
===============================
In Java, both `matches()` and `contains()` methods are used for string comparison,
but they have different purposes and behaviors.

### `String.matches()`:
The `matches()` method is used to check if a string fully matches a given regular
expression pattern.

#### Syntax:
```java
boolean matches(String regex)
```
- **Returns**: `true` if the entire string matches the given regular expression,
otherwise `false`.

#### Behavior:
- The `matches()` method checks if the entire string conforms to the pattern
defined by the regular expression.
- It doesn't just check for substring matches; it checks the whole string.

#### Use Case:

Use `matches()` when you need to validate if the entire string follows a specific
pattern (such as checking if a string is a valid email address or phone number).

#### Example:
```java
public class MatchesExample {
public static void main(String[] args) {
String str1 = "hello123";
String str2 = "hello1234";

// Check if the string matches a specific pattern (only alphanumeric

characters allowed)
System.out.println(str1.matches("[a-zA-Z0-9]+")); // true
System.out.println(str2.matches("[a-zA-Z0-9]+")); // true
}
}
```
In this case, both strings `str1` and `str2` match the pattern `[a-zA-Z0-9]+`,
which allows only letters and numbers.

### `String.contains()`:
The `contains()` method checks if a string contains a specific sequence of
characters (substring). It is **not based on regular expressions** but is a simpler
search.

#### Syntax:
```java
boolean contains(CharSequence sequence)
```
- **Returns**: `true` if the sequence of characters (substring) is found anywhere
in the string, otherwise `false`.

#### Behavior:
- `contains()` checks if the provided sequence of characters exists anywhere in the
string, regardless of whether the entire string matches.
- It is case-sensitive and checks for the substring anywhere in the string.

#### Use Case:

Use `contains()` when you need to check if a string contains a particular
substring, without requiring the entire string to match a specific pattern.

#### Example:
```java
public class ContainsExample {
public static void main(String[] args) {
String str1 = "hello123";
String str2 = "hello";

// Check if the string contains the substring "123"

System.out.println(str1.contains("123")); // true
System.out.println(str2.contains("123")); // false
}
}
```
Here, `str1.contains("123")` returns `true` because `"123"` is a substring of
`"hello123"`. The check is only looking for the presence of the substring, not a
complete match.

### Key Differences:

| Aspect | `matches()` | `contains()`

|
|--------------------|-------------------------------------|-----------------------
-----------------|
| **Functionality** | Checks if the entire string matches a regular expression |
Checks if a substring exists in the string |
| **Input** | Takes a regular expression pattern | Takes a sequence of
characters (substring) |
| **Return Value** | `true` if the string matches the regex, `false` otherwise |
`true` if the substring is found, `false` otherwise |
| **Use Case** | Used for pattern matching (e.g., validating format) | Used
for checking substring presence |
| **Example** | `str.matches("\\d{3}")` (matches a 3-digit number) |
`str.contains("hello")` (checks if "hello" is part of the string) |

### When to Use Which?

- **Use `matches()`** when you need to validate the **entire string** against a
specific **pattern** (such as checking the format of an email address, phone
number, etc.).

- Example: Verifying if a string is a valid email:

```java
String email = "[email protected]";
if (email.matches("[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}")) {
System.out.println("Valid email");
} else {
System.out.println("Invalid email");
}
```

- **Use `contains()`** when you want to check if a **substring** exists inside a

string, without worrying about the string matching a pattern.

- Example: Checking if a string contains a specific word:

```java
String sentence = "Java is great!";
if (sentence.contains("great")) {
System.out.println("Found 'great' in the sentence");
} else {
System.out.println("'great' not found");
}
```

### Conclusion:
- **`matches()`** is used for full pattern matching (using regular expressions) and
validates if the entire string conforms to the specified pattern.
- **`contains()`** is used to check if a substring exists within a string and is
simpler for checking presence without pattern matching.
====================================
The **Lifecycle of Inversion of Control (IoC)** refers to the phases through which
an IoC container (such as **Spring IoC container**) manages beans and their
dependencies during the execution of a Java application. In Spring, IoC is a
fundamental concept that means the control of object creation and dependency
management is inverted. Instead of the developer manually instantiating objects,
the Spring IoC container takes care of object creation, wiring, and lifecycle
management.

Below is an overview of the **lifecycle of a bean in IoC** (specifically in the

context of **Spring IoC** container):

### **1. Bean Instantiation**

The Spring container is responsible for creating beans. During the bean
instantiation phase:
- The Spring container reads the configuration (XML, annotations, Java-based
configuration).
- For each bean definition (usually defined in a configuration file or
annotations), Spring creates an instance of the bean using reflection.

### **2. Dependency Injection (DI)**

After instantiation, Spring injects the dependencies required by the bean:
- If the bean requires other beans (dependencies), Spring will resolve and inject
those dependencies into the bean.
- Dependency injection can be done through constructor injection, setter injection,
or field injection.

### **3. Initialization (Post-processing Beans)**

Before the bean is ready for use, some initialization logic may be performed:
- **BeanPostProcessors**: Spring allows custom operations through the
`BeanPostProcessor` interface. This interface has two methods:
- **`postProcessBeforeInitialization()`**: Invoked before the bean’s
initialization callback methods.
- **`postProcessAfterInitialization()`**: Invoked after the bean’s initialization
callback methods.
- **InitializingBean Interface**: If a bean implements the `InitializingBean`
interface, its `afterPropertiesSet()` method is called after dependency injection
is complete.
- **`@PostConstruct` Annotation**: If a bean has a method annotated with
`@PostConstruct`, it is executed after the bean is fully initialized.

### **4. Bean Usage**

Once the bean is initialized and its dependencies are injected, it is ready to be
used by the application. The bean is now in a fully functional state, and Spring
provides it to the application whenever required.

### **5. Destruction**

When the application context is destroyed or when the scope of the bean is over
(e.g., `@RequestScope`, `@SessionScope`, etc.), Spring will clean up the beans. The
destruction phase involves:
- **DisposableBean Interface**: If the bean implements `DisposableBean`, the
`destroy()` method will be called when the context is closed or the bean is
removed.
- **`@PreDestroy` Annotation**: If a bean has a method annotated with
`@PreDestroy`, it will be called before the bean is destroyed.
- **Custom Cleanup**: Any custom cleanup operations can be added by defining beans'
custom `destroy-method`.

---

### **Detailed Lifecycle Phases in Spring:**

1. **Bean Creation**
- When the Spring container starts (either at application startup or on demand),
the Spring IoC container loads the bean definitions and creates the beans.
 - For example, if a bean is defined in XML or through annotations, Spring will
instantiate it using reflection.

2. **Dependency Injection**
- After the bean is created, Spring will inject any dependencies into the bean.
The dependencies could be other beans that the bean requires.
- The injection can be done via:
- **Constructor Injection**
- **Setter Injection**
- **Field Injection**

3. **BeanPostProcessors**
- Spring provides a mechanism for users to intercept and customize bean
initialization through **BeanPostProcessors**.
- These are hooks that allow us to modify beans before and after their
initialization.
- Examples include logging, security checks, or modifying bean properties.

4. **Initialization**
- Spring invokes the bean's initialization logic.
- This can be done via:
- **InitializingBean's afterPropertiesSet()**
- **`@PostConstruct` annotated method**
- Custom initialization method defined in the bean configuration (e.g., `init-
method` in XML).
- Initialization involves setting properties and performing any business logic
to make the bean fully functional.

5. **Bean in Use**
- After initialization, the bean is ready to be used by the application. The IoC
container provides the fully initialized beans to the classes that need them.
- The bean can be injected and accessed by other components within the Spring
context.

6. **Bean Destruction**
- When the Spring container is being destroyed, the beans need to be cleaned up
properly.
- **DisposableBean's destroy() method** or the **`@PreDestroy`** annotated
method will be invoked.
- This is done to clean up any resources, close connections, or perform any
final clean-up work.

### **Visualizing the Lifecycle of a Spring Bean**:

1. **Bean Definition**: Defined in configuration (XML or Java config) or through

annotations.
2. **Instantiation**: Spring container creates the bean instance.
3. **Dependency Injection**: Spring injects dependencies into the bean (via
constructor, setter, or field injection).
4. **Post-processing**: `BeanPostProcessor` may modify the bean before/after
initialization.
5. **Initialization**: Calls `afterPropertiesSet()` (for `InitializingBean`),
`@PostConstruct`, or custom `init-method`.
6. **Bean Use**: The bean is used in the application.
7. **Destruction**: When the context is closed, calls `destroy()` (for
`DisposableBean`), `@PreDestroy`, or custom `destroy-method`.

---
### **Bean Scopes in Spring IoC Container**:

- **Singleton (Default Scope)**: Only one instance of the bean is created for the
entire Spring container.
- **Prototype**: A new instance of the bean is created every time it is requested.
- **Request**: A new instance is created for each HTTP request (used in web
applications).
- **Session**: A new instance is created for each HTTP session (used in web
applications).
- **Global Session**: A new instance is created for each global HTTP session (used
in portlet-based applications).

### **Spring Bean Lifecycle Example:**

Here’s an example of how the lifecycle of a Spring bean works:

```java
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.DisposableBean;

public class MyBean implements InitializingBean, DisposableBean {

private String message;

public void setMessage(String message) {

this.message = message;
}

// This method will be called after the bean properties are set
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("Bean Initialization Logic: " + message);
}

// This method will be called before the bean is destroyed

@Override
public void destroy() throws Exception {
System.out.println("Bean Destruction Logic: Cleaning up resources");
}
}
```

In the above example:

- `afterPropertiesSet()` is part of the **initialization phase**.
- `destroy()` is part of the **destruction phase**.

### **Bean Lifecycle Phases Recap**:

1. **Instantiation**: Spring creates the bean instance.

2. **Dependency Injection**: Dependencies are injected.
3. **Post-processing**: Custom post-processing hooks (BeanPostProcessor).
4. **Initialization**: Initialization logic (e.g., `afterPropertiesSet()`,
`@PostConstruct`).
5. **Usage**: Bean is in use throughout the application.
6. **Destruction**: Cleanup logic is invoked (e.g., `destroy()`, `@PreDestroy`).

By managing this lifecycle, the Spring IoC container ensures efficient creation,
management, and cleanup of beans, allowing you to focus on your application’s
business logic.
=====================================
Constructor injection is recommended in **dependency injection (DI)** for several
reasons, particularly in frameworks like **Spring**, as it offers a more robust and
maintainable approach compared to other forms of injection (such as setter
injection). Here's why **constructor injection** is preferred:

### 1. **Immutability and Finality**

- **Immutability**: Constructor injection ensures that all required dependencies
are provided at the time of bean instantiation, which promotes the **immutability**
of the object. Once the object is created, its dependencies cannot be changed
(since the fields are usually final), making the class more predictable and thread-
safe.
- **Final Fields**: Constructor injection can be used with `final` fields,
ensuring that once the dependencies are set, they cannot be modified later. This
enhances the integrity of the object.

```java
public class MyService {
private final MyRepository repository;

// Constructor injection ensures repository is set at creation and is

immutable
public MyService(MyRepository repository) {
this.repository = repository;
}

public void doSomething() {

// Use the repository
}
}
```

### 2. **Required Dependencies**

- **Clarity of Required Dependencies**: With constructor injection, you make it
clear **which dependencies** are required for the object to function. If a
dependency is missing or incorrect, the class won’t be able to instantiate,
preventing errors from propagating silently.
- **Enforced Valid State**: Since dependencies are required at the time of
instantiation, the object can’t be created in an invalid state. This helps in
avoiding issues that might arise if dependencies are set later using setters.

```java
public class MyService {
private final MyRepository repository;

// Constructor ensures the repository must be passed and is not null

public MyService(MyRepository repository) {
if (repository == null) {
throw new IllegalArgumentException("Repository cannot be null");
}
this.repository = repository;
}
}
```

### 3. **Testability**
- **Easier to Unit Test**: Constructor injection simplifies unit testing because
dependencies can be passed directly into the constructor during test setup. You can
easily mock or create test versions of the dependencies, making unit tests cleaner
and more predictable.
 - **Clearer Test Setup**: By requiring dependencies via the constructor, tests
must explicitly provide all required collaborators, improving the clarity of test
setup and reducing the chance of incorrect mock behavior or null-pointer
exceptions.

```java
@Test
public void testService() {
MyRepository mockRepo = mock(MyRepository.class);
MyService service = new MyService(mockRepo);
// Proceed with test
}
```

### 4. **No Need for Setters**

- **Avoids Setter Methods**: Constructor injection doesn't rely on setter
methods. This can avoid accidental setter calls that might change the internal
state of an object after it’s been created. This leads to more predictable behavior
and reduces the potential for errors due to incorrect or incomplete initialization.
- **Cleaner Code**: Setter injection requires extra code for each dependency,
while constructor injection keeps the class compact and clear about what it needs.

### 5. **Promotes Strong Dependency Contract**

- **Mandatory Dependencies**: Constructor injection forces developers to declare
**mandatory dependencies** clearly. It’s impossible to create the object without
providing all required dependencies, which helps avoid runtime errors caused by
uninitialized fields.
- **Encourages Good Design**: By using constructor injection, you’re making
dependencies explicit and clearly defining the object’s required state. This often
leads to better overall class design where dependencies are well understood and
managed.

### 6. **Supports Dependency Injection Frameworks**

- **Works Well with Spring IoC Container**: Constructor injection is widely
supported and encouraged by frameworks like **Spring**. Spring’s dependency
injection framework can easily handle constructor injection, making it easy to wire
dependencies automatically during bean instantiation. This leads to more concise
configuration (e.g., through annotations or XML).

```java
@Component
public class MyService {
private final MyRepository repository;

@Autowired
public MyService(MyRepository repository) {
this.repository = repository;
}
}
```

### 7. **Avoids Null Dependencies**

- **Null Dependency Risks**: With setter injection, there's a risk that some
dependencies might not be set, leading to `NullPointerException` or faulty behavior
when accessing them. Constructor injection ensures that all dependencies are
provided during object creation, minimizing this risk.
- **Cleaner Error Handling**: If something goes wrong, constructor injection can
trigger an exception during the creation of the object (e.g., via
`IllegalArgumentException` or `BeanInstantiationException`), while setter injection
may allow for incomplete or invalid objects to exist.

### 8. **Reduces Complexity in Complex Applications**

- **Clearer Dependency Graph**: In larger applications with multiple layers or
components, constructor injection helps to clearly define the dependencies between
components. This makes it easier to track dependencies and understand the flow of
data.
- **No Need for Setter Calls**: In complex applications with multiple
dependencies, setter injection can lead to "setter explosion," where many setter
methods are required. Constructor injection reduces this complexity by
consolidating all dependencies into a single step during object creation.

---

### **Comparison with Setter Injection**:

| **Aspect** | **Constructor Injection**

| **Setter Injection** |
|-------------------------|--------------------------------------------------------
-------|---------------------------------------------------------------|
| **Required Dependencies**| All required dependencies must be provided at
instantiation. | Dependencies can be provided later via setter methods. |
| **Immutability** | Encourages immutable objects (fields can be `final`).
| No enforced immutability. |
| **Object Integrity** | Bean is always in a valid state (all dependencies are
injected). | Possible for objects to be in an invalid or incomplete state. |
| **Testability** | Easier to test (dependencies passed through
constructor). | Requires more boilerplate for testing (setter invocations).
|
| **Flexibility** | Less flexible (all dependencies must be provided at
once). | More flexible (dependencies can be set or changed later). |

---

### **When to Use Constructor Injection**:

- **Always prefer constructor injection for mandatory dependencies**.
- **When immutability is important** (i.e., the object's state should not change
after initialization).
- **When the object has many required dependencies**, as constructor injection
makes it explicit which dependencies are needed.

### **When to Use Setter Injection**:

- If dependencies are **optional** or **can be changed later** (e.g., when setting
properties that may change during the object's lifecycle).
- When you need to **configure some dependencies dynamically**.

### **Summary**:
Constructor injection is considered best practice because it ensures that all
dependencies are available at the time of object creation, improves immutability,
and makes code easier to test and maintain. By enforcing required dependencies
upfront, it reduces the risk of incorrect or incomplete object creation and helps
maintain better design and reliability in your code.
=============================