private static void testMathRandom() {
    double random = Math.random();
    System.out.println("random = " + random);
  }

double d = Math.random();
int i = (int) (d*100);

  private static final class RandomNumberGeneratorHolder {
    static final Random randomNumberGenerator = new Random();
  }
 
  public static double random() {
    return RandomNumberGeneratorHolder.randomNumberGenerator.nextDouble();
  }

  public Random() {
  }
 
  public Random(long seed) {
  }

int r = random.nextInt(100);

boolean nextBoolean()     // 返回一個(gè)boolean類型隨機(jī)數(shù)
void  nextBytes(byte[] buf) // 生成隨機(jī)字節(jié)并將其置于字節(jié)數(shù)組buf中 
double nextDouble()     // 返回一個(gè)[0.0, 1.0)之間的double類型的隨機(jī)數(shù)
float  nextFloat()      // 返回一個(gè)[0.0, 1.0) 之間的float類型的隨機(jī)數(shù)
int   nextInt()       // 返回一個(gè)int類型隨機(jī)數(shù)
int   nextInt(int n)    // 返回一個(gè)[0, n)之間的int類型的隨機(jī)數(shù)
long  nextLong()      // 返回一個(gè)long類型隨機(jī)數(shù) 
synchronized double nextGaussian()  // 返回一個(gè)double類型的隨機(jī)數(shù)，它是呈高斯（正常地）分布的 double值，其平均值是0.0，標(biāo)準(zhǔn)偏差是1.0。 
synchronized void setSeed(long seed) // 使用單個(gè)long種子設(shè)置此隨機(jī)數(shù)生成器的種子

 private static void testRandom(Random random) {
    // 獲取隨機(jī)的boolean值
    boolean b = random.nextBoolean();
    System.out.println("b = " + b);
 
    // 獲取隨機(jī)的數(shù)組buf[]
    byte[] buf = new byte[5];
    random.nextBytes(buf);
    System.out.println("buf = " + Arrays.toString(buf));
 
    // 獲取隨機(jī)的Double值，范圍[0.0, 1.0)
    double d = random.nextDouble();
    System.out.println("d = " + d);
 
    // 獲取隨機(jī)的float值，范圍[0.0, 1.0)
    float f = random.nextFloat();
    System.out.println("f = " + f);
 
    // 獲取隨機(jī)的int值
    int i0 = random.nextInt();
    System.out.println("i without bound = " + i0);
 
    // 獲取隨機(jī)的[0,100)之間的int值
    int i1 = random.nextInt(100);
    System.out.println("i with bound 100 = " + i1);
 
    // 獲取隨機(jī)的高斯分布的double值
    double gaussian = random.nextGaussian();
    System.out.println("gaussian = " + gaussian);
 
    // 獲取隨機(jī)的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));
  }

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

  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));
  }