What is object cloning, arrays, and two-dimensional arrays, and how is it used?

Cloning allows creating a copy of an object.

• Shallow cloning: The object itself is copied, but reference fields point to the same objects as in the original. Changes in one of the referenced objects will be visible in the other. Implemented by default using the Object.clone() method.

• Deep cloning: A complete copy of the object and all objects referenced by its fields is created. Changes in the copies do not affect the originals. Requires manual implementation or the use of libraries (e.g., Apache Commons Lang SerializationUtils.clone()).

For an object to be cloneable, its class must implement the Cloneable interface.

// Class supporting cloning
class MyObject implements Cloneable {
    private int value;
    private AnotherObject ref; // Reference field

    public MyObject(int value, AnotherObject ref) {
        this.value = value;
        this.ref = ref;
    }

    // Override clone() for deep cloning
    @Override
    public Object clone() throws CloneNotSupportedException {
        MyObject cloned = (MyObject) super.clone(); // Shallow clone
        cloned.ref = (AnotherObject) this.ref.clone(); // Clone referenced object
        return cloned;
    }

    // Getters and setters...
}

Arrays in Java are objects and can be cloned using the clone() method. For primitive arrays, this is always deep cloning. For object arrays, it is shallow.

// Cloning a primitive type array (deep)
int[] originalIntArray = {1, 2, 3};
int[] clonedIntArray = originalIntArray.clone();

// Cloning an object array (shallow)
MyObject[] originalObjectArray = {new MyObject(1, new AnotherObject()), new MyObject(2, new AnotherObject())};
MyObject[] clonedObjectArray = originalObjectArray.clone(); // Elements are the same objects

Two-dimensional arrays (arrays of arrays) are arrays of references to other arrays. Cloning a 2D array with clone() results in a shallow copy — the container array is copied, but inner arrays remain the same. For deep cloning, each inner array must be cloned separately.

// Cloning a 2D array (shallow)
int[][] original2DArray = {{1, 2}, {3, 4}};
int[][] cloned2DArray = original2DArray.clone(); // Shallow clone

// Deep cloning a 2D array
int[][] deepCloned2DArray = new int[original2DArray.length][];
for (int i = 0; i < original2DArray.length; i++) {
    deepCloned2DArray[i] = original2DArray[i].clone(); // Clone each inner array
}

Cloning is useful when an independent modification of the object copy is required without changing the original. For example, when working with mutable data in multithreaded environments, creating snapshots of object states, or implementing the Prototype pattern.