FileInputStream is used to read data from a file byte by byte. It is used for reading binary data like images, audio, etc.
FileInputStream fis = new FileInputStream("input.txt");
int data = fis.read();
fis.close();

FileOutputStream is used to write data to a file byte by byte. It is used for writing binary data.
FileOutputStream fos = new FileOutputStream("output.txt");
fos.write(65);
fos.close();

An exception in Java is an unexpected event that disrupts the normal flow of a program, like dividing by zero, accessing a null object, or going out of array bounds.

To handle exceptions, we use try, catch, throws, throwable, and finally blocks in Java.

Code:
try {
     int result = 10 / 0;
} catch (Exception e) {
    System.out.println("Cannot divide by zero");
} finally {
    System.out.println("This always runs");
}

Multithreading in Java is the ability of a program to execute multiple threads simultaneously or in parallel. Each thread runs independently, allowing concurrent execution of tasks.

Improving Performance:
- Better CPU utilization: Threads can run in parallel on multiple cores.
- Faster Execution: Tasks like downloading, file processing, or UI updates can run at the same time.
- Keeps programs like GUI apps smooth and responsive.

Garbage collection in Java is the process of automatically freeing memory by destroying objects that are no longer used. Java uses a garbage collector to manage memory. We don't need to manually delete objects. It helps prevent memory leaks and improves performance.

Example:
MyObject obj = new MyObject();
obj = null;

Synchronized Method:
- Locks the entire method.
- Applied to 'this' object.
- Slower because it locks the whole method, even if not necessary.
- Less flexible.

Synchronized Block:
- Locks a specific block of code.
- Can lock any specific object.
- More efficient and faster.

Garbage collection in Java automatically clears unused objects, helping manage memory efficiently.

Example:
MyObject obj = new MyObject();
obj = null;

It helps prevent memory leaks and improve performance.

In Java, the JVM manages memory allocation for objects on the heap. The garbage collector plays a crucial role in reclaiming memory occupied by unused objects, preventing memory leaks.

Heap Memory Allocation:
- Java uses a heap, a region of memory for dynamic allocation of objects.
- When you create an object in Java, the JVM allocates memory for it on the heap.
- Objects stored in the heap are globally accessible, meaning they can be referenced from anywhere in the application.

JDBC:
- Low-level API.
- Manual SQL writing, result set handling.
- Fast but error-prone.
- Manual transaction management.

Hibernate:
- High-level ORM (Object Relational Mapping tool).
- Automatically maps Java objects to DB tables.
- Requires less code.
- Slightly slower but efficient and safer.

In Java, a thread pool is a mechanism that manages a group of worker threads, reusing them instead of creating new ones for each task. This improves performance in concurrent applications by reducing overhead and resource consumption.