这篇来说说java中的 随机数 ，以及为什么说随机数是 伪随机 。
目录：
math.random() random类 伪随机 如何 优化 随机 封装的一个随机处理工具类1. math.random()
1.1 介绍
通过math.random()可以获取随机数，它返回的是一个[0.0, 1.0)之间的double值。
|
1 2 3 4 |
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整数。方法如下：
|
1 2 |
double d = math.random(); int i = ( int ) (d* 100 ); |
1.2 实现原理
|
1 2 3 4 5 6 7 |
private static final class randomnumbergeneratorholder { static final random randomnumbergenerator = new random(); }
public static double random() { return randomnumbergeneratorholder.randomnumbergenerator.nextdouble(); } |
可以看到math.random()方法最终也是调用random类中的方法。
2. random类
2.1 介绍
random类提供了两个构造器：
|
1 2 3 4 5 |
public random() { }
public random( long seed) { } |
一个是默认的构造器，一个是可以传入一个随机种子。
然后通过random对象获取随机数，如：
|
1 |
int r = random.nextint( 100 ); |
2.2 api
|
1 2 3 4 5 6 7 8 9 |
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 例子
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
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 = -5390332732391127434
b = 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
b = 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类构造器和属性：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
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()为例再继续分析：
|
1 2 3 4 5 6 7 8 9 |
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
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。
原文链接：https://blog.csdn.net/u014294681/article/details/86527930
查看更多关于浅谈Java随机数的原理、伪随机和优化的详细内容...