计算机程序的思惟逻辑 (34) - 随机

时间  2019-11-17
标签 计算机 程序 思惟 逻辑 随机 繁體版
原文   原文链接

本系列文章经补充和完善，已修订整理成书《Java编程的逻辑》（马俊昌著），由机械工业出版社华章分社出版，于2018年1月上市热销，读者好评如潮！各大网店和书店有售，欢迎购买：京东自营连接 html

随机

本节，咱们来讨论随机，随机是计算机程序中一个很是常见的需求，好比说：java

  • 各类游戏中有大量的随机，好比扑克游戏洗牌
  • 微信抢红包，抢的红包金额是随机的
  • 北京购车摇号，谁能摇到是随机的
  • 给用户生成随机密码

咱们首先来介绍Java中对随机的支持，同时介绍其实现原理，而后咱们针对一些实际场景，包括洗牌、抢红包、摇号、随机高强度密码、带权重的随机选择等，讨论如何应用随机。算法

先来看如何使用最基本的随机。编程

Math.random

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

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

个人电脑上的一次运行，输出为：安全

0.4784896133823269
0.03012515628333423
0.7921024363953197
复制代码

每次运行，输出都不同。bash

Math.random()是如何实现的呢？咱们来看相关代码：微信

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变量只有在第一次使用的时候才建立。多线程

下面咱们来看这个Random类，它位于包java.util下。并发

Random

基本用法

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

Random rnd = new Random();
System.out.println(rnd.nextInt());
System.out.println(rnd.nextInt(100));
复制代码

个人电脑上的一次运行，输出为：

-1516612608
23
复制代码

nextInt()产生一个随机的int，可能为正数，也可能为负数，nextInt(100)产生一个随机int，范围是0到100，包括0不包括100。

除了nextInt，还有一些别的方法。

随机生成一个long

public long nextLong() 复制代码

随机生成一个boolean

public boolean nextBoolean() 复制代码

产生随机字节

public void nextBytes(byte[] bytes) 复制代码

随机产生的字节放入提供的byte数组bytes，字节个数就是bytes的长度。

产生随机浮点数，从0到1，包括0不包括1

public float nextFloat() public double nextDouble() 复制代码

设置种子

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

public Random(long seed) 复制代码

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

Random rnd = new Random(20160824);
for(int i=0;i<5;i++){
    System.out.print(rnd.nextInt(100)+" ");
}
复制代码

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

69 13 13 94 50 
复制代码

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

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

synchronized public void setSeed(long seed) 复制代码

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

为何要指定种子呢？指定种子仍是真正的随机吗？

指定种子是为了实现可重复的随机。好比用于模拟测试程序中，模拟要求随机，但测试要求可重复。在北京购车摇号程序中，种子也是指定的，后面咱们还会介绍。

种子到底扮演了什么角色呢？随机究竟是如何产生的呢？让咱们看下随机的基本原理。

随机的基本原理

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

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

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

Random的默认构造方法中没有传递种子，它会自动生成一个种子，这个种子数是一个真正的随机数，代码以下：

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都是为了确保在多线程的环境下不会有两次调用返回相同的值，保证随机性。

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

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)，生成指定位数的随机数，咱们来看下它的代码：

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));
}
复制代码

简单的说，就是使用了以下公式：

nextseed = (oldseed * multiplier + addend) & mask;
复制代码

旧的种子(oldseed)乘以一个数(multiplier)，加上一个数addend，而后取低48位做为结果(mask相与)。

为何采用这个方法？这个方法为何能够产生随机数？这个方法的名称叫线性同余随机数生成器(linear congruential pseudorandom number generator)，描述在《计算机程序设计艺术》一书中。随机的理论是一个比较复杂的话题，超出了本文的范畴，咱们就不讨论了。

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

理解了随机的基本概念和原理，咱们来看一些应用场景，从产生随机密码开始。

随机密码

在给用户生成帐号时，常常须要给用户生成一个默认随机密码，而后经过邮件或短信发给用户，做为初次登陆使用。

咱们假定密码是6位数字，代码很简单，以下所示：

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

代码很简单，就不解释了。若是要求是8位密码，字符可能有大写字母、小写字母、数字和特殊符号组成，代码可能为：

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

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

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

这个代码，对每一个字符，先随机选类型，而后在给定类型中随机选字符。在个人电脑上，一次的随机运行结果是：

8Ctp2S4H
复制代码

这个结果不含特殊字符，不少环境对密码复杂度有要求，好比说，至少要含一个大写字母、一个小写字母、一个特殊符号、一个数字。以上的代码知足不了这个要求，怎么知足呢？一种可能的代码是：

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

private static char nextSpecialChar(Random rnd){
    return SPECIAL_CHARS.charAt(rnd.nextInt(SPECIAL_CHARS.length()));
}
private static char nextUpperlLetter(Random rnd){
    return (char)('A'+rnd.nextInt(26));
}
private static char nextLowerLetter(Random rnd){
    return (char)('a'+rnd.nextInt(26));
}
private static char nextNumLetter(Random rnd){
    return (char)('0'+rnd.nextInt(10));
}
public static String randomPassword(){
    char[] chars = new char[8];
    Random rnd = new Random();
    
    chars[nextIndex(chars, rnd)] = nextSpecialChar(rnd);
    chars[nextIndex(chars, rnd)] = nextUpperlLetter(rnd);
    chars[nextIndex(chars, rnd)] = nextLowerLetter(rnd);
    chars[nextIndex(chars, rnd)] = nextNumLetter(rnd);
    
    for(int i=0; i<8; i++){
        if(chars[i]==0){
            chars[i] = nextChar(rnd);    
        }
    }
    return new String(chars);
}
复制代码

