java隨機數生成器

一.java.lang.Math.Random

       調用這個Math.Random()函數可以返回帶正號的double值，取值範圍是[0.0,1.0)的左閉右開區間，並在該範圍內（近似）均勻分佈。

二.java.util.Random

• 經常使用函數

1. protected int next(int bits)：生成下一個僞隨機數。
2. boolean nextBoolean()：返回下一個僞隨機數，它是取自此隨機數生成器序列的均勻分佈的boolean值。
3. void nextBytes(byte[] bytes)：生成隨機字節並將其置於用戶提供的 byte 數組中。
4. double nextDouble()：返回下一個僞隨機數，它是取自此隨機數生成器序列的、在0.0和1.0之間均勻分佈的 double值。
5. float nextFloat()：返回下一個僞隨機數，它是取自此隨機數生成器序列的、在0.0和1.0之間均勻分佈float值。
6. double nextGaussian()：返回下一個僞隨機數，它是取自此隨機數生成器序列的、呈高斯（「正態」）分佈的double值，其平均值是0.0標準差是1.0。
7. int nextInt()：返回下一個僞隨機數，它是此隨機數生成器的序列中均勻分佈的 int 值。
8. int nextInt(int n)：返回一個僞隨機數，它是取自此隨機數生成器序列的、在（包括和指定值（不包括）之間均勻分佈的int值。
9. long nextLong()：返回下一個僞隨機數，它是取自此隨機數生成器序列的均勻分佈的 long 值。
10. void setSeed(long seed)：使用單個 long 種子設置此隨機數生成器的種子。

• 構造函數

1. public Random()  該構造方法使用一個和當前系統時間對應的相對時間有關的數字做爲種子數，而後使用這個種子數構造Random對象。
2. public Random(long seed) 該構造方法能夠經過制定一個種子數進行建立。

• 總結：

1.  種子數只是隨機算法的起源數字，和生成的隨機數字的區間無關；相同種子數的Random對象，相同次數生成的隨機數字是徹底相同的；
2. 生成[0,n)區間的數有公式Math.abs(nextInt()%n)和nextInt(n)
3. 生成任意區間[a,b)，公式nextInt(b-a)+a和Math.abs(nextInt()%(b-a)+a
4. 生成任意區間[a,b],公式nextInt(b+1-a)+a和Math.abs(nextInt()%(b+1-a)+a)

示例代碼：

package com.random;

import java.util.Random;

import org.junit.After;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;

public class testRandom {

    private static Random r1;
    private static Random r2;

    /**
     * @Title: loadUp
     * @Description: 測試以前的初始化工做
     */
    @BeforeClass
    public static void loadUp() {
        r1 = new Random(10);
        r2 = new Random(10);
    }

    @After
    public void testAfter() {
        System.out.println("------------------------>");
    }

    /**
     * @Title: testMathRandom
     * @Description: 經過Math.random產生[0,5)之間的數
     * @throws
     */
    @Ignore
    @Test
    public void testMathRandom() {
        for (int i = 0; i < 20; i++) {
            System.out.println((int) (Math.random() * 5));
        }
    }

    /**
     * @Title: testTwoRandom
     * @Description: 兩個random對象，具備相同的種子，會產生相同的隨機數(僞隨機)
     */
    @Test
    public void testTwoRandom() {
        for (int i = 0; i < 10; ++i) {
            Assert.assertEquals(r1.nextInt(), r2.nextInt());
        }
    }

    /**
     * @Title: testRandom1
     * @Description: 產生[1,2.5)之間的數的，有公式 nextDouble()*(b-a)+a
     * @param 設定文件
     * @return void 返回類型
     * @throws
     */
    @Test
    @Ignore
    public void testRandom1() {
        for (int i = 0; i < 10; ++i) {
            System.out.println(r1.nextDouble() * 1.5 + 1);
        }
    }

    /**
     * @Title: testRandom2
     * @Description: 產生[0,10)的兩種方法，生成[0,n)區間的數有公式Math.abs(nextInt()%n)和nextInt(n)
     */
    @Test
    @Ignore
    public void testRandom2() {
        for (int i = 0; i < 10; ++i) {
            System.out.println("方法一: " + r1.nextInt(10));
            System.out.println("方法二: " + Math.abs(r2.nextInt() % 10));
        }
    }

    /**
     * @Title: testNextBoolean
     * @Description: 生成一個隨機的boolean值,true和false值均等
     */
    @Test
    @Ignore
    public void testNextBoolean() {
        for (int i = 0; i < 10; ++i) {
            System.out.println(r1.nextBoolean());
        }
    }

    /**
     * @Title: testNextInt
     * @Description: 生成一個-2^31~2^31-1之間的隨機數
     */
    @Test
    @Ignore
    public void testNextInt() {
        for (int i = 0; i < 10; ++i) {
            System.out.println(Math.abs(r1.nextInt()));// 0~2^31-1
            System.out.println(r1.nextInt());// -2^31~2^31-1
            System.out.println(r1.nextInt(10));// [0,10)，參數10爲隨機生成數字的上限
        }
    }
    
    /**
    * @Title: testNextDouble 
    * @Description: 隨機生成[0,1.0)區間的小數
     */
    @Test
    @Ignore
    public void testNextDouble() {
        for (int i = 0; i < 10; ++i) {
            System.out.println(r1.nextDouble());
        }
    }
    
    /**
    * @Title: testRandom3 
    * @Description: 生成任意區間[a,b)，公式nextInt(b-a)+a和Math.abs(nextInt()%(b-a)+a),例如區間[-3,15)
     */
    @Test
    @Ignore
    public void testRandom3() {
        for (int i = 0; i < 100; ++i) {
            System.out.println(r1.nextInt(18) - 3);
            System.out.println(Math.abs(r1.nextInt()%18)-3);
        }
    }
    
    /**
    * @Title: testRandom4 
    * @Description: 生成任意區間[a,b],公式nextInt(b+1-a)+a和Math.abs(nextInt()%(b+1-a)+a)，例如區間[3,10]
     */
    @Test
    public void testRandom4(){
        for(int i=0;i<20;++i){
            System.out.println(r1.nextInt(8)+3);
        }
    }
}

三.能夠經過java.util.Random實現概率控制

      在前面的方法介紹中，nextInt(int n)方法中生成的數字是均勻的，也就是說該區間內部的每一個數字生成的概率是相同的。那麼若是生成一個[0,100)區間的隨機整數，則每一個數字生成的概率應該是相同的，並且因爲該區間中總計有100個整數，因此每一個數字的概率都是1%。按照這個理論，能夠實現程序中的概率問題。

示例代碼：

@Test
    public void testRandom5() {
        for (int i = 0; i < 100; ++i) {
            int a = r1.nextInt(100);
            if (a < 55) {
                System.out.println("1");// 55%的概率
            } else if (a < 95) {
                System.out.println("2");// 40%的概率
            } else {
                System.out.println("3");// 5%的概率
            }
        }
    }