java copyOf() copyOfRange()
0x00 概述
copyOf()和copyOfRange()方法都是Arrays类的静态方法，都是用来复制数组的。
0x01 copyOf()
copyOf()方法的说明：
/*
public static <T> T[] copyOf(T[] original, int newLength)
方法说明：
属于Arrays类的静态方法，可以通过类名直接调用，作用是复制指定长度的数组
参数说明：
T[] original 泛型，指的是要传入的源数组，即会被复制的数组，可以是String[]，Integer[]等，有多个重载方法
int newLength 整型，指的是要复制的长度，也是新数组的长度
1.如果newLength不合法，即小于0，那么抛出NegativeArraySizeException异常
2.如果newLength小于源数组长度，则复制指定长度的数组元素
3.如果newLength大于源数组长度，则新数组中超出源数组长度的元素则是默认值
返回值说明：
T[] 返回的是一个泛型，指的是复制成功的结果数组
*/
有多个重载方法，能够复制各种类型的数组：
示例如下：
public class Demo {
public static void main(String[] args) {
String[] originArr = new String[]{"唐僧", "孙悟空", "猪八戒", "沙僧"};
// 1.当输入的newLength小于0（不合法）时，抛出java.lang.NegativeArraySizeException异常
// String[] newArr1 = Arrays.copyOf(originArr, -2);
// printArr(newArr1);
// 2.当输入的newLength小于源数组长度时
String[] newArr2 = Arrays.copyOf(originArr, 3);
printArr(newArr2);
// 3.当输入的newLength大于源数组长度时，新数组没有填充的元素是默认值
String[] newArr3 = Arrays.copyOf(originArr, 6);
printArr(newArr3);
}
static void printArr(String[] arr) {
for (String s : arr) {
System.out.print(s + "\t");
}
System.out.println();
}
}
/**
* 打印结果：
* 唐僧 孙悟空 猪八戒
* 唐僧 孙悟空 猪八戒 沙僧 null null
*/注意：copyOf()的复制是从索引为0的元素开始的。
0x02 copyOfRange()
/*
public static <T> T[] copyOfRange(T[] original, int from, int to)
方法说明：
属于Arrays类的静态方法，可以通过类名直接调用，作用是复制指定开始索引到结束索引的数组，注意，复制的数组元素是[from,to)，即包括from的索引，但不包括to索引对应的元素
参数说明：
T[] original 泛型，指的是要传入的源数组，即会被复制的数组，可以是String[]，Integer[]等，有多个重载方法
int from 开始索引，复制的元素包括original[from]
int to 结束索引，复制的元素但不包括original[to]
返回值说明：
T[] 返回的是一个泛型，指的是复制成功的结果数组
*/
有多个重载方法，可以复制各种类型的数组。
示例：
public class Demo {
public static void main(String[] args) {
String[] originArr = new String[]{"唐僧", "孙悟空", "猪八戒", "沙僧"};
String[] newArr = Arrays.copyOfRange(originArr, 1, 3);
printArr(newArr);
}
static void printArr(String[] arr) {
for (String s : arr) {
System.out.print(s + "\t");
}
System.out.println();
}
}
/**
* 打印结果：
* 孙悟空 猪八戒
*/演示代码1：
package niuke;
import java.util.Arrays;
public class Solution {
public static void main(String[] args) {
int[] n=new int[]{1};//Java中数组初始化
int[] m=Arrays.copyOfRange(n, 0, 5);
for(int i=0;i<m.length;i++) {
System.out.print(m[i]+" ");
}
}
}
运行结果：
Arrays.copyOfRange(n, 0, 5);意思是返回一个长度为to-from即5-0=5的数组，从n数组下标0开始复制，由于n数组只有一个元素，故复制一个就没有可以复制的，剩下的4个元素默认为0。
演示代码2：
package niuke;
import java.util.Arrays;
public class Solution {
public static void main(String[] args) {
int[] n=new int[]{1,2,3,4,5};//Java中数组初始化
int[] m=Arrays.copyOfRange(n, 0, 3);
for(int i=0;i<m.length;i++) {
System.out.print(m[i]+" ");
}
}
}
运行结果：
Arrays.copyOfRange(n, 0, 3);的意思是返回一个长的为3-0=3的数组，从n数组0开始复制，由于数组n的长度大于3，因此直接从n数组0下标开始复制3个元素返回即可。
演示代码3：
package niuke;
import java.util.Arrays;
public class Solution {
public static void main(String[] args) {
int[] n=new int[]{1};//Java中数组初始化
int[] m=Arrays.copyOfRange(n, 1, 3);
for(int i=0;i<m.length;i++) {
System.out.print(m[i]+" ");
}
}
}
运行结果：
n数组没有可以复制的，所以m数组全为0。
package niuke;
import java.util.Arrays;
public class Solution {
public static void main(String[] args) {
int[] n=new int[]{1};//Java中数组初始化
int[] m=Arrays.copyOfRange(n, 1, 1);
for(int i=0;i<m.length;i++) {
System.out.print(m[i]+" ");
}
}
}
该运行没有任何输出，因为它返回的是一个长度为1-1=0的数组。
演示代码4：
长度为0的数组是存在的，只是输出啥也没有。
package niuke;
public class Solution {
public static void main(String[] args) {
int[] n=new int[]{};
int[] m=new int[0];
for(int i=0;i<n.length;i++) {
System.out.print(n[i]+" ");
}
for(int i=0;i<m.length;i++) {
System.out.print(m[i]+" ");
}
}
}
演示代码5：
package niuke;
import java.util.Arrays;
public class Solution {
public static void main(String[] args) {
int[] n=new int[]{1};//Java中数组初始化
int[] m=Arrays.copyOfRange(n, 1, 0);
for(int i=0;i<m.length;i++) {
System.out.print(m[i]+" ");
}
}
}
运行结果： 会抛出异常，因为不存在长度为0-1=-1的数组。
演示代码6：
package niuke;
import java.util.Arrays;
public class Solution {
public static void main(String[] args) {
int[] n=new int[]{1};//Java中数组初始化
int[] m=Arrays.copyOfRange(n, 2, 3);
for(int i=0;i<m.length;i++) {
System.out.print(m[i]+" ");
}
}
}
运行结果：
抛出数组越界异常。根据copyOfRange(original,int from,int to)该方法返回一个长度为to-from的数组，其中from~min(original.length-to,to)之间的元素（不包括min(original.length-to,to)）是从数组original复制的元素，剩下的值为0。
此时min(original.length-to,to)=min(1-2,3)=min(-1,3)=-1，下标为-1是非法的。
0x03 源码解析
copyOf()方法的源码如下：
在该方法内做了三件事：
- 创建一个数组，该数组是复制的结果数组。
- 调用System类的arraycopy()方法复制数组，注意其实索引都是0，表示从第一个元素开始复制。
- 返回复制完成的数组。
copyOfRange()方法的源码如下：
在该方法内做了四件事：
- 计算新数组的长度，由于指定了开始索引和结束索引，所以新数组的长度是可以计算的。
- 创建一个数组，该数组用来存放复制的元素。
- 调用System.arraycopy()方法来复制数组，注意srcPos参数的值变为了from，即源数组的起始索引，而复制的结果数组当然是从索引为0的位置开始填充元素。
- 返回复制完成的结果数组。
0x04 System.arraycopy()方法
发现copyOf()和copyOfRange()方法的底层都是调用System.arraycopy()方法完成的。
System.arraycopy()方法说明：
/*
public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length);
方法说明：
属于System类的静态方法，可以通过类名直接调用，作用是复制从指定索引开始的指定长度的数组
参数说明：
Object src 源数组，可以是任何类型的
int srcPos 源数组的起始索引，即要复制的源数组的开始位置，结束位置通过长度来锁定
Object dest 目标数组，也就是复制的结果数组
int destPos 目标数组的起始位置，一般从0开始，也可以是其他索引
int length 要复制的元素个数
注意事项：
1.该方法被native修饰，表示底层使用C或C++实现的，不属于Java范畴
*/
示例：
public class Demo {
public static void main(String[] args) {
// 源数组
String[] originArr = new String[]{"唐僧", "孙悟空", "猪八戒", "沙僧"};
// 目标数组
String[] descArr = new String[4];
descArr[0] = "小白龙";
// 调用方法，复制源数组从索引为1的位置开始的2个元素，然后复制到目标数组从索引1开始的两个元素
System.arraycopy(originArr, 1, descArr, 1, 2);
// 打印目标数组
printArr(descArr);
}
static void printArr(String[] arr) {
for (String s : arr) {
System.out.print(s + "\t");
}
System.out.println();
}
}
/**
* 打印结果：
* 小白龙 孙悟空 猪八戒 null
*/System.arraycopy()方法的源码：
没有任何实现的方法体，使用了native修饰方法，表示底层使用C或C++实现，不属于Java范畴，不关注。
0x05 总结
0x06 参考
参考1
参考2