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

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

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

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

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

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

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

 1 public class Test1 {
 2     public static void main(String[] args) {
 3         char[] p1 = new char[3];
 4         long[] p2 = new long[4];
 5         String[] p3 = new String[5];
 6         Arrays.fill(p1, ‘b‘);
 7         Arrays.fill(p2, 5L);
 8         Arrays.fill(p3, "Hello");
 9         System.out.println(Arrays.toString(p1)); // [b, b, b]
10         System.out.println(Arrays.toString(p2)); // [5, 5, 5, 5]
11         System.out.println(Arrays.toString(p3)); // [Hello, Hello, Hello, Hello, Hello]
12         Arrays.fill(p3, 4, 5, "World");
13         System.out.println(Arrays.toString(p3)); // [Hello, Hello, Hello, Hello, World]
14     }
15 }

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

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

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

  1 import java.util.Random;
  2
  3 interface Generator<T> { T next(); }
  4
  5 class RandomGenerator {
  6
  7     // 对于有参构造,需要注意的是,如果seed(种子)值相同,不管执行多少次,随机生成的数据是相同的
  8     private static Random r = new Random(47);
  9
 10     // Boolean Generator
 11     public static class GenBoolean implements Generator<Boolean> {
 12         @Override
 13         public Boolean next() {
 14             return r.nextBoolean(); // return next(1) != 0; 想生成范围在[0,1]的整数
 15         }
 16     }
 17
 18     // Byte Generator
 19     public static class GenByte implements Generator<Byte> {
 20         @Override
 21         public Byte next() {
 22             return (byte) r.nextInt(); // 随机生成一个整数,范围就是int类型的范围-2^31~2^31-1,这里会强制截取后8 bit作为byte值
 23         }
 24     }
 25
 26     // Character Generator
 27     public static class GenCharacter implements Generator<Character> {
 28
 29         private static char[] chars = ("abcdefghijklmnopqrstuvwxyz" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ").toCharArray();
 30
 31         @Override
 32         public Character next() {
 33             return chars[r.nextInt(GenCharacter.chars.length)]; // 生成范围在[0, chars.length)的整数
 34         }
 35     }
 36
 37     // String Generator
 38     public static class GenString implements Generator<String> {
 39         private int length = 7;
 40         Generator<Character> cg = new GenCharacter();
 41
 42         public GenString() {
 43         }
 44
 45         public GenString(int length) {
 46             this.length = length;
 47         }
 48
 49         @Override
 50         public String next() {
 51             char[] buf = new char[length];
 52             for (int i = 0; i < length; i++)
 53                 buf[i] = cg.next();
 54             return new String(buf);
 55         }
 56     }
 57
 58     // Short Generator
 59     public static class GenShort implements Generator<Short> {
 60
 61         @Override
 62         public Short next() {
 63             return (short) r.nextInt(); // 随机生成一个整数,范围就是int类型的范围-2^31~2^31-1,这里会强制截取后16 bit作为byte值
 64         }
 65     }
 66
 67     // Integer Generator
 68     public static class GenInteger implements Generator<Integer> {
 69         private int mod = 10000;
 70
 71         public GenInteger() {
 72         }
 73
 74         public GenInteger(int modulo) {
 75             mod = modulo;
 76         }
 77
 78         @Override
 79         public Integer next() {
 80             return r.nextInt(mod); // 随机生成一个整数,默认范围是[0, 10000)
 81         }
 82     }
 83
 84     // Long Generator
 85     public static class GenLong implements Generator<Long> {
 86         private int mod = 10000;
 87
 88         public GenLong() {
 89         }
 90
 91         public GenLong(int modulo) {
 92             mod = modulo;
 93         }
 94
 95         @Override
 96         public Long next() {
 97             return new Long(r.nextInt(mod));// 随机生成一个整数,默认范围是[0, 10000)
 98         }
 99     }
100
101     // Float Generator
102     public static class GenFloat implements Generator<Float> {
103         @Override
104         public Float next() {
105             int trimmed = Math.round(r.nextFloat() * 100);
106             return ((float) trimmed) / 100;
107         }
108     }
109
110     // Double Generator
111     public static class GenDouble implements Generator<Double> {
112         @Override
113         public Double next() {
114             long trimmed = Math.round(r.nextDouble() * 100);
115             return ((double) trimmed) / 100;
116         }
117     }
118 }
119
120 public class Test3 {
121     public static void main(String[] args) {
122         Generator<Boolean> a = new RandomGenerator.GenBoolean();
123         Generator<Integer> b = new RandomGenerator.GenInteger();
124         Generator<Float> c = new RandomGenerator.GenFloat();
125         generate(a, 5); // true false true false false
126         generate(b, 5); // 429 4868 200 4522 6207
127         generate(c, 5); // 0.27 0.95 0.26 0.11 0.05
128     }
129
130     private static <T> void generate(Generator<T> gen, int times) {
131         for (int i = 0; i < times; i++) {
132             System.out.print(gen.next() + " ");
133         }
134         System.out.println();
135     }
136 }

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

> 创建包装类型的数组

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

  1 import java.lang.reflect.Array;
  2 import java.util.ArrayList;
  3 import java.util.Arrays;
  4
  5 class CollectionData<T> extends ArrayList<T> {
  6
  7     private static final long serialVersionUID = 1L;
  8
  9     public CollectionData(Generator<T> gen, int quantity) {
 10         for (int i = 0; i < quantity; i++)
 11             add(gen.next());
 12     }
 13
 14     public static <T> CollectionData<T> list(Generator<T> gen, int quantity) {
 15         return new CollectionData<T>(gen, quantity);
 16     }
 17 }
 18
 19 class Generated {
 20     // Fill an existing array:
 21     public static <T> T[] array(T[] a, Generator<T> gen) {
 22         return new CollectionData<T>(gen, a.length).toArray(a);
 23     }
 24
 25     // Create a new array:
 26     public static <T> T[] array(Class<T> type, Generator<T> gen, int size) {
 27         @SuppressWarnings("unchecked")
 28         T[] a = (T[]) Array.newInstance(type, size);
 29         return new CollectionData<T>(gen, size).toArray(a);
 30     }
 31 }
 32
 33 class ConvertTo {
 34     public static boolean[] primitive(Boolean[] in) {
 35         boolean[] result = new boolean[in.length];
 36         for (int i = 0; i < in.length; i++)
 37             result[i] = in[i];
 38         return result;
 39     }
 40
 41     public static char[] primitive(Character[] in) {
 42         char[] result = new char[in.length];
 43         for (int i = 0; i < in.length; i++)
 44             result[i] = in[i];
 45         return result;
 46     }
 47
 48     public static byte[] primitive(Byte[] in) {
 49         byte[] result = new byte[in.length];
 50         for (int i = 0; i < in.length; i++)
 51             result[i] = in[i];
 52         return result;
 53     }
 54
 55     public static short[] primitive(Short[] in) {
 56         short[] result = new short[in.length];
 57         for (int i = 0; i < in.length; i++)
 58             result[i] = in[i];
 59         return result;
 60     }
 61
 62     public static int[] primitive(Integer[] in) {
 63         int[] result = new int[in.length];
 64         for (int i = 0; i < in.length; i++)
 65             result[i] = in[i];
 66         return result;
 67     }
 68
 69     public static long[] primitive(Long[] in) {
 70         long[] result = new long[in.length];
 71         for (int i = 0; i < in.length; i++)
 72             result[i] = in[i];
 73         return result;
 74     }
 75
 76     public static float[] primitive(Float[] in) {
 77         float[] result = new float[in.length];
 78         for (int i = 0; i < in.length; i++)
 79             result[i] = in[i];
 80         return result;
 81     }
 82
 83     public static double[] primitive(Double[] in) {
 84         double[] result = new double[in.length];
 85         for (int i = 0; i < in.length; i++)
 86             result[i] = in[i];
 87         return result;
 88     }
 89 }
 90
 91 public class Test4 {
 92     public static void main(String[] args) {
 93         Integer[] a = Generated.array(new Integer[5], new RandomGenerator.GenInteger());
 94         System.out.println(Arrays.toString(a)); // [9258, 555, 6693, 1861, 961]
 95         Long[] b = Generated.array(Long.class, new RandomGenerator.GenLong(), 5);
 96         System.out.println(Arrays.toString(b)); // [429, 4868, 200, 4522, 6207]
 97
 98         int[] c = ConvertTo.primitive(a);
 99         System.out.println(Arrays.toString(c)); // [9258, 555, 6693, 1861, 961]
100         long[] d = ConvertTo.primitive(b);
101         System.out.println(Arrays.toString(d)); // [429, 4868, 200, 4522, 6207]
102     }
103 }

原文地址:https://www.cnblogs.com/storml/p/8399747.html

时间: 2024-10-02 00:32:50

Java数组(3):创建测试数据的相关文章

Java数组的创建和初始化

我们说到数组,可能有的人就会比较害怕了,其实,数组只是把对象序列(很多个对象)或者基本类型序列(很多个基本类型)放在一起而已.数组是通过方括号下标操作符[]来定义和使用的.如果要定义,创建一个数组,只需在类型名后加上一对方括号[]即可.如果要定义二维数组,那么,就要加两个方括号[].可以多个维度联想一下,只要学会了一维数组,那么二维数组也是一维数组的扩展而已.而数组的初始化有下面两种方式. 特殊初始化 用new一个对象进行初始化 查看初始化示例,请看:break易站

Java学习小结(1)-数组的创建与传参

(一)数组的创建 数组的创建包括两部分:数组的申明与分配内存空间. int score[]=null; //申明一维数组 score=new int[3]; //分配长度为3的空间 数组的申明还有另外一种方式: int[] score=null; //把中括号写在数组名前面 通常,在写代码时,为了方便,我们将两行合并为一行: int score[]=new int score[3]; //将数组申明与分配内存写在一行 (二)传递参数 由于初学java,这里只讨论值传递,不考虑地址传递.主要有3点

java数组的声明、创建和遍历

一.数组的声明.创建 1.一维数组 先是声明 dataType[] arrayRefVar; // 首选的方法 数据类型[] 数组名; dataType arrayRefVar[]; // 效果相同,但不是首选方法 数据类型 数组名[]; 创建 (1) arrayRefVar = new dataType[arraySize]; 数组名 = new 数据类型[数组大小]; (2) dataType[] arrayRefVar = new dataType[arraySize]; 数据类型[] 数

Java 数组学习笔记

数组的简单认识 简单理解java数组,就是可以创建并组装它们,通过使用整型索引值访问它们的元素,并且它们的尺寸不能改变,这里的它们就是数组. 数组的特殊性 在java中有很多方式去持有对象,那么数组的与众不同点在哪里? 数组与其他种类的容器区别有三个方面:效率.类型和保存基本类型的能力. 在java中,数组是一种效率最高的存储和随机访问对象引用序列的方式.数组就是一个简单的线性序列,这使得元素访问非常迅速.但是为之付出的代价就是数组对象的大小被固定,并且在其生命周期中不可改变. 在泛型之前,其他

源码分析:Java堆的创建

虚拟机在内存中申请一片区域,由虚拟机自动管理,用来满足应用程序对象分配的空间需求,即堆空间. 由于程序运行的局部特性,程序创建的大多数对象都具有非常短的生命周期,而程序也会创建一些生命周期特别长的对象.简单的复制收集器无论对象的 生命周期是长是短,都会进行复制操作.而生命周期较长的对象在多次垃圾回收期间内并不会被回收,这就使得这些对象被来回复制而使得算法性能大大下降. 分代收集把堆分为多个子堆,分别用来存放不同寿命的对象.新生对象空间的将经历最频繁的垃圾回收,而对于经历了若干次垃圾收集后仍然存活

java数组和Array类

java数组英文:Arrays 存储相同数值的集合的数据结构 An array is a data structure that stores a collection of values of the same type. You accesseach individual value through an integer index. For example, if a is an array of integers, thena[i] is the ith integer in the a

Java数组操作十大方法

0.定义一个Java数组 String[] aArray = new String[5]; String[] bArray = {"a","b","c", "d", "e"}; String[] cArray = new String[]{"a","b","c","d","e"}; 第一种是定义了一个数组,并

浅析Java 数组-基础详解

什么是数组:数组对于每一门编程语言来说都是重要的数据结构之一,当然不同语言对数组的实现及处理也不尽相同. Java 数组:用来存储固定大小的同类型元素. 一 声明.创建,初始化Java 数组 写在前面:定义Java 数组包括声明和创建:可以先声明,再创建(两步):也可以同时声明和创建(一步). 1.声明 方法1(首选):dataType[] arrayName;  示例:String[] country; 方法2:dataType arrayName[]; : 示例:String country

Java——Java数组

数组对于每一门编辑应语言来说都是重要的数据结构之一. 声明数组变量 首先必须声明数组变量,才能在程序中使用数组.下面是声明数组变量的语法: double[] myList; // 首选的方法 或 double myList[]; // 效果相同,但不是首选方法 // 建议使用dataType[] arrayRefVar 的声明风格声明数组变量. dataType arrayRefVar[] 风格是来自 C/C++ 语言 ,在Java中采用是为了让 C/C++ 程序员能够快速理解java语言. 创