数组（3）：创建测试数据（上）

末蓝、 2023-07-20 12:25 10阅读 0赞

通常，在试验数组和程序时，能够很方便的生成填充了测试数据的数组，将会很有帮助。本节介绍的工具就可以用数值或对象来填充数组。

### 一、Arrays.fill() ###

java标准库Arrays有一个作用十分有限的fill()方法：只能用同一个值填充各个位置，而针对对象而言，就是复制同一个引用进行填充。下面是一个示例：

import java.util.Arrays;
    
    public class FillingArrays {
    	public static void main(String[] args) {
    		int size = 6;
    		boolean[] a1 = new boolean[size];
    		byte[] a2 = new byte[size];
    		char[] a3 = new char[size];
    		short[] a4 = new short[size];
    		int[] a5 = new int[size];
    		long[] a6 = new long[size];
    		float[] a7 = new float[size];
    		double[] a8 = new double[size];
    		String[] a9 = new String[size];
    		Arrays.fill(a1, true);
    		System.out.println("a1 = " + Arrays.toString(a1));
    		Arrays.fill(a2, (byte) 11);
    		System.out.println("a2 = " + Arrays.toString(a2));
    		Arrays.fill(a3, 'x');
    		System.out.println("a3 = " + Arrays.toString(a3));
    		Arrays.fill(a4, (short) 17);
    		System.out.println("a4 = " + Arrays.toString(a4));
    		Arrays.fill(a5, 19);
    		System.out.println("a5 = " + Arrays.toString(a5));
    		Arrays.fill(a6, 23);
    		System.out.println("a6 = " + Arrays.toString(a6));
    		Arrays.fill(a7, 29);
    		System.out.println("a7 = " + Arrays.toString(a7));
    		Arrays.fill(a8, 47);
    		System.out.println("a8 = " + Arrays.toString(a8));
    		Arrays.fill(a9, "Hello");
    		System.out.println("a9 = " + Arrays.toString(a9));
            Arrays.fill(a9, 3, 5, "World");
    		System.out.println("a9 = " + Arrays.toString(a9));
    	}
    }

使用Arrays.fill()可以填充整个数组，或者像最后两条语句所示，只填充数组的某个区域。但是由于只能用单一的数组来调用Arrays.fill()，因此所产生的结果并非特别有用。

### 二、数据生成器 ###

为了灵活的方式创建更有意义的数组，我们将使用Generator概念。如果某个工具使用了Generator，那么你就可以通过选择Generator的类型来创建任何类型的数据（这是策略设计模式的一个实例——每个不同的Generator都表示一个不同的策略）。

本节将提供一些Generator，并且，就像之前看到的，你还可以很容易的定义自己的Generator。

首先给出的是可以用于所有基本类型的包装器类型，以及String类型的最基本的计数生成器集合。这些生成器类都嵌套在CountingGenerator类中，从而使得它们能够使用与所要生成的对象类型相同的名字。例如，创建Integer对象的生成器可以通过表达式new CountingGenerator.Integer()来创建：

public class CountingGenerator {
    	public static class Boolean implements Generator<java.lang.Boolean> {
    		private boolean value = false;
    
    		@Override
    		public java.lang.Boolean next() {
    			value = !value;
    			return value;
    		}
    	}
    
    	public static class Byte implements Generator<java.lang.Byte> {
    		private byte value = 0;
    
    		@Override
    		public java.lang.Byte next() {
    			return value++;
    		}
    	}
    
    	static char[] chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".toCharArray();
    
    	public static class Character implements Generator<java.lang.Character> {
    		int index = -1;
    
    		@Override
    		public java.lang.Character next() {
    			index = (index + 1) % chars.length;
    			return chars[index];
    		}
    	}
    
    	public static class String implements Generator<java.lang.String> {
    		private int length = 7;
    
    		Generator<java.lang.Character> cg = new Character();
    
    		public String() {
    		}
    
    		public String(int length) {
    			this.length = length;
    		}
    
    		@Override
    		public java.lang.String next() {
    			char[] buf = new char[length];
    			for (int i = 0; i < length; i++) {
    				buf[i] = cg.next();
    			}
    			return new java.lang.String(buf);
    		}
    	}
    
    	public static class Short implements Generator<java.lang.Short> {
    		private short value = 0;
    
    		@Override
    		public java.lang.Short next() {
    			return value++;
    		}
    	}
    
    	public static class Integer implements Generator<java.lang.Integer> {
    		private int value = 0;
    
    		@Override
    		public java.lang.Integer next() {
    			return value++;
    		}
    	}
    
    	public static class Long implements Generator<java.lang.Long> {
    		private long value = 0;
    
    		@Override
    		public java.lang.Long next() {
    			return value++;
    		}
    	}
    
    	public static class Float implements Generator<java.lang.Float> {
    		private float value = 0;
    
    		@Override
    		public java.lang.Float next() {
    			return value++;
    		}
    	}
    
