How can I create a true copy of a 2D array in Java without modifying the original array?

Copying 2 Dimensional Arrays in Java

When working with multidimensional arrays in Java, it is often necessary to create a copy of the array to avoid unexpected modifications to the original array. Creating a copy ensures that the original array remains untouched, while the copy can be freely modified without affecting the original.

Consider the following scenario where two 2D arrays, current and old, are declared and two helper methods are defined:

<code class="java">int[][] current;
int[][] old;

public void old() {
  old = current;
}

public void keepold() {
  current = old;
}</code>

When invoking old(), the reference to the current array is assigned to the old array. Similarly, when invoking keepold(), the reference to the old array is assigned to the current array. However, this simple assignment does not create a copy of the actual data. Instead, it merely shares the same references to the same underlying data.

This behavior can lead to confusion when updates are made to one of the arrays. For instance, if an update is made to current, and then keepold() is invoked, the current array will now reference the same data as old. As a result, any further modifications to old will also modify current, which is not the intended behavior.

To create a true copy of a 2D array in Java, a technique called deep copying must be employed. This involves creating a new 2D array and copying the contents of the original array into it, element by element. This can be achieved using a nested loop.

Alternatively, as of Java 8, the Streams API can be utilized to provide a more concise and efficient way of performing deep copying of multidimensional arrays:

<code class="java">int[][] copy = Arrays.stream(matrix).map(int[]::clone).toArray(int[][]::new);</code>

In this code, the Arrays.stream(matrix) creates a stream of the rows in the original array. The map(int[]::clone) operation creates a new array for each row using the clone() method. Finally, the toArray(int[][]::new) operation combines the cloned rows into a new 2D array. This resulting array is a true copy and can be modified without affecting the original array.

The above is the detailed content of How can I create a true copy of a 2D array in Java without modifying the original array?. For more information, please follow other related articles on the PHP Chinese website!