Java Arrays.copyOfRange 方法

Java Arrays.copyOfRange 方法是 Array 方法之一，用于将指定用户范围内的数组项复制到一个新数组中。

在本文中，我们将通过一个示例展示如何使用 copyOfRange 方法将数组元素范围复制到一个新数组中。该编程语言中 Arrays.copyOfRange 的语法如下所示。

Java Arrays.copyOfRange 方法语法

Java 编程语言提供了十种不同的 Arrays.copyOfRange 方法，用于将指定的 Arrays 复制到一个新的数组中。在复制时

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

以下 Java Arrays.copyOfRange 方法接受布尔数组，作为第二个参数（整数值）的元素开始复制的起始索引位置（from）。最后一个索引位置（to）是复制结束的位置，作为第三个参数。

注意：此方法将复制从 from 开始到 to（不包含 to）的数组元素。

public static boolean copyOfRange(Boolean[] anBooleanArray, int from, int to); // It will return Boolean Array

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

其余的 Java arrays.copyOfRange 方法。

public static byte copyOfRange(byte[] anByteArray, int from, int to); // It will return Byte Array
Arrays.copyOfRange(byte[] anByteArray, int from, int to);

public static short copyOfRange(short[] anShortArray, int from, int to); // It will return short Array
Arrays.copyOfRange(short[] anShortArray, int from, int to);

public static char copyOfRange(char[] anCharArray, int from, int to); // It will return char Array
Arrays.copyOfRange(char[] anCharArray, int from, int to);

public static short copyOfRange(int[] anIntArray, int from, int to); // It will return Integer Array
Arrays.copyOfRange(int[] anIntArray, int from, int to);

public static long copyOfRange(long[] anLongArray, int from, int to); // It will return Long Array
Arrays.copyOfRange(long[] anLongArray, int from, int to);

public static double copyOfRange(double[] anDoubleArray, int from, int to); // It will return Double Array
Arrays.copyOfRange(double[] anDoubleArray, int from, int to);

public static float copyOfRange(float[] anFloatArray, int from, int to); // It will return float Array
Arrays.copyOfRange(float[] anFloatArray, int from, int to);

public static <T> T[] copyOfRange(T[] Array, int from, int to); 
Arrays.copyOfRange(T[] Array, int from, int to);

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

• Array：这是原始的 数组。我们将使用 Arrays.copyOfRange 方法将此数组复制到一个新数组中。
• from：请指定元素开始复制到新数组的起始位置。
• to：请指定结束位置。copyOfRange 方法将复制到此索引位置的数组元素，但不包括它们在新数组中。根据 to，数组元素将被截断或扩展（使用默认值）。
• newType：请为新数组指定类类型。

Java Arrays.copyOfRange 字节数组

此 Java 程序声明了一个带有随机数组元素的字节数组。接下来，我们将调用 public static byte[] copyOfRange (byte[] anByteArray, int from, int to) 方法，将字节数组复制到一个指定范围（from-to）的新数组中。

// Java Example to Copy Byte Array to New
package ArrayMethods;
import java.util.Arrays;

public class CopyOfRangeBytes {
	public static void main(String[] args) {
		byte[] byteArray = {10, 25, 8, 19, 16, 5}; 
		
		//Copying Array
		byte[] bitArray = Arrays.copyOfRange(byteArray, 1, 5);
		System.out.println("New Integer Array after Copying:");
		arrayPrint(bitArray);
		
		//Copying Array
		byte[] biteArray = Arrays.copyOfRange(byteArray, 3, 9);
		System.out.println("New Integer Array after Copying:");
		arrayPrint(biteArray);
	}
	public static void arrayPrint(byte[] anByteArray) {
		for (byte Number: anByteArray) {
			System.out.println("Array Elelment = " + Number);
		}
	}
}

在此示例中，我们声明了一个字节数组，并使用以下语句为其分配了一些随机值作为数组元素。

byte[] byteArray = {10, 25, 8, 19, 16, 5};

接下来，我们使用 Java Arrays.copyOfRange 方法将 bitArray 元素从索引位置 1 复制到 4。

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

下一条语句是打印字节数组元素到输出。

arrayPrint(bitArray);

下一行，我们使用 Arrays.copyOfRange 方法将 byteArray 元素从索引位置 3 复制到 5。这意味着剩余的值将填充默认值（零）。

byte[] biteArray = Arrays.copyOfRange(byteArray, 3, 9);

下一条语句是打印字节数组元素到输出。

arrayPrint(byteArray);

当编译器执行到上述语句时，Jcompiler 将跳转到以下函数。

从下面的代码片段可以观察到，我们使用了 Java Foreach 循环来迭代字节数组。然后，我们使用 System.out.println 语句打印每个数组元素。

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

Java Arrays.copyOfRange 复制布尔数组

在此 Java 程序中，我们声明了一个带有随机元素的布尔数组。然后，我们将调用 public static Boolean[] copyOfRange (boolean[] anBooleanArray, int from, int to) 方法，将布尔数组复制到一个指定范围的新数组中。

package ArrayMethods;
import java.util.Arrays;

