您好,登录后才能下订单哦!
小编给大家分享一下Java随机数之原理、伪随机和优化的示例分析,相信大部分人都还不怎么了解,因此分享这篇文章给大家参考一下,希望大家阅读完这篇文章后大有收获,下面让我们一起去了解一下吧!
1. Math.random()
1.1 介绍
通过Math.random()可以获取随机数,它返回的是一个[0.0, 1.0)之间的double值。
private static void testMathRandom() { double random = Math.random(); System.out.println("random = " + random); }
执行输出:random = 0.8543235849742018
Java中double在32位和64位机器上都是占8个字节,64位,double正数部分和小数部分最多17位有效数字。
如果要获取int类型的整数,只需要将上面的结果转行成int类型即可。比如,获取[0, 100)之间的int整数。方法如下:
double d = Math.random(); int i = (int) (d*100);
1.2 实现原理
private static final class RandomNumberGeneratorHolder { static final Random randomNumberGenerator = new Random(); } public static double random() { return RandomNumberGeneratorHolder.randomNumberGenerator.nextDouble(); }
先获取一个Random对象,在Math中是单例模式,唯一的。
调用Random对象的nextDouble方法返回一个随机的double数值。
可以看到Math.random()方法最终也是调用Random类中的方法。
2. Random类
2.1 介绍
Random类提供了两个构造器:
public Random() { } public Random(long seed) { }
一个是默认的构造器,一个是可以传入一个随机种子。
然后通过Random对象获取随机数,如:
int r = random.nextInt(100);
2.2 API
boolean nextBoolean() // 返回一个boolean类型随机数 void nextBytes(byte[] buf) // 生成随机字节并将其置于字节数组buf中 double nextDouble() // 返回一个[0.0, 1.0)之间的double类型的随机数 float nextFloat() // 返回一个[0.0, 1.0) 之间的float类型的随机数 int nextInt() // 返回一个int类型随机数 int nextInt(int n) // 返回一个[0, n)之间的int类型的随机数 long nextLong() // 返回一个long类型随机数 synchronized double nextGaussian() // 返回一个double类型的随机数,它是呈高斯(正常地)分布的 double值,其平均值是0.0,标准偏差是1.0。 synchronized void setSeed(long seed) // 使用单个long种子设置此随机数生成器的种子
2.3 例子
private static void testRandom(Random random) { // 获取随机的boolean值 boolean b = random.nextBoolean(); System.out.println("b = " + b); // 获取随机的数组buf[] byte[] buf = new byte[5]; random.nextBytes(buf); System.out.println("buf = " + Arrays.toString(buf)); // 获取随机的Double值,范围[0.0, 1.0) double d = random.nextDouble(); System.out.println("d = " + d); // 获取随机的float值,范围[0.0, 1.0) float f = random.nextFloat(); System.out.println("f = " + f); // 获取随机的int值 int i0 = random.nextInt(); System.out.println("i without bound = " + i0); // 获取随机的[0,100)之间的int值 int i1 = random.nextInt(100); System.out.println("i with bound 100 = " + i1); // 获取随机的高斯分布的double值 double gaussian = random.nextGaussian(); System.out.println("gaussian = " + gaussian); // 获取随机的long值 long l = random.nextLong(); System.out.println("l = " + l); } public static void main(String[] args) { testRandom(new Random()); System.out.println("\n\n"); testRandom(new Random(1000)); testRandom(new Random(1000)); }
执行输出:
b = true
buf = [-55, 55, -7, -59, 86]
d = 0.6492428743107401
f = 0.8178623
i without bound = -1462220056
i with bound 100 = 66
gaussian = 0.3794413450456145
l = -5390332732391127434b = true
buf = [47, -38, 53, 63, -72]
d = 0.46028809169559504
f = 0.015927613
i without bound = 169247282
i with bound 100 = 45
gaussian = -0.719106498075259
l = -7363680848376404625b = true
buf = [47, -38, 53, 63, -72]
d = 0.46028809169559504
f = 0.015927613
i without bound = 169247282
i with bound 100 = 45
gaussian = -0.719106498075259
l = -7363680848376404625
可以看到,一次运行过程中,如果种子相同,产生的随机值也是相同的。
总结一下:
1. 同一个种子,生成N个随机数,当你设定种子的时候,这N个随机数是什么已经确定。相同次数生成的随机数字是完全相同的。
2. 如果用相同的种子创建两个Random 实例,则对每个实例进行相同的方法调用序列,它们将生成并返回相同的数字序列。
2.4 实现原理
先来看看Random类构造器和属性:
private final AtomicLong seed; private static final long multiplier = 0x5DEECE66DL; private static final long addend = 0xBL; private static final long mask = (1L << 48) - 1; private static final double DOUBLE_UNIT = 0x1.0p-53; // 1.0 / (1L << 53) private static final AtomicLong seedUniquifier = new AtomicLong(8682522807148012L); public Random() { this(seedUniquifier() ^ System.nanoTime()); } private static long seedUniquifier() { for (;;) { long current = seedUniquifier.get(); long next = current * 181783497276652981L; if (seedUniquifier.compareAndSet(current, next)) return next; } } public Random(long seed) { if (getClass() == Random.class) this.seed = new AtomicLong(initialScramble(seed)); else { this.seed = new AtomicLong(); setSeed(seed); } } synchronized public void setSeed(long seed) { this.seed.set(initialScramble(seed)); haveNextNextGaussian = false; }
有两个构造器,有一个无参,一个可以传入种子。
种子的作用是什么?
种子就是产生随机数的第一次使用值,机制是通过一个函数,将这个种子的值转化为随机数空间中的某一个点上,并且产生的随机数均匀的散布在空间中,以后产生的随机数都与前一个随机数有关。
无参的通过seedUniquifier() ^ System.nanoTime()生成一个种子,里面使用了CAS自旋锁实现。使用System.nanoTime()方法来得到一个纳秒级的时间量,参与48位种子的构成,然后还进行了一个很变态的运算:不断乘以181783497276652981L,直到某一次相乘前后结果相同来进一步增大随机性,这里的nanotime可以算是一个真随机数,不过有必要提的是,nanoTime和我们常用的currenttime方法不同,返回的不是从1970年1月1日到现在的时间,而是一个随机的数:只用来前后比较计算一个时间段,比如一行代码的运行时间,数据库导入的时间等,而不能用来计算今天是哪一天。
不要随便设置随机种子,可能运行次数多了会获取到相同的随机数,Random类自己生成的种子已经能满足平时的需求了。
以nextInt()为例再继续分析:
protected int next(int bits) { long oldseed, nextseed; AtomicLong seed = this.seed; do { oldseed = seed.get(); nextseed = (oldseed * multiplier + addend) & mask; } while (!seed.compareAndSet(oldseed, nextseed)); return (int)(nextseed >>> (48 - bits)); }
还是通过CAS来实现,然后进行位移返回,这块的算法比较复杂,就不深入研究了。
3. 伪随机
3.1 什么是伪随机?
(1) 伪随机数是看似随机实质是固定的周期性序列,也就是有规则的随机。
(2) 只要这个随机数是由确定算法生成的,那就是伪随机,只能通过不断算法优化,使你的随机数更接近随机。(随机这个属性和算法本身就是矛盾的)
(3) 通过真实随机事件取得的随机数才是真随机数。
3.2 Java随机数产生原理
Java的随机数产生是通过线性同余公式产生的,也就是说通过一个复杂的算法生成的。
3.3 伪随机数的不安全性
Java自带的随机数函数是很容易被黑客破解的,因为黑客可以通过获取一定长度的随机数序列来推出你的seed,然后就可以预测下一个随机数。比如eos的dapp竞猜游戏,就因为被黑客破解了随机规律,而盗走了大量的代币。
4. 如何优化随机
主要要考虑生成的随机数不能重复,如果重复则重新生成一个。可以用数组或者Set存储来判断是否包含重复的随机数,配合递归方式来重新生成一个新的随机数。
5. 封装的一个随机处理工具类
https://github.com/kuangzhongwen/android-common-libs/blob/master/src/main/java/waterhole/commonlibs/utils/RandomUtils.java
以上是“Java随机数之原理、伪随机和优化的示例分析”这篇文章的所有内容,感谢各位的阅读!相信大家都有了一定的了解,希望分享的内容对大家有所帮助,如果还想学习更多知识,欢迎关注亿速云行业资讯频道!
免责声明:本站发布的内容(图片、视频和文字)以原创、转载和分享为主,文章观点不代表本网站立场,如果涉及侵权请联系站长邮箱:is@yisu.com进行举报,并提供相关证据,一经查实,将立刻删除涉嫌侵权内容。