Java——随机 - 技术栈

随机

1、Math.random

Java中，对随机最基本的支持是Math类中的静态方法random()，它生成一个0～1的随机数，类型为double，包括0但不包括1。比如，随机生成并输出3个数：

java 复制代码

for(int i=0; i<3; i++){
    System.out.println(Math.random());
}

java 复制代码

0.07585360896312643
0.7862599957247403
0.2948433312723595

每次运行，输出都不一样。Math.random()是如何实现的呢？我们来看相关代码（Java 7）：

java 复制代码

private static Random randomNumberGenerator;
private static synchronized Random initRNG() {
    Random rnd = randomNumberGenerator;
    return (rnd == null) ? (randomNumberGenerator = new Random()) : rnd;
}
public static double random() {
    Random rnd = randomNumberGenerator;
    if (rnd == null) rnd = initRNG();
    return rnd.nextDouble();
}

内部它使用了一个Random类型的静态变量randomNumberGenerator，调用random()就是调用该变量的nextDouble()方法，这个Random变量只有在第一次使用的时候才创建。

2、Random

Random类提供了更为丰富的随机方法，它的方法不是静态方法，使用Random，先要创建一个Random实例，看个例子：

java 复制代码

Random rnd = new Random();
System.out.println(rnd.nextInt());
System.out.println(rnd.nextInt(100));

java 复制代码

-1516612608
23

nextInt()产生一个随机的int，可能为正数，也可能为负数，nextInt(100)产生一个随机int，范围是0～100，包括0不包括100。除了nextInt，还有一些别的方法：

java 复制代码

public long nextLong() //随机生成一个long
public boolean nextBoolean() //随机生成一个boolean
public void nextBytes(byte[] bytes) //产生随机字节， 字节个数就是bytes的长度
public float nextFloat() //随机浮点数，从0到1，包括0不包括1
public double nextDouble() //随机浮点数，从0到1，包括0不包括1

除了默认构造方法，Random类还有一个构造方法，可以接受一个long类型的种子参数：

java 复制代码

public Random(long seed)

种子决定了随机产生的序列，种子相同，产生的随机数序列就是相同的。看个例子：

java 复制代码

public static void main(String[] args) {
    Random md = new Random(20160824);
    for(int i = 0; i < 5; i++) {
        System.out.print(md.nextInt(100) + " ");
    }
}

种子为20160824，产生5个0～100的随机数，输出为：

java 复制代码

69 13 13 94 50

这个程序无论执行多少遍，在哪执行，输出结果都是相同的。

除了在构造方法中指定种子，Random类还有一个setter实例方法：

java 复制代码

synchronized public void setSeed(long seed)

其效果与在构造方法中指定种子是一样的。

为什么要指定种子呢？指定种子还是真正的随机吗？指定种子是为了实现可重复的随机。比如用于模拟测试程序中，模拟要求随机，但测试要求可重复。在北京购车摇号程序中，种子也是指定的。

3、随机的基本原理

Random产生的随机数不是真正的随机数，相反，它产生的随机数一般称为伪随机数。真正的随机数比较难以产生，计算机程序中的随机数一般都是伪随机数。

伪随机数都是基于一个种子数的，然后每需要一个随机数，都是对当前种子进行一些数学运算，得到一个数，基于这个数得到需要的随机数和新的种子。

数学运算是固定的，所以种子确定后，产生的随机数序列就是确定的，确定的数字序列当然不是真正的随机数，但种子不同，序列就不同，每个序列中数字的分布也都是比较随机和均匀的，所以称之为伪随机数。

Random的默认构造方法中没有传递种子，它会自动生成一个种子，这个种子数是一个真正的随机数，如下所示（Java 7）：

java 复制代码

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

种子是seedUniquifier()与System.nanoTime()按位异或的结果，System.nanoTime()返回一个更高精度（纳秒）的当前时间，seedUniquifier()里面的代码涉及一些多线程相关的知识，我们后续章节再介绍，简单地说，就是返回当前seedUniquifier（current变量）与一个常数181783497276652981L相乘的结果（next变量），然后，设置seedUniquifier的值为next，使用循环和compareAndSet都是为了确保在多线程的环境下不会有两次调用返回相同的值，保证随机性。