nextIndex随机生成一个未赋值的位置，程序先随机生成四个不一样类型的字符，放到随机位置上，而后给未赋值的其余位置随机生成字符。

洗牌

一种常见的随机场景是洗牌，就是将一个数组或序列随机从新排列，咱们以一个整数数组为例来看，怎么随机重排呢？咱们直接看代码：

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 rnd = new Random();
    for(int i=arr.length; i>1; i--) {
        swap(arr, i-1, rnd.nextInt(i));
    }
}
复制代码

shuffle这个方法就能将参数数组arr随机重排，来看使用它的代码：

int[] arr = new int[13];
for(int i=0; i<arr.length; i++){
    arr[i] = i;
}
shuffle(arr);
System.out.println(Arrays.toString(arr));
复制代码

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

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

已经随机从新排序了。

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

swap(arr, i-1, rnd.nextInt(i));
复制代码

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

带权重的随机选择

实际场景中，常常要从多个选项中随机选择一个，不过，不一样选项常常有不一样的权重。

好比说，给用户随机奖励，三种面额，1元、5元和10元，权重分别为70, 20和10。这个怎么实现呢？

实现的基本思路是，使用几率中的累计几率分布。

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

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

下面来看代码，咱们使用一个类Pair表示选项和权重，代码为： 

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表示带权重的选择，代码为：

public class WeightRandom {
    private Pair[] options;
    private double[] cumulativeProbabilities;
    private Random rnd;
    
    public WeightRandom(Pair[] options){
        this.options = options;
        this.rnd = 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;
        }
    }
    
    public Object nextItem(){
        double randomValue = rnd.nextDouble();

        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次，代码为：

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.print(rnd.nextItem()+" ");
}
复制代码

在一次运行中，输出正好符合预期，具体为：

1元 1元 1元 2元 1元 10元 1元 2元 1元 1元 
复制代码

不过，须要说明的，因为随机，每次执行结果比例不必定正好相等。

抢红包算法

咱们都知道，微信能够抢红包，红包有一个总金额和总数量，领的时候随机分配金额，金额是怎么随机分配的呢？微信具体是怎么作的，咱们并不能确切的知道，根据一些公开资料，思路可能以下。

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

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

public class RandomRedPacket {

    private int leftMoney;
    private int leftNum;
    private Random rnd;
    
    public RandomRedPacket(int total, int num){
        this.leftMoney = total;
        this.leftNum = num;
        this.rnd = new Random();
    }
    
    public synchronized int nextMoney(){
        if(this.leftNum<=0){
            throw new IllegalStateException("抢光了");
        }
        if(this.leftNum==1){
            return this.leftMoney;
        }
        double max = this.leftMoney/this.leftNum*2d;
        int money = (int)(rnd.nextDouble()*max);
        money = Math.max(1, money);
        this.leftMoney -= money;
        this.leftNum --;
        
        return money;
    }
}
复制代码

代码比较简单，就不解释了。咱们来看一个使用的例子，总金额为10元，10个红包，代码以下：

RandomRedPacket redPacket = new RandomRedPacket(1000, 10);
for(int i=0; i<10; i++){
    System.out.print(redPacket.nextMoney()+" ");
}
复制代码

一次输出为：

136 48 90 151 36 178 92 18 122 129 
复制代码

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

北京购车摇号算法

咱们来看下影响不少人的北京购车摇号，它的算法是怎样的呢？根据公开资料，它的算法大概是这样的。

  1. 每期摇号前，将每一个符合摇号资格的人，分配一个从0到总数的编号，这个编号是公开的，好比总人数为2304567，则编号从0到2304566。
  2. 摇号第一步是生成一个随机种子数，这个随机种子数在摇号当天经过必定流程生成，整个过程由公证员公证，就是生成一个真正的随机数。
  3. 种子数生成后，而后就是循环调用相似Random.nextInt(int n)方法，生成中签的编号。

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

一些说明

须要说明的是，Random类是线程安全的，也就是说，多个线程能够同时使用一个Random实例对象，不过，若是并发性很高，会产生竞争，这时，能够考虑使用多线程库中的ThreadLocalRandom类。

另外，Java类库中还有一个随机类SecureRandom，以产生安全性更高、随机性更强的随机数，用于安全加密等领域。

这两个类本文就不介绍了。

小结

本节介绍了随机，介绍了Java中对随机的支持Math.random()以及Random类，介绍了其使用和实现原理，同时，咱们介绍了随机的一些应用场景，包括随机密码、洗牌、带权重的随机选择、微信抢红包和北京购车摇号。

至此，关于一些基本经常使用类的介绍，咱们就告一段落了，回顾一下，咱们深刻剖析了各类包装类、String、StringBuilder、Arrays、日期和时间、Joda-Time以及随机，这些都是平常程序中常常用到的功能。

以前章节中，咱们常常提到泛型这一律念，是时候具体讨论一下了。

未完待续，查看最新文章，敬请关注微信公众号“老马说编程”(扫描下方二维码)，深刻浅出，老马和你一块儿探索Java编程及计算机技术的本质。用心原创，保留全部版权。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程