Java Arrays.copyOf 方法

Java Arrays.copyOf 方法是 Array Methods 之一，它用于将数组内容复制到用户指定长度的新数组中。本文将通过示例展示如何将一个数组复制到一个新数组。该编程语言中 Arrays.copyOf 的基本语法如下所示。

Java Arrays.copyOf 方法语法

该编程语言提供了九种不同的 Arrays copyof 方法，用于将指定数组复制到新数组。复制时

• 如果指定的长度大于原始数组，则其余元素将填充为数据类型的默认值。例如，一个整数类型的数组 a[5] 包含五个元素（1, 2, 3, 4, 5），但我们指定的新长度为 7（Arrays.copyOf(b, 7)），则 b 数组将变为 b[7]，包含元素 1, 2, 3, 4, 5, 0, 0（这里，0 是 int 类型的默认值）
• 如果指定的长度小于原始数组，则其余元素将被截断。例如，一个整数类型的数组 a[7] 包含五个元素（10, 15, 22, 45, 65, 3, 54），但我们指定的新长度为 4（Arrays.copyOf(b, 4)），则 b 数组将变为 b[4]，包含元素 10, 15, 22, 45。

以下 Java arrays copyof 方法将接受布尔数组和长度作为参数，并将其复制到一个用户指定长度的新数组中。

public static boolean copyOf(Boolean[] anBooleanArray, int newLength); // It will return Boolean Array

//In order to use in program
Arrays.copyOf(Boolean[] anBooleanArray, int newLength);

以下是其余的 arrays copyof 方法。

public static byte copyOf(byte[] anByteArray, int newLength); // It will return Byte Array
Arrays.copyOf(byte[] anByteArray, int newLength);

public static short copyOf(short[] anShortArray, int newLength); // It will return short Array
Arrays.copyOf(short[] anShortArray, int newLength);

public static char copyOf(char[] anCharArray, int newLength); // It will return char Array
Arrays.copyOf(char[] anCharArray, int newLength);

public static short copyOf(int[] anIntArray, int newLength); // It will return Integer Array
Arrays.copyOf(int[] anIntArray, int newLength);

public static long copyOf(long[] anLongArray, int newLength); // It will return Long Array
Arrays.copyOf(long[] anLongArray, int newLength);

public static double copyOf(double[] anDoubleArray, int newLength); // It will return Double Array
Arrays.copyOf(double[] anDoubleArray, int newLength);

public static float copyOf(float[] anFloatArray, int newLength); // It will return float Array
Arrays.copyOf(float[] anFloatArray, int newLength);

public static <T> T[] copyOf(T[] Array, int newLength); 
Arrays.copyOf(T[] Array, int newLength);

public static <T,U> T[] copyOf(U[] Array, int newLength, Class<? extends T[]> newType); 
Arrays.copyOf(T[] Array, int newLength, Class<? extends T[]> newType);

• Array：这是原始数组。我们将使用 copyOf 方法将其复制到一个新数组中。
• newlength：请指定新数组的长度。根据长度，元素会被截断或扩展（使用默认值）。
• newType：请指定您想为新数组应用的目标类类型。

Java Arrays.copyOf 复制字节数组

在此程序中，我们声明了一个包含随机元素的字节数组。然后，我们调用 public static byte copyOf (byte[] anByteArray, int newLength) 方法将字节数组复制到一个指定长度的新数组中。

package ArrayMethods;
import java.util.Arrays;
public class CopyOfBytes {
	public static void main(String[] args) {
		byte[] byteArray = {12, 24, 26}; 		
		//Copying Array
		byte[] bitArray = Arrays.copyOf(byteArray, 5);
		System.out.println("New Byte Array after Copying:");
		arrayPrint(bitArray);
		
		//Copying Array and assign Values
		byte[] btArray = Arrays.copyOf(byteArray, 5);
		btArray[3] = 5;
		btArray[4] = 19;
		System.out.println("New Byte Array with Vlaues:");
		arrayPrint(btArray);
	}
	public static void arrayPrint(byte[] anByteArray) {
		for (byte Number: anByteArray) {
			System.out.println("Array Elelment = " + Number);
		}
	}
}

在此示例中，我们使用此函数将上面指定的字节数组复制到长度为 5 的 bitArray 中。它将复制 byteArray 中的可用元素到 bitArray，并用默认值填充剩余的值。

byte[] bitArray = Arrays.copyOf(byteArray, 5);

以下 Java 语句用于将字节数组的元素打印到输出。

arrayPrint(byteArray);

下一行，我们使用 Java Arrays.copyOf 方法将上面指定的字节数组复制到长度为 5 的 btArray 中，并将新值赋给索引位置 3 和 4。这意味着这些值将替换默认值（零）。

byte[] btArray = Arrays.copyOf(byteArray, 5);
btArray[3] = 5;
btArray[4] = 19;

以下语句用于将字节 数组 的元素打印到输出。

arrayPrint(byteArray);