有了种子数之后，其他数是怎么生成的呢？我们来看一些代码：

java 复制代码

public int nextInt() {
   return next(32);
}
public long nextLong() {
   return ((long)(next(32)) << 32) + next(32);
}
public float nextFloat() {
   return next(24) / ((float)(1 << 24));
}
public boolean nextBoolean() {
   return next(1) ! = 0;
}

它们都调用了next(int bits)，生成指定位数的随机数，我们来看下它的代码：

java 复制代码

private static final long multiplier = 0x5DEECE66DL;
private static final long addend = 0xBL;
private static final long mask = (1L << 48) - 1;
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));
}

简单地说，就是使用了如下公式：

java 复制代码

nextseed = (oldseed ＊ multiplier + addend) & mask;

旧的种子（oldseed）乘以一个数（multiplier），加上一个数addend，然后取低48位作为结果（mask相与）。

为什么采用这个方法？这个方法为什么可以产生随机数？这个方法的名称叫线性同余随机数生成器（linearcongruential pseudorandom number generator），描述在《计算机程序设计艺术》一书中。

我们需要知道的基本原理是：随机数基于一个种子，种子固定，随机数序列就固定，默认构造方法中，种子是一个真正的随机数。

4、随机密码

在给用户生成账号时，经常需要给用户生成一个默认随机密码，然后通过邮件或短信发给用户，作为初次登录使用。我们假定密码是6位数字，代码很简单，如下所示。

java 复制代码

public static String randomPassword() {
    char[] chars = new char[6];
    Random random = new Random();
    for (int i = 0; i < 6; i++) {
        chars[i] = (char)('0' + random.nextInt(10));
    }
    return new String(chars);
}

代码很简单，就不解释了。如果要求是8位密码，字符可能由大写字母、小写字母、数字和特殊符号组成，如代码所示。

java 复制代码

private static final String SPECIAL_CHARS = "! @#$%^&*_=+-/";

public static char nextChar(Random random) {
    switch (random.nextInt(4)) {
        case 0:
            return (char)('a' + random.nextInt(26));
        case 1:
            return (char)('A' + random.nextInt(26));
        case 2:
            return (char)('0' + random.nextInt(10));
        default:
            return SPECIAL_CHARS.charAt(random.nextInt(SPECIAL_CHARS.length()));
    }
}

public static String randomPassword() {
    char[] chars = new char[8];
    Random random = new Random();
    for(int i = 0; i < 8; i++) {
        chars[i] = nextChar(random);
    }
    return new String(chars);
}

这段代码，对每个字符，先随机选类型，然后在给定类型中随机选字符。

复制代码

@6L6^vo6
03#0857+
*@=61AY&
Ln^L*576
31578X_S

这个结果不含特殊字符。很多环境对密码复杂度有要求，比如，至少要含一个大写字母、一个小写字母、一个特殊符号、一个数字。以上的代码满足不了这个要求，怎么满足呢？一种可能的代码如下所示。

java 复制代码

    private static final String SPECIAL_CHARS = "! @#$%^&*_=+-/";

    public static char nextChar(Random random) {
        switch (random.nextInt(4)) {
            case 0:
                return (char)('a' + random.nextInt(26));
            case 1:
                return (char)('A' + random.nextInt(26));
            case 2:
                return (char)('0' + random.nextInt(10));
            default:
                return SPECIAL_CHARS.charAt(random.nextInt(SPECIAL_CHARS.length()));
        }
    }

    private static int nextIndex(char[] chars, Random random) {
        int index = random.nextInt(chars.length);
        while (chars[index] != 0) {
            index = random.nextInt(chars.length);
        }
        return index;
    }

    private static char nextSpecialChar(Random random) {
        return SPECIAL_CHARS.charAt(random.nextInt(SPECIAL_CHARS.length()));
    }

    private static char nextUpperLetter(Random random) {
        return (char)('A' + random.nextInt(26));
    }

    private static char nextLowerLetter(Random random) {
        return (char)('a' + random.nextInt(26));
    }

    private static char nextNumLetter(Random random) {
        return (char)('0' + random.nextInt(10));
    }

    public static String randomPassword() {
        char[] chars = new char[8];
        Random random = new Random();
        chars[nextIndex(chars, random)] = nextSpecialChar(random);
        chars[nextIndex(chars, random)] = nextUpperLetter(random);
        chars[nextIndex(chars, random)] = nextLowerLetter(random);
        chars[nextIndex(chars, random)] = nextNumLetter(random);
        for(int i = 0; i < 8; i++) {
            if(chars[i] == 0) {
                chars[i] = nextChar(random);
            }
        }
        return new String(chars);
    }

