Java 数组填充

Java 数组填充方法是数组方法之一，它将用户指定的_值_分配给数组中指定范围（如果指定）的每个元素。

在本 Java 文章中，我们将展示如何填充布尔型、字节型、整型、字符型、长整型、双精度型、单精度型、短整型和对象型数组。此编程语言中数组填充的基本语法如下所示。

Java 数组填充方法语法

Java 编程语言提供了十八种不同的方法来填充数组。以下填充方法将接受字节数组和字节值作为参数，并将字节值分配给字节数组中的每个元素。或者，我们可以说填充方法将用用户指定的字节值替换所有数组元素。

public static void fill(byte[] anByteArray, byte Value); 

//In order to use in program
Arrays.fill(byte[] anByteArray, byte Value);

它接受字节数组作为第一个参数，起始索引位置（fromIndex）。填充将从第二个参数（整数值）开始，最后一个索引位置（toIndex）。填充将在第三个参数和字节值（被此值替换的数组元素）处结束。

注意：此方法将从 fromIndex 开始填充数组元素，直到 toIndex，但不包含 toIndex。

public static void fill(byte[] anByteArray, int fromIndex, int toIndex, byte Value); 

//In order to use in program
Arrays.fill(byte[] anByteArray, int fromIndex, int toIndex, byte Value);

此 Java 填充方法将接受布尔数组和值作为参数，并将布尔值分配给每个元素。

public static void fill(boolean[] anBooleanArray, boolean Value); 

//In order to use in program
Arrays.fill(boolean[] anBooleanArray, boolean Value);

以下方法将布尔数组作为第一个参数。起始索引位置（fromIndex）作为第二个参数（整数值）。最后一个索引位置（toIndex）作为第三个参数，以及布尔值。

它接受双精度数组作为第一个参数，填充将开始的起始索引位置（fromIndex）作为第二个参数（整数值）。填充将结束的最后一个索引位置（toIndex）作为第三个参数。以及双精度值（被此值替换的数组元素）。

public static void fill(boolean[] anBooleanArray, int fromIndex, int toIndex, boolean Value); 

//In order to use in program
Arrays.fill(boolean[] anBooleanArray, int fromIndex, int toIndex, boolean Value);

此填充方法接受短整型数组和短整型值作为参数。它将短整型值分配给短整型数组中的每个元素。

public static void fill(short[] anShortArray, short Value); 

//In order to use in program
Arrays.fill(short[] anShortArray, short Value);

Java 填充方法接受短整型数组作为第一个参数，起始索引位置（fromIndex），最后一个索引位置（toIndex），以及短整型值（被替换的元素值）。

public static void fill(short[] anShortArray, int fromIndex, int toIndex, short Value); 
Arrays.fill(short[] anShortArray, int fromIndex, int toIndex, short Value);

public static void fill(char[] anCharArray, char Value); 
Arrays.fill(char[] anCharArray, char Value);

public static void fill(char[] anCharArray, int fromIndex, int toIndex, char Value); 
Arrays.fill(char[] anCharArray, int fromIndex, int toIndex, char Value);

public static void fill(int[] anIntArray, int Value); 
Arrays.fill(int[] anIntArray, int Value);

public static void fill(int[] anIntArray, int fromIndex, int toIndex, int Value); 
Arrays.fill(int[] anIntArray, int fromIndex, int toIndex, int Value);

public static void fill(long[] anLongArray, long Value); 
Arrays.fill(long[] anLongArray, long Value);

public static void fill(long[] anLongArray, int fromIndex, int toIndex, long Value);
Arrays.fill(long[] anLongArray, int fromIndex, int toIndex, long Value);

public static void fill(double[] anDoubleArray, double Value);
Arrays.fill(double[] anDoubleArray, double Value);

public static void fill(double[] anDoubleArray, int fromIndex, int toIndex, double Value);
Arrays.fill(double[] anDoubleArray, int fromIndex, int toIndex, double Value);

public static void fill(float[] anFloatArray, float Value); 
Arrays.fill(float[] anFloatArray, float Value);

public static void fill(float[] anFloatArray, int fromIndex, int toIndex, float Value); 
Arrays.fill(float[] anFloatArray, int fromIndex, int toIndex, float Value);

public static void fill(Object[] Array, Object Val); 
Arrays.fill(Object[] Array, Object Val);

