Q. Meaning the array is new but the elements in the array point to the same location as that of the original?? so if i access an element and mutate the element the element in the original array also gets affected?

That is accurate—this behavior is known as a shallow copy.

When you clone an array of objects in Java:

Mutating the object's internal state affects both arrays because both array slots point to the exact same object in memory.

Reassigning the reference at an array index affects only that array, because the array containers themselves are separate objects.

Q. so we can add new elements without the other knowing that's the main usecase of the clone

Yes, that is a primary use case—isolating the array structure and references so one array can be modified, reordered, or reassigned without affecting the other. This pattern is commonly known as defensive copying

Doesnot mean immutable: When you perform a "manipulation" on a String—such as .toUpperCase(), .concat(), or .replace()—Java never modifies the original String object. Instead, it generates and returns a brand-new String object containing the transformed text, leaving the original object completely untouched.

Characters

text and passwords

``` class Animal {} class Dog extends Animal {}

class Parent { Animal getAnimal() { return new Animal(); } }

class Child extends Parent { @Override Dog getAnimal() { // Covariant: Dog is a subclass of Animal return new Dog(); } } ```

``` import java.util.List; import java.util.ArrayList;

class DataProvider { List<String> fetchData() { return new ArrayList<>(); } }

class FastDataProvider extends DataProvider { @Override ArrayList<String> fetchData() { // Covariant: ArrayList implements List return new ArrayList<>(); } } ```

Primary Domain * Reading and writing raw bytes/characters to files, network sockets, or memory.

What "Filter" Means * Wraps/decorates an existing I/O stream to add features (e.g., buffering, primitive data parsing, or encryption).

Design Pattern * Decorator Pattern (wraps an underlying InputStream or OutputStream).

Example // FileInputStream provides raw byte reading. // BufferedInputStream (a FilterStream) wraps it to add buffer capabilities for speed. InputStream fileStream = new FileInputStream("data.txt"); InputStream bufferedStream = new BufferedInputStream(fileStream);