Java Assignment 2

Q1. Difference between 2D Array and Jagged Array.

In Java, both 2D arrays and jagged arrays are used to represent tables of data, but they have
some key differences in terms of memory allocation and flexibility.

2D Array:

A 2D array in Java is a matrix with rows and columns. It is a fixed-size structure where each
row has the same number of columns.

Declaration and Initialization:

// Declaration and initialization of a 2D array

int[][] twoDArray = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};

Accessing Elements:

int value = twoDArray[rowIndex][colIndex];

Features:
- Rectangular structure with a fixed number of rows and columns.
- Memory is allocated in a contiguous block.
- All rows have the same length.

Jagged Array:

A jagged array, also known as an array of arrays, is an array whose elements are arrays.
Unlike a 2D array, a jagged array allows each row to have a different length.

Declaration and Initialization:

// Declaration and initialization of a jagged array

int[][] jaggedArray = {
{1, 2, 3},
{4, 5},
{6, 7, 8, 9}
};

Accessing Elements:
 int value = jaggedArray[rowIndex][colIndex];

Features:
- Irregular structure where different rows can have different lengths.
- Memory is allocated in a non-contiguous manner.
- Rows can have varying lengths.

Differences:

2D Arrays Jagged Arrays

Memory is allocated in a contiguous block, Memory is allocated in a non-contiguous
with all rows of same length manner, each row can have a different length
More rigid in structure as all rows have More flexible as rows can have varying
same length lengths
Declared with a fixed number of rows and Declared as an array of arrays, each sub-
columns array can have different length

Example:

// 2D array
int[][] twoDArray = new int[3][3];

// Jagged array
int[][] jaggedArray = {
{1, 2, 3},
{4, 5},
{6, 7, 8, 9}
};

In summary, the main distinction lies in the fixed vs. variable row length. 2D arrays are
suitable when you have a regular grid of data, while jagged arrays provide more flexibility
when dealing with irregular or dynamically changing row lengths.

Q2. Explain lifecycle of Multithreading in Java.

The lifecycle of multithreading in Java refers to the various stages that a thread goes through
from its creation to its termination. In Java, multithreading is implemented using the
`Thread` class or the `Runnable` interface. Here are the key stages in the lifecycle of a
thread:

1. New (Creation):
- A thread is in the "New" state when an instance of the `Thread` class or an object that
implements the `Runnable` interface is created.
- The `Thread` object is created, but the `start()` method has not been called yet.

2. Runnable (Ready-to-Run):
- Once the `start()` method is called on the `Thread` object, it transitions to the "Runnable"
state.
- In this state, the thread is ready to run, but the operating system or the Java Virtual
Machine (JVM) scheduler has not selected it for execution.

3. Running:
- The thread moves from the "Runnable" state to the "Running" state when the operating
system or JVM scheduler selects it for execution.
- The `run()` method of the thread is executed.

4. Blocked (Waiting for a Monitor Lock):

- A thread enters the "Blocked" state when it is waiting for a monitor lock to enter a
synchronized block or method.
- It can also be in this state when waiting for some external event, such as I/O operations
or the completion of another thread.

5. Waiting (Thread Awaits Another Thread):

- A thread enters the "Waiting" state when it is waiting indefinitely for another thread to
perform a specific action.
- This state occurs, for example, when a thread calls `Object.wait()` without a timeout or
when it waits for a condition variable.

6. Timed Waiting:
- Similar to the "Waiting" state, but with a specified timeout. A thread is in the "Timed
Waiting" state when it calls methods like `Thread.sleep(long millis)` or `Object.wait(long
millis)`.

7. Terminated (Dead):
- A thread is in the "Terminated" state when its `run()` method completes, or when the
`stop()` method is called (though it's deprecated and not recommended).
- A thread can also enter the "Terminated" state due to an unhandled exception.

Thread States Transition:

Here is a simplified visualization of thread states and transitions:

 New -> Runnable -> Running -> [Blocked, Waiting, Timed Waiting] -> Terminated

Example Code:

class MyThread extends Thread {

public void run() {
// Code to be executed by the thread
}
}

public class ThreadLifecycleExample {

public static void main(String[] args) {
MyThread myThread = new MyThread();

// New state
myThread.start(); // Runnable state

// Running state
// ...

// Terminated state (after run() completes)

}
}

Understanding the lifecycle of a thread is crucial for proper synchronization, coordination,

and resource management in multithreaded Java applications. Developers must be aware of
potential issues like race conditions and deadlocks and use synchronization mechanisms to
ensure thread safety.

Q3. Explain exception handling in detail

Exception handling in Java is a mechanism that allows you to handle errors and exceptional
situations gracefully, preventing the program from terminating abruptly. Java provides a
robust exception-handling model through the use of `try`, `catch`, `finally`, `throw`, and
`throws` keywords.

1. Try-Catch Blocks:

The basic structure of exception handling involves using `try` to enclose the code that might
raise an exception and `catch` to handle the exception if it occurs.

try {
// Code that may raise an exception
} catch (ExceptionType1 e1) {
// Handle ExceptionType1
} catch (ExceptionType2 e2) {
 // Handle ExceptionType2
} finally {
// Code that always runs (optional)
}

- The code inside the `try` block is monitored for exceptions.

- If an exception occurs, the corresponding `catch` block is executed based on the type of the
exception.
- Multiple `catch` blocks can be used to handle different types of exceptions.
- The `finally` block (optional) contains code that is guaranteed to execute, whether an
exception occurs or not.

2. Throw and Throws:

- `throw`: Used to manually throw an exception.

throw new ExceptionType("Custom error message");

- `throws`: Used in method signature to declare that the method might throw a particular
type of exception.

void myMethod() throws SomeException {

// Method code
}

3. Exception Hierarchy:

- All exceptions in Java are subclasses of the `Throwable` class.

- Exceptions are divided into two categories:

- Checked Exceptions: Checked at compile-time. Examples include `IOException` and

`SQLException`. They must be either caught using `try-catch` or declared in the method
signature using `throws`.

- Unchecked Exceptions (Runtime Exceptions): Not checked at compile-time. Examples

include `NullPointerException` and `ArrayIndexOutOfBoundsException`.

4. Custom Exceptions:
You can create your own exception classes by extending existing exception classes or the
`Exception` class.

class MyCustomException extends Exception {

// Constructors and additional code
}

Example:
 import java.io.IOException;

public class ExceptionHandlingExample {

public static void main(String[] args) {
try {
int result = divide(10, 0);
System.out.println("Result: " + result);
} catch (ArithmeticException e) {
System.err.println("Error: " + e.getMessage());
} finally {
System.out.println("Finally block always executes.");
}
}

static int divide(int num, int denom) throws ArithmeticException {

if (denom == 0) {
throw new ArithmeticException("Division by zero");
}
return num / denom;
}
}

In this example:
- The `divide` method throws an `ArithmeticException` if the denominator is zero.
- The `main` method catches this exception and prints an error message.
- The `finally` block always executes, providing a place for cleanup code.

Exception handling is essential for writing robust and fault-tolerant Java applications. It helps
prevent unexpected program termination and allows developers to handle errors in a
controlled and graceful manner.