    	public static class Double implements Generator<java.lang.Double> {
    		private double value = 0;
    
    		@Override
    		public java.lang.Double next() {
    			return value++;
    		}
    	}
    }

上面的每个类都实现了某种意义的“计数”。在CountingGenerator.Character中，计数只是不断地重复大写和小写字母；CountingGenerator.String类使用CountingGenerator.Character来填充一个字符数组，该数组将被转换为String，数组的尺寸取决于构造器参数。请注意，CountingGenerator.String使用的是基本的Generator<java.lang.Character>，而不是具体的对CountingGenerator.Character的引用。稍后，我们可以替换这个生成器，以生成RandomGenerator.java中的RandomGenerator.String。

下面是一个测试工具，针对嵌套的Generator这一惯用法，因为使用了反射所以这个工具可以遵循下面的形式来测试Generator的任何集合。

import com.buba.util.CountingGenerator;
    import com.buba.util.Generator;
    
    public class GeneratorsTest {
    	public static int size = 10;
    
    	public static void test(Class<?> surroundingClass) {
    		for (Class<?> type : surroundingClass.getClasses()) {
    			System.out.print(type.getSimpleName() + ": ");
    			try {
    				Generator<?> g = (Generator<?>) type.newInstance();
    				for (int i = 0; i < size; i++) {
    					System.out.printf(g.next() + " ");
    				}
    				System.out.println();
    			} catch (Exception e) {
    				new RuntimeException(e);
    			}
    		}
    	}
    
    	public static void main(String[] args) {
    		test(CountingGenerator.class);
    	}
    }

这里假设待测类包含一组嵌套的Generator对象，其中每个都有一个默认构造器（无参构造器），反射方法getClass()可以生成所有的嵌套类，而test()方法可以为这些生成器中的每一个都创建一个实例，然后打印通过调用10次next()方法而产生的结果。

下面是一组使用随机数生成器的Generator。因为Random构造器使用常量进行初始化，所以，每次用这些Generator中的一个来运行程序时，所产生的输出都是可重复的：

import java.util.Random;
    
    public class RandomGenerator {
    	private static Random r = new Random();
    
    	public static class Boolean implements Generator<java.lang.Boolean> {
    		@Override
    		public java.lang.Boolean next() {
    			return r.nextBoolean();
    		}
    	}
    
    	public static class Byte implements Generator<java.lang.Byte> {
    		@Override
    		public java.lang.Byte next() {
    			return (byte) r.nextInt();
    		}
    	}
    
    	public static class Character implements Generator<java.lang.Character> {
    		@Override
    		public java.lang.Character next() {
    			return CountingGenerator.chars[r.nextInt(CountingGenerator.chars.length)];
    		}
    	}
    
    	public static class String extends CountingGenerator.String {
    		{
    			cg = new Character();
    		}
    
    		public String() {
    		}
    
    		public String(int length) {
    			super(length);
    		}
    	}
    
    	public static class Short implements Generator<java.lang.Short> {
    		@Override
    		public java.lang.Short next() {
    			return (short) r.nextInt();
    		}
    	}
    
    	public static class Integer implements Generator<java.lang.Integer> {
    		private int mod = 10000;
    
    		public Integer() {
    		}
    
    		public Integer(int modulo) {
    			mod = modulo;
    		}
    
    		@Override
    		public java.lang.Integer next() {
    			return r.nextInt(mod);
    		}
    	}
    
    	public static class Long implements Generator<java.lang.Long> {
    		private int mod = 10000;
    
    		public Long() {
    		}
    
    		public Long(int modulo) {
    			mod = modulo;
    		}
    
    		@Override
    		public java.lang.Long next() {
    			return new java.lang.Long(r.nextInt(mod));
    		}
    	}
    
    	public static class Float implements Generator<java.lang.Float> {
    		@Override
    		public java.lang.Float next() {
    			int trimmed = Math.round(r.nextFloat() * 100);
    			return ((float) trimmed) / 100;
    		}
    	}
    
    	public static class Double implements Generator<java.lang.Double> {
    		@Override
    		public java.lang.Double next() {
    			long trimmed = Math.round(r.nextDouble() * 100);
    			return ((double) trimmed) / 100;
    		}
    	}
    }

你可以看到。RandomGenerator.String继承自CountingGenerator.String，并且只是插入了新的Character生成器。

为了不生成过大的数字，RandomGenerator.Integer默认使用的模数为10000，但是重载的构造器允许你选择更小的值。同样的方式也应用到了RandomGenerator.Long上。对于Float和Double生成器，小数点之后的数字被截掉了。

我们复用GeneratorTest来测试RandomGenerator：

import com.buba.util.RandomGenerator;
    
    public class RandomGeneratorsTest {
    	public static void main(String[] args) {
    		GeneratorsTest.test(RandomGenerator.class);
    	}
    }

你可以通过修改public的GeneratorTest.size的值，来改变所产生的数值数量。

**如果本文对您有很大的帮助，还请点赞关注一下。**