public static void fill(Object[] Array, int fromIndex, int toIndex, Object Val); 
Arrays.fill(Object[] Array, int fromIndex, int toIndex, Object Val);
  • fromIndex：请指定起始索引位置。这是填充将开始的索引位置。
  • toIndex：请指定结束索引位置。Arrays.fill 方法将填充到该索引位置。但是，它不包含该位置（toIndex）的元素。
  • Value：请指定您要分配给 Java 数组每个元素的_值_。

Java 填充字节数组

在此 Java 程序中，我们声明了具有随机数组元素的字节数组。然后我们将填充数组元素为一个新值。

package ArrayMethods;
import java.util.Arrays;
public class ByteFill {
	public static void main(String[] args) {
		byte[] byteArray = {20, 8, 18, 45}; 
		byte[] bitArray = {10, 25, 8, 19, 16}; 
		
		//Filling Array with Value 5
		Arrays.fill(byteArray, (byte)5);	
		System.out.println("Filling Byte Array:");
		arrayPrint(byteArray);
		
		//Filling Array with Value 7 using Index
		Arrays.fill(bitArray, 1, 4, (byte)7);		
		System.out.println("Filling Byte Array Using Index:");
		arrayPrint(bitArray);
	}
	public static void arrayPrint(byte[] anByteArray) {
		for (byte Number: anByteArray) {
			System.out.println("Array Elelment = " + Number);
		}
	}
}
Java Array Fill Method 1

以下语句将调用 public static void fill(byte[] anByteArray, byte Value) 方法，将 Value 分配给字节数组中的每个元素。

Arrays.fill(byteArray, (byte)5);

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

arrayPrint(byteArray);

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

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

以下语句调用 public static void fill(byte[] anByteArray, int fromIndex, int toIndex, byte Value) 来用值 7 填充从索引位置 1 到索引位置 3 的字节数组。

Arrays.fill(bitArray, 1, 4, (byte)7);

Java 填充布尔数组

在此填充程序中，我们声明了具有随机元素的布尔数组。然后我们将填充数组元素为一个新值。

package ArrayMethods;
import java.util.Arrays;

public class BooleanFill {
	public static void main(String[] args) {
		boolean[] bool = {true, false, false, true};
		boolean[] boolArray = {true, false, true, true, true};
		
		Arrays.fill(bool, true);
		System.out.println("Boolean Array:");
		arrayPrint(bool);
		
		Arrays.fill(boolArray, 1, 4, false);
		System.out.println("Filling Boolean Array Using Index:");
		arrayPrint(boolArray);
	}
	public static void arrayPrint(boolean[] anBooleanArray) {
		for (boolean bool: anBooleanArray) {
			System.out.println("Array Elelment = " + bool);
		}
	}
}
Boolean Array:
Array Elelment = true
Array Elelment = true
Array Elelment = true
Array Elelment = true
Filling Boolean Array Using Index:
Array Elelment = true
Array Elelment = false
Array Elelment = false
Array Elelment = false
Array Elelment = true

以下语句将调用 public static void fill(boolean[] anBooleanArray, Boolean Value) 方法，将 Value 分配给布尔数组中的每个元素。

Arrays.fill(bool, true);

它调用 public static void fill(boolean[] anBooleanArray, int fromIndex, int toIndex, Boolean Value) 方法，使用布尔值 False 填充从索引位置 1 到索引位置 3 的布尔数组。

Arrays.fill(boolArray, 1, 4, false);

Java 填充短整型数组

在此填充程序中，我们声明了具有随机元素的短整型数组。然后我们将按升序对短整型数组元素进行排序。

package ArrayMethods;
import java.util.Arrays;

public class ShortFill {
	public static void main(String[] args) {
		short[] shrArray = {12, 14, 2, 9}; 
		short[] ShortArray = {25, 5, 19, 6, 50}; 		

		Arrays.fill(shrArray, (short)15);
		System.out.println("Filling Short Array:");
		arrayPrint(shrArray);
		
		Arrays.fill(ShortArray, 1, 4,(short)75);
		System.out.println("Filling Short Array Using Index:");
		arrayPrint(ShortArray);
	}
	public static void arrayPrint(short[] anShortArray) {
		for (short Number: anShortArray) {
			System.out.println("Array Elelment = " + Number);
		}
	}
}
Filling Short Array:
Array Elelment = 15
Array Elelment = 15
Array Elelment = 15
Array Elelment = 15
Filling Short Array Using Index:
Array Elelment = 25
Array Elelment = 75
Array Elelment = 75
Array Elelment = 75
Array Elelment = 50

它调用 public static void fill(short[] anShortArray, short Value) 方法，将 Value 分配给短整型数组中的每个元素。

Arrays.fill(shrArray, (short)15);

