剖析JDK源码-Random -(12)

一、简述

该类的实例用于生成伪随机数。该类使用原值为48位的种子，其使用线性同余公式进行修改。如果使用相同的种子创建两个Random，并且对每个实例进行相同的方法调用该序列，则它们将生成并返回相同的数字序列。通过调用私有方法next(int bits)方法可以提供多达32个伪随机生成位。java.util.Random是线程安全的。但是，跨线程的同时使用java.util.Random实例可能会遇到争用，从而导致性能下降。但java.util.Random并不是加密安全的。

二、类及常量的声明

public class Random implements java.io.Serializable {   	//使用JDK 1.1中的serialVersionUID实现互操作性 	static final long serialVersionUID = 3905348978240129619L; 	//与这个伪随机数生成器相关联的内部状态。 	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; 	// 异常信息    static final String BadBound = "bound must be positive";    static final String BadRange = "bound must be greater than origin";    static final String BadSize  = "size must be non-negative";}

三、构造方法

创建一个新的随机数生成器。 System.nanoTime()返回运行中的Java虚拟机的高分辨率时间源的当前值，以纳秒为单位。

使用单个 long类型的参数创建一个新的随机数生成器。

public Random() {           this(seedUniquifier() ^ System.nanoTime());    }	 public Random(long seed) {           if (getClass() == Random.class)            this.seed = new AtomicLong(initialScramble(seed));        else {               this.seed = new AtomicLong();            setSeed(seed);        }    }

四、内部方法

1、 public void nextBytes(byte[] bytes)；生成随机字节并将它们放入用户提供的字节数组中。产生的随机字节数等于字节数组的长度。

public void nextBytes(byte[] bytes) {           for (int i = 0, len = bytes.length; i < len; )            for (int rnd = nextInt(),                     n = Math.min(len - i, Integer.SIZE/Byte.SIZE);                 n-- > 0; rnd >>= Byte.SIZE)                bytes[i++] = (byte)rnd;    }

2、返回下一个伪随机数，从这个随机数生成器的序列中均匀分布int值。所有可能的int值以（大约）相等的概率产生。范围（0-2³² ）不包含2³² 获取指定值。

public int nextInt() {           return next(32);    }    public int nextInt(int bound) {           if (bound <= 0)            throw new IllegalArgumentException(BadBound);        int r = next(31);        int m = bound - 1;        if ((bound & m) == 0)  // i.e., bound is a power of 2            r = (int)((bound * (long)r) >> 31);        else {               for (int u = r;                 u - (r = u % bound) + m < 0;                 u = next(31))                ;        }        return r;}

3、返回下一个伪随机数，从这个随机数发生器的序列中均匀分布long值。
因为Random类使用只有48位的种子，所以该算法并不会返回所有可能的long值。

public long nextLong() {           // it's okay that the bottom word remains signed.        return ((long)(next(32)) << 32) + next(32);    }

4、返回下一个伪随机数，从这个随机数发生器的序列中均匀分布boolean值。值true和false以（大概）相等的概率产生。

public boolean nextBoolean() {           return next(1) != 0;    }

5、这个随机数生成器的序列中返回下一个伪随机、均匀分布的浮点值在0.0到1.0之间。

public float nextFloat() {           return next(24) / ((float)(1 << 24));    }

6、从这个随机数生成器的序列中返回下一个伪随机、均匀分布的双精度值在0.0到1.0之间。

public double nextDouble() {           return (((long)(next(26)) << 27) + next(27)) * DOUBLE_UNIT;    }

7、从该随机数发生器的序列返回下一个伪随机数，高斯（“正”）分布 double值，平均值为 0.0 ，标准差为 1.0 。

synchronized public double nextGaussian() {           // See Knuth, ACP, Section 3.4.1 Algorithm C.        if (haveNextNextGaussian) {               haveNextNextGaussian = false;            return nextNextGaussian;        } else {               double v1, v2, s;            do {                   v1 = 2 * nextDouble() - 1; // between -1 and 1                v2 = 2 * nextDouble() - 1; // between -1 and 1                s = v1 * v1 + v2 * v2;            } while (s >= 1 || s == 0);            double multiplier = StrictMath.sqrt(-2 * StrictMath.log(s)/s);            nextNextGaussian = v2 * multiplier;            haveNextNextGaussian = true;            return v1 * multiplier;        }    }

转载地址：http://jhao.baihongyu.com/

你可能感兴趣的文章