Java数组(3)：创建测试数据

有时我们需要使用数组批量创建测试数据，接下来通过以下4点来举例。

(1) 使用Arrays.fill()填充数据

(2) 使用Random类中JDK1.8提供的新方法用来生成随机数

(3) 一个随机数生成器的实例

(4) 根据(3)中的随机数生成器创建包装类型的数组及通过转换器转换成基本类型的数组

(1) 使用Arrays.fill()填充数据：它可以填充整个数组或填充数组某个区域。另外填充对象时是复制一个引用填充的。

 public class Test1 {
     public static void main(String[] args) {
         char[] p1 = new char[3];
         long[] p2 = new long[4];
         String[] p3 = new String[5];
         Arrays.fill(p1, 'b');
         Arrays.fill(p2, 5L);
         Arrays.fill(p3, "Hello");
         System.out.println(Arrays.toString(p1)); // [b, b, b]
         System.out.println(Arrays.toString(p2)); // [5, 5, 5, 5]
         System.out.println(Arrays.toString(p3)); // [Hello, Hello, Hello, Hello, Hello]
         Arrays.fill(p3, 4, 5, "World");
         System.out.println(Arrays.toString(p3)); // [Hello, Hello, Hello, Hello, World]
     }
 }

(2) 使用Random类中JDK1.8提供的新方法用来生成随机数

 public class Test2 {
     public static void main(String[] args) {
         Random random = new Random();
         int[] arr = random.ints(10).toArray(); // 生成10个int范围类的个数。
         System.out.println(Arrays.toString(arr));
         random.ints().limit(10).forEach(System.out::println); // 生成10个int范围类的个数(先生成无限个再截取10个)。
         random.longs(5, 10, 100).forEach(System.out::println); // 生成5个在[10,100)范围内的整数
         random.longs(10, 100).limit(5).forEach(System.out::println); // 生成5个在[10,100)范围内的整数(先生成无限个再截取10个)。
     }
 }

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

 import java.util.Random;

 interface Generator<T> { T next(); }

 class RandomGenerator {

     // 对于有参构造，需要注意的是，如果seed(种子)值相同，不管执行多少次，随机生成的数据是相同的
     private static Random r = new Random(47);

     // Boolean Generator
     public static class GenBoolean implements Generator<Boolean> {
         @Override
         public Boolean next() {
             return r.nextBoolean(); // return next(1) != 0; 想生成范围在[0,1]的整数
         }
     }

     // Byte Generator
     public static class GenByte implements Generator<Byte> {
         @Override
         public Byte next() {
             return (byte) r.nextInt(); // 随机生成一个整数，范围就是int类型的范围-2^31~2^31-1，这里会强制截取后8 bit作为byte值
         }
     }

     // Character Generator
     public static class GenCharacter implements Generator<Character> {

         private static char[] chars = ("abcdefghijklmnopqrstuvwxyz" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ").toCharArray();

         @Override
         public Character next() {
             return chars[r.nextInt(GenCharacter.chars.length)]; // 生成范围在[0, chars.length)的整数
         }
     }

     // String Generator
     public static class GenString implements Generator<String> {
         private int length = 7;
         Generator<Character> cg = new GenCharacter();

         public GenString() {
         }

         public GenString(int length) {
             this.length = length;
         }

         @Override
         public String next() {
             char[] buf = new char[length];
             for (int i = 0; i < length; i++)
                 buf[i] = cg.next();
             return new String(buf);
         }
     }

     // Short Generator
     public static class GenShort implements Generator<Short> {

         @Override
         public Short next() {
             return (short) r.nextInt(); // 随机生成一个整数，范围就是int类型的范围-2^31~2^31-1，这里会强制截取后16 bit作为byte值
         }
     }

     // Integer Generator
     public static class GenInteger implements Generator<Integer> {
         private int mod = 10000;

         public GenInteger() {
         }

         public GenInteger(int modulo) {
             mod = modulo;
         }

         @Override
         public Integer next() {
             return r.nextInt(mod); // 随机生成一个整数，默认范围是[0, 10000)
         }
     }

     // Long Generator
     public static class GenLong implements Generator<Long> {
         private int mod = 10000;

         public GenLong() {
         }

         public GenLong(int modulo) {
             mod = modulo;
         }

         @Override
         public Long next() {
             return new Long(r.nextInt(mod));// 随机生成一个整数，默认范围是[0, 10000)
         }
     }

     // Float Generator
     public static class GenFloat implements Generator<Float> {
         @Override
         public Float next() {
             int trimmed = Math.round(r.nextFloat() * 100);
             return ((float) trimmed) / 100;
         }
     }

     // Double Generator
     public static class GenDouble implements Generator<Double> {
         @Override
         public Double next() {
             long trimmed = Math.round(r.nextDouble() * 100);
             return ((double) trimmed) / 100;
         }
     }
 }

 public class Test3 {
     public static void main(String[] args) {
         Generator<Boolean> a = new RandomGenerator.GenBoolean();
         Generator<Integer> b = new RandomGenerator.GenInteger();
         Generator<Float> c = new RandomGenerator.GenFloat();
         generate(a, 5); // true false true false false
         generate(b, 5); // 429 4868 200 4522 6207
         generate(c, 5); // 0.27 0.95 0.26 0.11 0.05
     }

     private static <T> void generate(Generator<T> gen, int times) {
         for (int i = 0; i < times; i++) {
             System.out.print(gen.next() + " ");
         }
         System.out.println();
     }
 }

(4) 根据(3)中的随机数生成器创建包装类型的数组及通过转换器转换成基本类型的数组

> 创建包装类型的数组

> 由于泛型不支持基本类型，如果想用生成器填充基本类型的数组，还需要创建一个转换器

 import java.lang.reflect.Array;
 import java.util.ArrayList;
 import java.util.Arrays;

 class CollectionData<T> extends ArrayList<T> {

     private static final long serialVersionUID = 1L;

     public CollectionData(Generator<T> gen, int quantity) {
         for (int i = 0; i < quantity; i++)
             add(gen.next());
     }

     public static <T> CollectionData<T> list(Generator<T> gen, int quantity) {
         return new CollectionData<T>(gen, quantity);
     }
 }

 class Generated {
     // Fill an existing array:
     public static <T> T[] array(T[] a, Generator<T> gen) {
         return new CollectionData<T>(gen, a.length).toArray(a);
     }

     // Create a new array:
     public static <T> T[] array(Class<T> type, Generator<T> gen, int size) {
         @SuppressWarnings("unchecked")
         T[] a = (T[]) Array.newInstance(type, size);
         return new CollectionData<T>(gen, size).toArray(a);
     }
 }

 class ConvertTo {
     public static boolean[] primitive(Boolean[] in) {
         boolean[] result = new boolean[in.length];
         for (int i = 0; i < in.length; i++)
             result[i] = in[i];
         return result;
     }

     public static char[] primitive(Character[] in) {
         char[] result = new char[in.length];
         for (int i = 0; i < in.length; i++)
             result[i] = in[i];
         return result;
     }

     public static byte[] primitive(Byte[] in) {
         byte[] result = new byte[in.length];
         for (int i = 0; i < in.length; i++)
             result[i] = in[i];
         return result;
     }

     public static short[] primitive(Short[] in) {
         short[] result = new short[in.length];
         for (int i = 0; i < in.length; i++)
             result[i] = in[i];
         return result;
     }

     public static int[] primitive(Integer[] in) {
         int[] result = new int[in.length];
         for (int i = 0; i < in.length; i++)
             result[i] = in[i];
         return result;
     }

     public static long[] primitive(Long[] in) {
         long[] result = new long[in.length];
         for (int i = 0; i < in.length; i++)
             result[i] = in[i];
         return result;
     }

     public static float[] primitive(Float[] in) {
         float[] result = new float[in.length];
         for (int i = 0; i < in.length; i++)
             result[i] = in[i];
         return result;
     }

     public static double[] primitive(Double[] in) {
         double[] result = new double[in.length];
         for (int i = 0; i < in.length; i++)
             result[i] = in[i];
         return result;
     }
 }

 public class Test4 {
     public static void main(String[] args) {
         Integer[] a = Generated.array(new Integer[5], new RandomGenerator.GenInteger());
         System.out.println(Arrays.toString(a)); // [9258, 555, 6693, 1861, 961]
         Long[] b = Generated.array(Long.class, new RandomGenerator.GenLong(), 5);
         System.out.println(Arrays.toString(b)); // [429, 4868, 200, 4522, 6207]

         int[] c = ConvertTo.primitive(a);
         System.out.println(Arrays.toString(c)); // [9258, 555, 6693, 1861, 961]
         long[] d = ConvertTo.primitive(b);
         System.out.println(Arrays.toString(d)); // [429, 4868, 200, 4522, 6207]
     }
 }