nextIndex随机生成一个未赋值的位置，程序先随机生成4个不同类型的字符，放到随机位置上，然后给未赋值的其他位置随机生成字符。

5、洗牌

一种常见的随机场景是洗牌，就是将一个数组或序列随机重新排列。我们以一个整数数组为例来介绍如何随机重排，如代码所示。

java 复制代码

    private static void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

    public static void shuffle(int[] arr) {
        Random random = new Random();
        for (int i = arr.length; i > 1; i--) {
            swap(arr, i - 1, random.nextInt(i));
        }
    }

调用shuffle方法前，arr是排好序的，调用后，一次调用的输出为：

java 复制代码

[10, 1, 4, 5, 3, 12, 11, 8, 0, 7, 6, 9, 2]

已经随机重新排序了。shuffle的基本思路是什么呢？从后往前，逐个给每个数组位置重新赋值，值是从剩下的元素中随机挑选的。在如下关键语句中：

java 复制代码

swap(arr, i-1, rnd.nextInt(i));

i-1表示当前要赋值的位置，rnd.nextInt(i)表示从剩下的元素中随机挑选。

6、带选中的随机选择

实际场景中，经常要从多个选项中随机选择一个，不过，不同选项经常有不同的权重。比如，给用户随机奖励，三种面额：1元、5元和10元，权重分别为70、20和10。这个怎么实现呢？实现的基本思路是，使用概率中的累计概率分布。

以上面的例子来说，计算每个选项的累计概率值，首先计算总的权重，这里正好是100，每个选项的概率是70%、20%和10%，累计概率则分别是70%、90%和100%。

有了累计概率，则随机选择的过程是：使用nextDouble()生成一个0～1的随机数，然后使用二分查找，看其落入哪个区间，如果小于等于70%则选择第一个选项，70%和90%之间选第二个，90%以上选第三个，如图所示。

1元	5元	10元
0.7	0.9	1.0

下面来看代码，我们使用一个类Pair表示选项和权重，如代码所示。

java 复制代码

class Pair {
    Object item;
    int weight;

    public Pair(Object item, int weight) {
        this.item = item;
        this.weight = weight;
    }

    public Object getItem() {
        return item;
    }

    public int getWeight() {
        return weight;
    }
}

我们使用一个类WeightRandom表示带权重的选择，如代码所示。

java 复制代码

public class WeightRandom {
    private Pair[] options;//权重
    private double[] cumulativeProbabilities;//累计概率
    private Random random;
    public WeightRandom(Pair[] options) {
        this.options = options;
        this.random = new Random();
        prepare();
    }

    private void prepare() {
        int weights = 0;//总权重
        for(Pair pair : options) {
            weights += pair.getWeight();
        }
        cumulativeProbabilities = new double[options.length];

        int sum = 0;
        for (int i = 0; i < options.length; i++) {
            sum += options[i].getWeight();
            //计算累计概率
            cumulativeProbabilities[i] = sum / (double)weights;
            System.out.println(cumulativeProbabilities[i]);
        }
    }

    public Object nextItem() {
        double randomValue = random.nextDouble();
        //查找概率区间
        //如果未找到，则返回负数，其绝对值代表第一个 > randomValue 的元素位置；
        //如果所有元素大于所有元素，则返回数组长度
        //公式为 -(insertion point) - 1
        //[0.1, 0.2, 0.3, 0.4, 0.5, 0.6]  查找0.15 返回 -2 实际该插入位置为：-(-2) - 1 = 1
        int index = Arrays.binarySearch(cumulativeProbabilities, randomValue);
        if(index < 0) {
            index = -index - 1;
        }
        return options[index].getItem();
    }
}

