Deep Copy of 2D Array in Java - Coding

In Java, performing a deep copy of a 2D array containing objects requires careful consideration to ensure independence between the original and copied arrays. By creating new instances of objects for each element in the array, developers can achieve a true deep copy, preventing unintended side effects due to shared references.

In this article, we will learn to create a deep copy of a 2D array in Java.

Illustration of Shallow Copy Vs Deep Copy

Consider a 2D array ‘originalArray‘ containing objects

Original Array : [[obj1, obj2] , [obj3], [obj4]]

Copy Type	Description	Example
Shallow Copy	Both arrays share references to the same objects	Shallow Copied Array : [[obj1, obj2] , [obj3], [obj4]]
Deep Copy	New instances of objects are created.	Deep copied array : [[newObj1, newObj2] , [newObj3], [newObj4]]

Java Program to Create Deep Copy of a 2D Array

Below is the implementation of the topic:

Java

// Java Program for Deep Copy of 2D Array 
public class DeepCopy2DArray { 
    // A simple class for illustration purposes 
    static class MyClass { 
        int value; 
  
        MyClass(int value) { 
            this.value = value; 
        } 
    } 
  
    public static void main(String[] args) { 
        // Create the original 2D array with objects 
        MyClass[][] originalArray = { 
            {new MyClass(1), new MyClass(2)}, 
            {new MyClass(3), new MyClass(4)} 
        }; 
  
        // Perform the deep copy 
        MyClass[][] deepCopiedArray = deepCopy2DArray(originalArray); 
  
        // Modify an element in the original array to demonstrate independence 
        originalArray[0][0].value = 99; 
  
        // Display the original and deep copied arrays 
        System.out.println("Original Array:"); 
        print2DArray(originalArray); 
  
        System.out.println("\nDeep Copied Array:"); 
        print2DArray(deepCopiedArray); 
    } 
  
    // Method to perform a deep copy of a 2D array with objects 
    private static MyClass[][] deepCopy2DArray(MyClass[][] originalArray) { 
        int rows = originalArray.length; 
        int cols = originalArray[0].length; 
  
        MyClass[][] copiedArray = new MyClass[rows][cols]; 
  
        for (int i = 0; i < rows; i++) { 
            for (int j = 0; j < cols; j++) { 
                // Create a new instance of the object for each element 
                copiedArray[i][j] = new MyClass(originalArray[i][j].value); 
            } 
        } 
  
        return copiedArray; 
    } 
  
    // Method to print a 2D array with objects 
    private static void print2DArray(MyClass[][] array) { 
        for (MyClass[] row : array) { 
            for (MyClass element : row) { 
                System.out.print(element.value + " "); 
            } 
            System.out.println(); 
        } 
    } 
}

Output

Original Array:
99 2 
3 4 

Deep Copied Array:
1 2 
3 4

Explanation of the above Program:

Create the Original 2D Array : We create a 2D array originalArray containing objects of the MyClass class.
Perform the Deep Copy : The deepCopy2DArray method is implemented to create a new array and instantiate new objects for each element, ensuring a deep copy.
Modify an Element in the Original Array : To demonstrate the independence of the deep copied array, we modify an element in the original array after the deep copy operation.
Display the Arrays : We print both the original and deep copied arrays to observe the effect of the modification.

Reffered: https://www.geeksforgeeks.org

Java

Related
Count a Group of Words in a String Using Regex in Java
Duck Number Java
How to Extract File Extension From a File Path String in Java?
Java Program to Shuffle Characters in a String Without Using Shuffle()
How to Declare an ArrayList with Values in Java?

Type:	Geek
Category:	Coding
Sub Category:	Tutorial
Uploaded by:	Admin
Views:	14