当编译器遇到上述语句时，编译器将跳转到以下函数。我们使用代码片段中的 Foreach 循环来迭代字节数组。然后，我们使用 System.out.println 语句打印每个元素。

public static void arrayPrint(byte[] anByteArray) {
	for (byte Number: anByteArray) {
		System.out.println("Array Elelment = " + Number);
	}
}

Java copyOf 复制布尔数组

在此程序中，我们声明了一个包含随机元素的布尔数组。然后，我们调用 public static Boolean copyOf (boolean[] anBooleanArray, int newLength) 方法将布尔数组复制到一个指定长度的新数组中。

package ArrayMethods;
import java.util.Arrays;

public class CopyOfBoolean {
	public static void main(String[] args) {
		boolean[] bool = {true, true};
		boolean[] boolArray =  Arrays.copyOf(bool, 4);
		System.out.println("New Boolean Array after Copying:");
		arrayPrint(boolArray);
		
		boolean[] bolArray =  Arrays.copyOf(bool, 4);
		bolArray[2] = false;
		bolArray[3] = true;
		System.out.println("New Boolean Array with Vlaues:");
		arrayPrint(bolArray);
	}
	public static void arrayPrint(boolean[] anBooleanArray) {
		for (boolean bool: anBooleanArray) {
			System.out.println("Array Elelment = " + bool);
		}
	}
}

New Boolean Array after Copying:
Array Elelment = true
Array Elelment = true
Array Elelment = false
Array Elelment = false
New Boolean Array with Vlaues:
Array Elelment = true
Array Elelment = true
Array Elelment = false
Array Elelment = true

Arrays.copyOf 复制短整型数组

在此方法程序中，我们声明了一个包含随机元素的短整型数组。然后，我们调用 public static Short copyOf (short[] anShortArray, int newLength) 方法将短整型数组复制到一个指定长度的新数组中。

package ArrayMethods;
import java.util.Arrays;
public class ShortCopyOf {
	public static void main(String[] args) {
		short[] srtArray = {2, 6, 4}; 		
		short[] ShortArray = Arrays.copyOf(srtArray, 5);
		System.out.println("New Short Array after Copying:");
		arrayPrint(ShortArray);
		
		short[] ShrtArray = Arrays.copyOf(srtArray, 5);
		ShrtArray[3] = 3;
		ShrtArray[4] = 9;
		System.out.println("New Short Array with Vlaues:");
		arrayPrint(ShrtArray);
	}
	public static void arrayPrint(short[] anShortArray) {
		for (short Number: anShortArray) {
			System.out.println(Number);
		}
	}
}

New Short Array after Copying:
2
6
4
0
0
New Short Array with Vlaues:
2
6
4
3
9

Java Arrays.copyOf 复制整型数组

在此程序中，我们声明了一个包含随机元素的整型数组。然后，我们调用 public static IntcopyOf (int[] anIntegerArray, int newLength) 方法将 Java 整型数组复制到一个指定长度的新数组中。

package ArrayMethods;
import java.util.Arrays;
public class CopyOfIntegers {
	public static void main(String[] args) {
		int[] intArray = {25, 45}; 		
		int[] integerArray = Arrays.copyOf(intArray, 5);
		System.out.println("New Integer Array after Copying:");
		arrayPrint(integerArray);
		
		int[] anIntArray = Arrays.copyOf(intArray, 5);
		anIntArray[2] = 65;
		anIntArray[4] = 75;
		System.out.println("New Integer Array with Vlaues:");
		arrayPrint(anIntArray);
	}
	public static void arrayPrint(int[] anIntArray) {
		for (int Number: anIntArray) {
			System.out.println(Number);
		}
	}
}

New Integer Array after Copying:
25
45
0
0
0
New Integer Array with Vlaues:
25
45
65
0
75

复制长整型数组

在此程序中，我们声明了一个包含随机元素的長整型数组。然后，我们调用 public static LongcopyOf (long[] anLongArray, int newLength) 方法将長整型数组复制到一个指定长度的新数组中。

package ArrayMethods;
import java.util.Arrays;

public class CopyOfLong {
	public static void main(String[] args) {
		long[] LngArray = {504, 405}; 		
		long[] longArray = Arrays.copyOf(LngArray, 5);
		System.out.println("New Long Array after Copying:");
		arrayPrint(longArray);
		
		long[] anLongArray = Arrays.copyOf(LngArray, 5);
		anLongArray[2] = 265;
		anLongArray[4] = 750;
		System.out.println("New Long Array with Vlaues:");
		arrayPrint(anLongArray);
	}
	public static void arrayPrint(long[] anLongArray) {
		for (long Number: anLongArray) {
			System.out.println(Number);
		}
	}
}

New Long Array after Copying:
504
405
0
0
0
New Long Array with Vlaues:
504
405
265
0
750

copyOf 双精度浮点型数组

在此程序中，我们声明了一个包含随机元素双精度浮点型数组。接下来，我们调用 public static Double copyOf (double[] anDoubleArray, int newLength) 来将双精度浮点型数组复制到一个新的数组中。

package ArrayMethods;
import java.util.Arrays;