其中，prepare()方法计算每个选项的累计概率，保存在数组cumulativeProbabilities中， nextItem()方法根据权重随机选择一个，具体就是，首先生成一个0～1的数，然后使用二分查找，如果没找到，返回结果是-（插入点）-1，所以-index-1就是插入点，插入点的位置就对应选项的索引。

回到上面的例子，随机选择10次，代码为：

java 复制代码

    public static void main(String[] args) {
        Pair[] options = new Pair[] {
                new Pair("1元", 7),
                new Pair("2元", 2),
                new Pair("10元", 1)
        };
        WeightRandom rnd = new WeightRandom(options);
        for (int i = 0; i < 10; i++) {
            System.out.println(rnd.nextItem());
        }
    }

复制代码

0.7
0.9
1.0
1元
1元
1元
1元
1元
2元
10元
2元
1元
2元

7、抢红包算法

我们都知道，微信可以抢红包，红包有一个总金额和总数量，领的时候随机分配金额。金额是怎么随机分配的呢？微信具体是怎么做的，我们并不能确切地知道，但如下思路可以达到该效果。

维护一个剩余总金额和总数量，分配时，如果数量等于1，直接返回总金额，如果大于1，则计算平均值，并设定随机最大值为平均值的两倍，然后取一个随机值，如果随机值小于0.01，则为0.01，这个随机值就是下一个的红包金额。

二倍均值算法：

每个人领到的最大金额 = （剩余总金额 / 剩余人数）✖️ 2

实际情况：随着剩余人数减少，基数变小，二倍均值的上限可能相对放宽。如果前面几个人都是极小值（0.01元），最后一个人可能领到剩余的大部分金额（前提是不超过200硬性上限）

我们来看代码，如代码所示，为计算方便，金额用整数表示，以分为单位。

java 复制代码

public class RandomRedPacket {
    private int leftMoney;//剩余金额
    private int leftNum;//剩余人数
    private Random random;
    
    public RandomRedPacket(int total, int num) {
        this.leftMoney = total;
        this.leftNum = num;
        this.random = new Random();
    }
    
    public synchronized int nextMoney() {
        if(this.leftNum <= 0) {
            throw new IllegalArgumentException(("强光了"));
        }
        if(this.leftNum == 1) {
            return this.leftMoney;
        }
        //当前轮次均值
        double max = this.leftMoney / this.leftNum * 2d;
        //本次红包金额
        int money = (int)(random.nextDouble() * max);
        //最少为1分
        money = Math.max(1, money);
        //剩余红包金额
        this.leftMoney -= money;
        //剩余人数
        this.leftNum--;
        return money;
    }
}

看一个使用的例子，总金额为10元，10个红包，代码如下：

java 复制代码

public static void main(String[] args) {
    RandomRedPacket randomRedPacket = new RandomRedPacket(1000, 10);
    for (int i = 0; i < 10; i++) {
        System.out.println(randomRedPacket.nextMoney());
    }
}

复制代码

如果是这个算法，那先抢好，还是后抢好呢？先抢肯定抢不到特别大的，不过，后抢也不一定会，这要看前面抢的金额，剩下的多就有可能抢到大的，剩下的少就不可能有大的。

8、北京购车摇号算法

我们来看下影响很多人的北京购车摇号，它的算法是怎样的呢？思路大概是这样的：

每期摇号前，将每个符合摇号资格的人，分配一个从0到总数的编号，这个编号是公开的，比如总人数为2 304567，则编号为0～2 304 566。（实际情况会有阶梯加倍，比如多次不中，或无车家庭，会多分配连续几个编号放入其中，增加概率）
摇号第一步是生成一个随机种子数，这个随机种子数在摇号当天通过一定流程生成，整个过程由公证员公证，就是生成一个真正的随机数。
种子数生成后，然后就是循环调用类似Random.nextInt(int n)方法，生成中签的编号。

编号是事先确定的，种子数是当场公证随机生成的，是公开的，随机算法是公开透明的，任何人都可以根据公开的种子数和编号验证中签的编号。