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]
    }
}