public class CopyOfRangeBoolean {
	public static void main(String[] args) {
		boolean[] bool = {true, false, false, true, true};
		boolean[] boolArray =  Arrays.copyOfRange(bool, 1, 4);
		System.out.println("New Boolean Array after Copying:");
		arrayPrint(boolArray);
		
		boolean[] bolArray =  Arrays.copyOfRange(bool, 2, 7);
		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 = false
Array Elelment = false
Array Elelment = true
New Boolean Array with Vlaues:
Array Elelment = false
Array Elelment = true
Array Elelment = true
Array Elelment = false
Array Elelment = false

如何复制 Short 数组？

在此程序中，我们声明了一个带有随机数组元素的 short 数组。然后，我们调用 public static Short[] copyOfRange (short[] anShortArray, int from, int to) 方法，将 short 数组复制到一个指定范围的新数组中。

package ArrayMethods;
import java.util.Arrays;

public class ShortCopyOfRange {
	public static void main(String[] args) {
		short[] srtArray = {2, 6, 4, 8, 9, 7, 3}; 
		
		short[] ShortArray = Arrays.copyOfRange(srtArray, 0, 4);
		System.out.println("New Short Array after Copying:");
		arrayPrint(ShortArray);
	}
	public static void arrayPrint(short[] anShortArray) {
		for (short Number: anShortArray) {
			System.out.println("Array Elelment = " + Number);
		}
	}
}

New Short Array after Copying:
Array Elelment = 2
Array Elelment = 6
Array Elelment = 4
Array Elelment = 8

Java Arrays.copyOfRange 复制整型数组

在此程序中，我们声明了一个带有随机元素的整型数组。然后，我们调用 public static int[] copyOfRange (int[] anIntegerArray, int from, int to) 方法，将 Int 数组复制到一个指定范围的新数组中。

package ArrayMethods;
import java.util.Arrays;

public class CopyOfRangeIntegers {
	public static void main(String[] args) {
		int[] intArray = {20, 40, 60, 80, 100, 120, 150}; 
		
		int[] integerArray = Arrays.copyOfRange(intArray, 2, 6);
		System.out.println("New Integer Array after Copying:");
		arrayPrint(integerArray);
		
		int[] inteArray = Arrays.copyOfRange(intArray, 4, 9);
		System.out.println("New Integer Array after Copying:");
		arrayPrint(inteArray);
	}
	public static void arrayPrint(int[] anIntArray) {
		for (int Number: anIntArray) {
			System.out.println("Array Elelment = " + Number);
		}
	}
}

New Integer Array after Copying:
Array Elelment = 60
Array Elelment = 80
Array Elelment = 100
Array Elelment = 120
New Integer Array after Copying:
Array Elelment = 100
Array Elelment = 120
Array Elelment = 150
Array Elelment = 0
Array Elelment = 0

Arrays.copyOfRange 复制 Long 数组

在此程序中，我们声明了一个带有随机元素的 long 数组。然后，我们调用 public static Long[] copyOfRange (long[] anLongArray, int from, int to) 方法，将 Long 数组复制到一个指定范围的新数组中。

package ArrayMethods;
import java.util.Arrays;

public class CopyOfRangeLong {
	public static void main(String[] args) {
		long[] LngArray = {540, 605, 1250, 2250, 3590, 9865}; 		
		long[] longArray = Arrays.copyOfRange(LngArray, 1, 4);
		System.out.println("New Long Array after Copying:");
		arrayPrint(longArray);
		
		long[] anLongArray = Arrays.copyOfRange(LngArray, 2, 8);
		System.out.println("New Long Array with Vlaues:");
		arrayPrint(anLongArray);
	}
	public static void arrayPrint(long[] anLongArray) {
		for (long Number: anLongArray) {
			System.out.println("Array Elelment = " + Number);
		}
	}
}

New Long Array after Copying:
Array Elelment = 605
Array Elelment = 1250
Array Elelment = 2250
New Long Array with Vlaues:
Array Elelment = 1250
Array Elelment = 2250
Array Elelment = 3590
Array Elelment = 9865
Array Elelment = 0
Array Elelment = 0

Java Arrays.copyOfRange 复制 Double 数组

在此程序中，我们声明了一个带有随机元素的 double 数组。然后，我们调用 public static Double[] copyOfRange (double[] anDoubleArray, int from, int to) 方法，将 double 数组复制到一个指定范围的新数组中。

package ArrayMethods;
import java.util.Arrays;

public class CopyOfRangeDoubles {
	public static void main(String[] args) {
		double[] DoubleArray = {143.96, 346.452, 67.89, 897.559, 655.689}; 
		
		double[] dblArray = Arrays.copyOfRange(DoubleArray, 1, 5);
		System.out.println("New Double Array after Copying:");
		arrayPrint(dblArray);
		
		double[] dbArray = Arrays.copyOfRange(DoubleArray, 2, 7);
		System.out.println("New Double Array after Copying:");
		arrayPrint(dbArray);
	}
	public static void arrayPrint(double[] anDoubleArray) {
		for (double Number: anDoubleArray) {
			System.out.println("Array Elelment = " + Number);
		}
	}
}

New Double Array after Copying:
Array Elelment = 346.452
Array Elelment = 67.89
Array Elelment = 897.559
Array Elelment = 655.689
New Double Array after Copying:
Array Elelment = 67.89
Array Elelment = 897.559
Array Elelment = 655.689
Array Elelment = 0.0
Array Elelment = 0.0

Arrays.copyOfRange 复制 Float 数组

在此程序中，我们声明了一个带有随机元素的浮点数组。然后，我们调用 public static float[] copyOfRange (float[] anFloatArray, int from, int to) 方法，将 float 数组复制到一个指定范围的新数组中。

package ArrayMethods;
import java.util.Arrays;
public class CopyOfFloat {
	public static void main(String[] args) {
		float[] floatArray = {24.54f, 33.98f, 46.68f, 19.25f, 3.95f};
		
		float[] fltArray = Arrays.copyOfRange(floatArray, 1, 4);
		System.out.println("New Float Array after Copying:");
		arrayPrint(fltArray);
		
		float[] ftArray = Arrays.copyOfRange(floatArray, 3, 7);
		System.out.println("New Float Array with Changed Vlaues:");
		arrayPrint(ftArray);
	}
	public static void arrayPrint(float[] anfloatArray) {
		for (float Number: anfloatArray) {
			System.out.println("Array Elelment = " + Number);
		}
	}
}

New Float Array after Copying:
Array Elelment = 33.98
Array Elelment = 46.68
Array Elelment = 19.25
New Float Array with Changed Vlaues:
Array Elelment = 19.25
Array Elelment = 3.95
Array Elelment = 0.0
Array Elelment = 0.0

Java Arrays.copyOfRange 复制 Char 数组

在此程序中，我们声明了一个字符数组。然后，我们调用 public static Char[] copyofRange (char[] anCharArray, int from, int to) 方法，将 Char 数组复制到一个指定范围的新字符数组中。

package ArrayMethods;
import java.util.Arrays;

public class CopyOfRangeChar {
	public static void main(String[] args) {
		char[] CharArray = {'T', 'u', 't', 'o', 'r', 'i', 'a', 'l'}; 
		char[] ChArray = Arrays.copyOfRange(CharArray, 1, 5);
		System.out.println("New Character Array after Copying:");
		arrayPrint(ChArray);
		
		char[] ChrArray = Arrays.copyOfRange(CharArray, 4, 10);
		System.out.println("New Character Array with Vlaues:");
		arrayPrint(ChrArray);
	}
	public static void arrayPrint(char[] anCharacterArray) {
		for (char Number: anCharacterArray) {
			System.out.println("Array Elelment = " + Number);
		}
	}
}

New Character Array after Copying:
Array Elelment = u
Array Elelment = t
Array Elelment = o
Array Elelment = r
New Character Array with Vlaues:
Array Elelment = r
Array Elelment = i
Array Elelment = a
Array Elelment = l
Array Elelment = 
Array Elelment = 

Arrays.copyOfRange 复制 Object 数组

在此程序中，我们声明了一个带有随机元素的 String 数组（String 是一个 Object）。然后，我们调用 public static T[] copyOfRange(T[] anArray, int from, int to) 方法，将 Object 数组复制到一个指定范围的新数组中。

package ArrayMethods;
import java.util.Arrays;

public class CopyOfRangeObject {
	public static void main(String[] args) {
		String[] stringArray = {"India", "USA", "UK", "Japan", "China", "Canada"}; 
		String[] strArray = Arrays.copyOfRange(stringArray, 1, 5);
		System.out.println("New Object Array after Copying:");
		arrayPrint(strArray);
		
		String[] strngArray = Arrays.copyOfRange(stringArray, 2, 8);
		System.out.println("New Object Array with Vlaues:");
		arrayPrint(strngArray);
	}
	public static void arrayPrint(Object[] anObjectArray) {
		for (Object Number: anObjectArray) {
			System.out.println("Array Elelment = " + Number);
		}
	}
}

New Object Array after Copying:
Array Elelment = USA
Array Elelment = UK
Array Elelment = Japan
Array Elelment = China
New Object Array with Vlaues:
Array Elelment = UK
Array Elelment = Japan
Array Elelment = China
Array Elelment = Canada
Array Elelment = null
Array Elelment = null

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

在此 Java 程序 中，我们声明了 Java 对象。然后，我们调用 public static <T, U> T[] copyOfRange (U[] anObjectArray, int from, int to) 方法，将 Object 数组复制到一个新的指定数组。

package ArrayMethods;
import java.util.Arrays;

public class CopyOfRangeT {
	public static void main(String[] args) {
		Object[] objectArray = {"Kiwi", "Apple", "Bannana", "Grape", "Cherry"}; 
		String[] objArray = Arrays.copyOfRange(objectArray, 1, 4, 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("Array Elelment = " + Number);
		}
	}
}

New Object Array after Copying:
Array Elelment = Apple
Array Elelment = Bannana
Array Elelment = Grape