它调用 public static void fill(short[] anShortArray, int fromIndex, int toIndex, short Value) 来用 75 填充从索引位置 1 到索引位置 3 的短整型数组。

Arrays.fill(ShortArray, 1, 4,(short)75);

Java fill 方法应用于整型数组

在此程序中，我们声明了具有随机元素的整型数组。然后我们将填充整型数组元素为一个新值。

package ArrayMethods;
import java.util.Arrays;

public class IntFill {
	public static void main(String[] args) {
		int[] IntArray = {98, 54, 75, 82}; 
		int[] IntegerArray = {14, 25, 78, 19, 94}; 
		
		Arrays.fill(IntArray, 30);
		System.out.println("Integer Array:");
		arrayPrint(IntArray);
		
		Arrays.fill(IntegerArray, 1, 4, 50);
		System.out.println("Filling Integer Array Using Index:");
		arrayPrint(IntegerArray);
	}
	public static void arrayPrint(int[] anIntArray) {
		for (int Number: anIntArray) {
			System.out.println("Array Element = " + Number);
		}
	}
}
Integer Array:
Array Element = 30
Array Element = 30
Array Element = 30
Array Element = 30
Filling Integer Array Using Index:
Array Element = 14
Array Element = 50
Array Element = 50
Array Element = 50
Array Element = 94

它调用 public static void fill(int[] anIntegerArray, int Value) 方法，将 Value 分配给整型数组中的每个元素。

Arrays.fill(IntArray, 30);

它调用 public static void fill(int[] anIntegerArray, int fromIndex, int toIndex, int Value) 方法，使用 50 填充从索引位置 1 到索引位置 3 的整型数组。

Arrays.fill(IntegerArray, 1, 4, 50);

使用 fill 方法的 long 数组

在此程序中，我们声明了具有随机元素的 long 数组。然后我们将用新值填充 long 数组的元素。

package ArrayMethods;
import java.util.Arrays;

public class LongFill {
	public static void main(String[] args) {
		long[] LngArray = {198, 146, 187, 153}; 
		long[] LongArray = {1515, 250, 190, 80, 2525}; 		

		Arrays.fill(LngArray, 750);
		System.out.println("Filling Long Array:");
		arrayPrint(LngArray);
		
		Arrays.fill(LongArray, 1, 4, 1500);
		System.out.println("Filling Long Array Using Index:");
		arrayPrint(LongArray);
	}
	public static void arrayPrint(long[] anLongArray) {
		for (long Number: anLongArray) {
			System.out.println(Number);
		}
	}
}
Filling Long Array:
750
750
750
750
Filling Long Array Using Index:
1515
1500
1500
1500
2525

在此示例中，以下语句调用 public static void fill(long[] anLongArray, long Value) 将 Value 分配给每个 long 数组元素。

Arrays.fill(LngArray, 750);

以下语句调用 public static void fill(long[] anLongArray, int fromIndex, int toIndex, long Value) 以 1500 的值填充从索引位置 1 到索引位置 3 的 long 数组。

Arrays.fill(LongArray, 1, 4, 1500);

Java fill 方法应用于 double 数组

在此 Java 程序中，我们声明了具有随机数组元素的 double 数组。然后我们将填充 double 数组元素为一个新值。

package ArrayMethods;
import java.util.Arrays;

public class DoubleFill {
	public static void main(String[] args) {
		double[] DoubArray = {64.542, 7.98, 78.45, 35.76}; 
		double[] DoubleArray = {145.25, 98.86, 27.9865, 83.485, 209.356}; 
		
		Arrays.fill(DoubArray, 1400.25);
		System.out.println("Double Array:");
		arrayPrint(DoubArray);
		
		Arrays.fill(DoubleArray, 1, 4, 180.75);
		System.out.println("Filling Double Array Using Index:");
		arrayPrint(DoubleArray);
	}
	public static void arrayPrint(double[] anDoubleArray) {
		for (double Number: anDoubleArray) {
			System.out.println(Number);
		}
	}
}
Double Array:
1400.25
1400.25
1400.25
1400.25
Filling Double Array Using Index:
145.25
180.75
180.75
180.75
209.356

它调用 public static void fill(double[] anDoubleArray, double Value) 方法，将 Value 分配给 double 数组中的每个元素。

Arrays.fill(DoubArray, 1400.25);

以下语句调用 public static void fill(double[] anDoubleArray, int fromIndex, int toIndex, double Value) 以 180.75 对从索引位置 1 到索引位置 3 的 double 数组进行排序。