public class CopyOfDouble {
	public static void main(String[] args) {
		double[] DoubArray = {64.542, 75.983}; 		
		double[] DoubleArray = Arrays.copyOf(DoubArray, 5);
		System.out.println("New Integer Array after Copying:");
		arrayPrint(DoubleArray);
		
		double[] dblArray = Arrays.copyOf(DoubArray, 4);
		dblArray[2] = 465.6054;
		dblArray[3] = 986.70534;
		System.out.println("New Integer Array with Vlaues:");
		arrayPrint(dblArray);
	}
	public static void arrayPrint(double[] anDoubleArray) {
		for (double Number: anDoubleArray) {
			System.out.println(Number);
		}
	}
}

New Integer Array after Copying:
64.542
75.983
0.0
0.0
0.0
New Integer Array with Vlaues:
64.542
75.983
465.6054
986.70534

Java Arrays.copyOf 复制单精度浮点型数组

在此 Java 程序中，我们声明了一个包含随机元素单精度浮点型数组。然后，我们调用 public static float copyOf (float[] anFloatArray, int newLength) 来将单精度浮点型数组复制到一个指定长度的新数组中。

package ArrayMethods;
import java.util.Arrays;

public class CopyOfFloat {
	public static void main(String[] args) {
		float[] floatArray = {4.54f, 7.98f, 5.68f, 3.25f, 6.95f}; 		
		float[] fltArray = Arrays.copyOf(floatArray, 2);
		System.out.println("New Float Array after Copying:");
		arrayPrint(fltArray);
		
		float[] ftArray = Arrays.copyOf(floatArray, 4);
		ftArray[0] = 12.56f;
		ftArray[3] = 22.56f;
		System.out.println("New Float Array with Changed Vlaues:");
		arrayPrint(ftArray);
	}
	public static void arrayPrint(float[] anfloatArray) {
		for (float Number: anfloatArray) {
			System.out.println(Number);
		}
	}
}

New Float Array after Copying:
4.54
7.98
New Float Array with Changed Vlaues:
12.56
7.98
5.68
22.56

Java copyOf 复制字符数组

在此程序中，我们声明了一个包含随机元素的字符数组。接下来，我们调用 public static Char copyof (char[] anCharacterArray, int newLength) 来将字符数组复制到一个指定长度的新字符数组中。

package ArrayMethods;
import java.util.Arrays;

public class CopyOfChar {
	public static void main(String[] args) {
		char[] CharArray = {'J', 'a', 'v', 'a'}; 
		char[] ChArray = Arrays.copyOf(CharArray, 5);
		System.out.println("New Character Array after Copying:");
		arrayPrint(ChArray);
		
		char[] ChrArray = Arrays.copyOf(CharArray, 6);
		ChrArray[4] = 'T';
		ChrArray[5] = 'G';
		System.out.println("New Character Array with Vlaues:");
		arrayPrint(ChrArray);
	}
	public static void arrayPrint(char[] anCharacterArray) {
		for (char Number: anCharacterArray) {
			System.out.println(Number);
		}
	}
}

New Character Array after Copying:
J
a
v
a

New Character Array with Vlaues:
J
a
v
a
T
G

复制对象数组

在此 copyof 程序中，我们声明了一个包含随机元素字符串数组。接下来，我们调用该方法将对象数组复制到一个指定长度的新数组中。

package ArrayMethods;
import java.util.Arrays;

public class CopyOfObject {
	public static void main(String[] args) {
		String[] stringArray = {"India", "USA"}; 
		String[] strArray = Arrays.copyOf(stringArray, 5);
		System.out.println("New Object Array after Copying:");
		arrayPrint(strArray);
		
		String[] strngArray = Arrays.copyOf(stringArray, 4);
		strngArray[2] = "Australia";
		strngArray[3] = "Japan";
		System.out.println("New Object Array with Values:");
		arrayPrint(strngArray);
	}
	public static void arrayPrint(Object[] anObjectArray) {
		for (Object Number: anObjectArray) {
			System.out.println(Number);
		}
	}
}

New Object Array after Copying:
India
USA
null
null
null
New Object Array with Values:
India
USA
Australia
Japan

将数组复制到用户指定类型

在此 Java 程序 中，我们声明了一个包含随机元素的对象数组。然后，我们将调用 public static <T, U> T[] copyOf (U[] anObjectArray, int newLength, , Class<? extends T[]> newType) 方法将 Java 对象数组复制到一个新的指定数组中。

package ArrayMethods;
import java.util.Arrays;

public class CopyOfT {
	public static void main(String[] args) {
		Object[] objectArray = {"Australia", "India"}; 
		String[] objArray = Arrays.copyOf(objectArray, 5, String[].class);
		System.out.println("New Object Array after Copying:");
		arrayPrint(objArray);
	}
	public static void arrayPrint(Object[] anObjectArray) {
		for (Object Number: anObjectArray) {
			System.out.println(Number);
		}
	}
}

New Object Array after Copying:
Australia
India
null
null
null