StdRandom提供一系列的靜態(tài)方法用于產生滿足多種需求的隨機數，具體代碼如下：

package crazymonkey.math;

import java.util.Random;

/**

* 此類提供一系列產生隨機數的方法，以滿足不同用例需要

* @author crazyMonkey

*/

public final class StdRandom {

//隨機數對象

private static Random random;

//用于產生隨機數的種子

private static long seed;

// 靜態(tài)初始化區(qū)域

static {

//產生隨機數種子

seed = System.currentTimeMillis();

random = new Random(seed);

}

private StdRandom() { }

/***********************************************************

* 產生基本的隨機數

***********************************************************/

/**

* 獲取此類實例的偽隨機種子生成器

*/

public static void setSeed(long s) {

seed = s;

random = new Random(seed);

}

/**

* 獲取此類實例提供的偽隨機種子生成器

*/

public static long getSeed() {

return seed;

}

/**

* 返回一個隨機的范圍在[0,1)之間的double類型的數

*/

public static double uniform() {

return random.nextDouble();

}

/**

* 返回一個隨機的范圍在[0,N)之間的int類型的數

*/

public static int uniform(int N) {

return random.nextInt(N);

}

/**

* 返回一個范圍在 [0, 1)的實數

*/

public static double random() {

return uniform();

}

/**

* 返回一個范圍在 [a, b)的int類型值

*/

public static int uniform(int a, int b) {

return a + uniform(b - a);

}

/**

* 返回一個范圍在 [a, b)的實數

*/

public static double uniform(double a, double b) {

return a + uniform() * (b-a);

}

/**

* 返回一個隨機boolean值,該p表示此布爾值為真的概率

* @param p 0~1 之間的double值,表示產生boolean真值的可能性

*/

public static boolean bernoulli(double p) {

return uniform() < p;

}

/**

* 返回一個隨機boolean值,此布爾值為真的概率為0.5

*/

public static boolean bernoulli() {

return bernoulli(0.5);

}

/***********************************************************

* 產生滿足特定概率分布的實數

***********************************************************/

/**

* 返回一個滿足標準正態(tài)分布的實數

*/

public static double gaussian() {

double r, x, y;

do {

x = uniform(-1.0, 1.0);

y = uniform(-1.0, 1.0);

r = x*x + y*y;

} while (r >= 1 || r == 0);

return x * Math.sqrt(-2 * Math.log(r) / r);

}

/**

* 返回一個滿足平均值為mean,標準差為stddev的正態(tài)分布的實數

* @param mean 正態(tài)分布的平均值

* @param stddev 正太分布的標準差

*/

public static double gaussian(double mean, double stddev) {

return mean + stddev * gaussian();

}

/**

* 返回一個滿足幾何分布的整型值 平均值為1/p

*/

public static int geometric(double p) {

// Knuth

return (int) Math.ceil(Math.log(uniform()) / Math.log(1.0 - p));

}

/**

* 根據指定的參數返回一個滿足泊松分布的實數

*/

public static int poisson(double lambda) {

// 使用 Knuth 的算法

// 參見

int k = 0;

double p = 1.0;

double L = Math.exp(-lambda);

do {

k++;

p *= uniform();

} while (p >= L);

return k-1;

}

/**

* 根據指定的參數按返回一個滿足帕雷托分布的實數

*/

public static double pareto(double alpha) {

return Math.pow(1 - uniform(), -1.0/alpha) - 1.0;

}

/**

* 返回一個滿足柯西分布的實數

*/

public static double cauchy() {

return Math.tan(Math.PI * (uniform() - 0.5));

}

/**

* 返回一個滿足離散分布的int類型的數

* @param a 算法產生隨機數過程中需要使用此數組的數據，a[i]代表i出現的概率

* 前提條件 a[i] 非負切和接近 1.0

*/

public static int discrete(double[] a) {

double EPSILON = 1E-14;

double sum = 0.0;

for (int i = 0; i < a.length; i++) {

if (a[i] < 0.0) throw new IllegalArgumentException("數組元素 " + i + " 為負數: " + a[i]);

sum = sum + a[i];

}

if (sum > 1.0 + EPSILON || sum < 1.0 - EPSILON)

throw new IllegalArgumentException("數組各個元素之和為: " + sum);

while (true) {

double r = uniform();

sum = 0.0;

for (int i = 0; i < a.length; i++) {

sum = sum + a[i];

if (sum > r) return i;

}

}

}

/**

* 返回一個滿足指數分布的實數，該指數分布比率為lambda

*/

public static double exp(double lambda) {

return -Math.log(1 - uniform()) / lambda;

}

/***********************************************************

* 數組操作

***********************************************************/

/**

* 隨機打亂指定的Object型數組

* @param a 待打亂的Object型數組

*/

public static void shuffle(Object[] a) {

int N = a.length;

for (int i = 0; i < N; i++) {

int r = i + uniform(N-i);

Object temp = a[i];

a[i] = a[r];

a[r] = temp;

}

}

/**

* 隨機打亂指定的double型數組

* @param a 待打亂的double型數組

*/

public static void shuffle(double[] a) {

int N = a.length;

for (int i = 0; i < N; i++) {

int r = i + uniform(N-i);

double temp = a[i];

a[i] = a[r];

a[r] = temp;

}

}

/**

* 隨機打亂指定的int型數組

* @param a 待打亂的int型數組

*/

public static void shuffle(int[] a) {

int N = a.length;

for (int i = 0; i < N; i++) {

int r = i + uniform(N-i);

int temp = a[i];

a[i] = a[r];

a[r] = temp;

}

}

/**

* 隨機打亂指定Object類型數組中指定范圍的數據

*

* @param a 指定的數組

* @param lo 起始位置

* @param hi 結束位置

*/

public static void shuffle(Object[] a, int lo, int hi) {

if (lo < 0 || lo > hi || hi >= a.length) {

throw new IndexOutOfBoundsException("不合法的邊界");

}

for (int i = lo; i <= hi; i++) {

int r = i + uniform(hi-i+1);

Object temp = a[i];

a[i] = a[r];

a[r] = temp;

}

}

/**

* 隨機打亂指定double類型數組中指定范圍的數據

*

* @param a 指定的數組

* @param lo 起始位置

* @param hi 結束位置

*/

public static void shuffle(double[] a, int lo, int hi) {

if (lo < 0 || lo > hi || hi >= a.length) {

throw new IndexOutOfBoundsException("不合法的邊界");

}

for (int i = lo; i <= hi; i++) {

int r = i + uniform(hi-i+1);

double temp = a[i];

a[i] = a[r];

a[r] = temp;

}

}

/**

* 隨機打亂指定int類型數組中指定范圍的數據

*

* @param a 指定的數組

* @param lo 起始位置

* @param hi 結束位置

*/

public static void shuffle(int[] a, int lo, int hi) {

if (lo < 0 || lo > hi || hi >= a.length) {

throw new IndexOutOfBoundsException("不合法的邊界");

}

for (int i = lo; i <= hi; i++) {

int r = i + uniform(hi-i+1);

int temp = a[i];

a[i] = a[r];

a[r] = temp;

}

}

}

更多信息請查看IT技術專欄