Arrays.fill(DoubleArray, 1, 4, 180.75);

Java fill 方法应用于 float 数组

在此 Java 程序中，我们声明了具有随机元素的 float 数组。接下来，我们将用新值填充 float 数组元素。

package ArrayMethods;
import java.util.Arrays;

public class FloatFill {
	public static void main(String[] args) {
		float[] floArray = {8.68f, 1.98f, 5.54f, 12.45f};
		float[] floatArray = {8.4f, 10.25f, 25.98f, 16.48f, 13.3f};	
		//Filling Array with Value 10.25
		Arrays.fill(floArray, 10.25f);
		System.out.println("Float Array:");
		arrayPrint(floArray);
		
		//Filling Array with Value 25.75 using Index
		Arrays.fill(floatArray, 1, 4, 25.75f);
		System.out.println("Filling Float Array Using Index:");
		arrayPrint(floatArray);
	}
	public static void arrayPrint(float[] anfloatArray) {
		for (float Number: anfloatArray) {
			System.out.println(Number);
		}
	}
}
Float Array:
10.25
10.25
10.25
10.25
Filling Float Array Using Index:
8.4
25.75
25.75
25.75
13.3

以下语句将调用 public static void fill(float[] anFloatArray, float Value) 方法，将 Value 分配给浮点数数组中的每个元素。

Arrays.fill(floArray, 10.25f);

它调用 public static void fill(float[] anFloatArray, int fromIndex, int toIndex, float Value) 方法，使用 25.75f 填充从索引位置 1 到索引位置 3 的 float 数组。

Arrays.fill(floatArray, 1, 4, 25.75f);

Java fill 方法应用于 char 数组

在此程序中，我们声明了具有随机元素的字符数组。然后我们将填充 char 数组元素为一个新值。

package ArrayMethods;
import java.util.Arrays;

public class CharFill {
	public static void main(String[] args) {
		char[] CharArray = {'g', 'a', 't', 'e'}; 
		char[] CharacterArray = {'g', 'a', 't', 'e', 'y'};
		//Filling Array with Char T
		Arrays.fill(CharArray, 'T');
		System.out.println("Character Array:");
		arrayPrint(CharArray);
		
		//Filling Array with Character A using Index
		Arrays.fill(CharacterArray, 2, 4, 'A');
		System.out.println("Filling Character Array Using Index:");
		arrayPrint(CharacterArray);
	}
	public static void arrayPrint(char[] anCharacterArray) {
		for (char ch: anCharacterArray) {
			System.out.println(ch);
		}
	}
}
Character Array:
T
T
T
T
Filling Character Array Using Index:
g
a
A
A
y

在此示例中，以下语句将调用 public static void fill(char [] anCharArray, char Value) 方法，将 Value 分配给 char 数组中的每个元素。

Arrays.fill(CharArray, 'T');

以下语句将调用 (char[] anCharArray, int fromIndex, int toIndex, char Value) 来用字符 ‘A’ 填充从索引位置 2 到索引位置 3 的 char 数组。

Arrays.fill(CharacterArray, 2, 4, 'A');

fill 方法应用于 Object 数组

在此 Java 程序中，我们声明了具有随机元素的 String 数组。接下来，我们将用新的对象值填充 String 对象数组元素。

package ArrayMethods;
import java.util.Arrays;

public class ObjectFill {
	public static void main(String[] args) {
		String[] strArray = {"Apple", "Orange", "Kiwi"};
		String[] stringArray = {"India", "UK", "Australia", "Japan","China"};

		Arrays.fill(strArray, "Cherry");
		System.out.println("Filling Object Array:");
		arrayPrint(strArray);
		
		Arrays.fill(stringArray, 1, 4, "USA");
		System.out.println("Filling Object Array Using Index:");
		arrayPrint(stringArray);
	}
	public static void arrayPrint(Object[] anObjectArray) {
		for (Object Number: anObjectArray) {
			System.out.println(Number);
		}
	}
}
Filling Object Array:
Cherry
Cherry
Cherry
Filling Object Array Using Index:
India
USA
USA
USA
China

在此方法示例中，以下语句调用 public static void fill(Object[] anObjectArray, Object Value) 将 Value 分配给每个 Object 数组元素。

Arrays.fill(strArray, "Cherry");

它调用 public static void fill(Object[] anObjectArray, int fromIndex, int toIndex, Object Value)。并且该方法使用字符串 “USA” 填充从索引位置 1 到索引位置 3 的 Object 数组。

Arrays.fill(stringArray, 1, 4, "USA");