How does the Arrays.copyOf() method in Java copy an array to a new array?
In Java, arrays are a very common data structure, and Java's Arrays class provides us with many convenient methods to handle arrays. Among them, the Arrays.copyOf() method is a very useful method for copying an array to a new array. This article will introduce the use and implementation principle of this method, and provide specific code examples.
Usage method
The Arrays.copyOf() method has two parameters: the original array and the length of the new array after copying. This method creates a new array and copies the elements from the original array to the new array. If the length of the original array is greater than or equal to the length of the new array, the front part of the original array is copied. If the length of the original array is less than the length of the new array, all elements of the original array are copied to the new array, and the remaining elements are filled with the default value of the array element type.
The following is an example of calling the Arrays.copyOf() method:
int[] arr1 = {1, 2, 3, 4, 5};
int[] arr2 = Arrays.copyOf(arr1, 3);
In this example, we create an integer array arr1 containing 5 elements. We call the Arrays.copyOf() method to copy arr1 to another array named arr2 and set the length of arr2 to 3. Since the length of array arr1 is 5 and the length of arr2 is 3, the Arrays.copyOf() method only copies the first 3 elements of arr1 to arr2. As a result, arr2 now contains {1, 2, 3}.
This is just the most basic example of using the Arrays.copyOf() method. Next, we'll look at some more complex usage and examples.
Copy two-dimensional array
The Arrays.copyOf() method is not only suitable for one-dimensional arrays, it can also be used to copy two-dimensional arrays. In the following example, we create a two-dimensional integer array named matrix1 and copy it to another array named matrix2 using the Arrays.copyOf() method:
int[][] matrix1 = {{1, 2, 3}, {4, 5, 6}};
int[][] matrix2 = Arrays.copyOf(matrix1, 2);
In this example, We copy matrix1 to matrix2 and set the length of matrix2 to 2. Since matrix1 is a two-dimensional array, and the Arrays.copyOf() method can only copy a one-dimensional array, we create a new two-dimensional array with a length of 2 and its first element is the first element of matrix1 row, its second element is the second row of matrix1. In this way we can copy one 2D array into another array.
Copy a specific range of array
In some cases, we may only want to copy a specific range of elements from the original array. The Arrays.copyOfRange() method is a very useful method that allows us to specify which index in the original array to start copying and end at which index. The following is an example of the Arrays.copyOfRange() method:
int[] arr1 = {1, 2, 3, 4, 5};
int[] arr2 = Arrays.copyOfRange(arr1, 1 , 4);
In this example, we create an integer array named arr1, which contains 5 elements. We call the Arrays.copyOfRange() method and assign it to arr2. We pass arr1 as the first parameter to the method and 1 and 4 as the second and third parameters. This means that we only want to copy starting from index 1 of arr1 (i.e. second element) up to index 4 (i.e. fifth element), not including index 4. As a result, arr2 now contains {2, 3, 4}.
Since the Arrays.copyOfRange() method only copies a part of the original array, we can copy a specific range of elements from the original array in this way.
Implementation principle
The Arrays.copyOf() method is actually a simplified implementation of the System.arraycopy() method. System.arraycopy() method is one of the fastest methods in Java for copying elements between arrays and has higher flexibility and performance than Arrays.copyOf() method. In addition, the System.arraycopy() method is also the basic implementation method of the Arrays.copyOf() method.
The following is the source code implementation of the Arrays.copyOf() method:
public static
return (T[]) copyOf(original, newLength, original.getClass());
}
public static
@SuppressWarnings("unchecked") T[] copy = ((Object)newType == (Object)Object[].class) ? (T[]) new Object[newLength] : (T[]) Array.newInstance(newType.getComponentType(), newLength); System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength)); return copy;
}
It can be seen from the code implementation that the first line of the Arrays.copyOf() method calls an overloaded version of the copyOf() method and returns the result returned by the method to the caller. This method accepts an original array and the length of the new array as arguments and passes them to the second copyOf() method.
The second copyOf() method performs the following steps to create a new array and copy elements:
Since the implementation of the Arrays.copyOf() method relies on the System.arraycopy() method, it follows the rules and restrictions of this method, such as not copying arrays that span two different types.
Summary
The Arrays.copyOf() method is a convenient way to copy an array in Java. It can quickly create a new array and copy the elements of the original array to the new array. This method can be used to copy one- and two-dimensional arrays, as well as copy a specific range of elements. The implementation of the Arrays.copyOf() method is based on the System.arraycopy() method, so it has the same rules and restrictions. When dealing with arrays, the Arrays class is a very useful tool that can help us handle and manipulate arrays more easily.
The above is the detailed content of How does the Arrays.copyOf() method in Java copy an array into a new array?. For more information, please follow other related articles on the PHP Chinese website!
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
