精华内容
下载资源
问答
  • JAVA伪随机数

    千次阅读 2019-05-08 16:45:17
    今天要讲的是Random生成的随机数是伪随机数,为什么说Random生成的随机数是伪随机数?是因为只要两个Random对象的种子相同,而且方法的调用顺序也相同,产生的随机数相同。我们来看一下。 首先第一步:创建一个 ...
    作者:孙英鹏  撰写时间:2019年5月8日
    

    今天要讲的是Random生成的随机数是伪随机数,为什么说Random生成的随机数是伪随机数?是因为只要两个Random对象的种子相同,而且方法的调用顺序也相同,产生的随机数相同。我们来看一下。

    首先第一步:创建一个 Java 文件名为 dome(名字随便命名),创建完之后,写上代码。(看图1)

    图1:

    在这里插入图片描述

    先写上Random类,在括号里写一个数(我这里写的是16),是为16的Random对象,接下来是写打印的代码,获取上面的 r1,然后再加上.nextBoolean,括号里写上数字(我这里写的是20),nextBoolean 是返回下一个伪随机数,它是取自此随机数生成器序列的均匀分布 的 boolean 值。

    第二步:复制,把r1的代码复制到下来。(看图1)

    结果:
    在这里插入图片描述

    得出来的结果是一样的,所以说Random生成的随机数是伪随机数。

    展开全文
  • java-Random类(伪随机数)学习

    千次阅读 2019-07-05 11:25:56
    1、什么是伪随机数,为什么是伪随机数? 查看jdk文档可以看到,Random生成的是伪随机数。 什么是伪随机数呢?java是通过一个“种子”,然后经过算法计算产生的随机数。如果种子相同,则产生的随机数序列也就相同...

    1、什么是伪随机数,为什么是伪随机数?

    查看jdk文档可以看到,Random生成的是伪随机数。

    什么是伪随机数呢?java是通过一个“种子”,然后经过算法计算产生的随机数。如果种子相同,则产生的随机数序列也就相同,这不是我们所想的真正的随机数。

    大部分程序和语言中的随机数,确实都只是伪随机。是由可确定的函数(常用线性同余),通过一个种子(常用时钟),产生的。这意味着:如果知道了种子,或者已经产生的随机数,都可能获得接下来随机数序列的信息(可预测性)。

    直观来想,计算机就是一种确定的,可预测的的设备:一行行的代码是固定的,一步步的算法是固定的,一个个与非门是固定的。通过这些固定的东西自身产生真随机,当然不可能。

     

    详细内容可参考:

    https://www.zhihu.com/question/20423025/answer/15097735

    2、构造方法

    带参构造,需要我们提供一个long型的seed,内部通过种子产生随机数。所以如果我们提供的seed相同产生的随机数也是一样的:

    public static void main(String[] args) throws InterruptedException {
            // 提供seed
            System.out.println("提供seed的带参构造");
            for (int i = 0; i < 5; i++) {
                Random random = new Random(100);
                int j = 0;
                while (j < 5) {
                    System.out.print(random.nextInt(100) + ", ");
                    j++;
                }
                System.out.println();
            }
    
            // 无参构造
            System.out.println("无参构造");
            for (int i = 0; i < 5; i++) {
                Random random = new Random();
                int j = 0;
                while (j < 5) {
                    System.out.print(random.nextInt(100) + ", ");
                    j++;
                }
                System.out.println();
            }
        }
    /*  输出结果:
    提供seed的带参构造
    15, 50, 74, 88, 91, 
    15, 50, 74, 88, 91, 
    15, 50, 74, 88, 91, 
    15, 50, 74, 88, 91, 
    15, 50, 74, 88, 91, 
    无参构造
    39, 67, 76, 76, 20, 
    97, 59, 48, 49, 41, 
    92, 4, 70, 97, 31, 
    34, 6, 46, 16, 1, 
    45, 67, 38, 56, 35, 
    */

    参看源码可以看到,无参构造会调用带参构造,并提供一个跟时间有关的seed。

    参考:

    Java 解惑:Random 种子的作用、含参与不含参构造函数区别

    https://blog.csdn.net/hanghangde/article/details/50705672

    3、常用方法

    void setSeed(long seed)方法的作用是给Random对象设置seed

    Random r = new Random(seed) ;等同于 Random r = new Random(); r.setSeed(seed);

    所有的nextXxx()方法都是直接或间接调用next()方法

    int nextInt(int bound)方法可以指定[0,bound)区间的随机数(不包含bound)

    4、Math.random()

    可以看到Math.random()实际上使用的是Random类的nextDouble()方法

     

    展开全文
  • java伪随机数

    2019-04-22 01:22:28
    NULL 博文链接:https://lan-qie.iteye.com/blog/1947295
  • Java安全伪随机数生成器 此目录包含为Apigee Edge编译简单的Java标注所需的Java源代码和pom.xml文件。 标注使用java.security.SecureRandom在策略Apigee Edge代理内生成随机数(int,UUID或高斯值),并使用该信息...
  • import java.util.Random; public class RandomDemo { public static void main(String[] args) { Random random = new Random(); // [0, bound) System.out.println(random.nextInt(10)); // 8 /

    Random获取随机数

    package com.example.demo;
    
    import java.util.Random;
    
    public class RandomDemo {
        public static void main(String[] args) {
            Random random = new Random();
    
            // 指定边界 [0, bound)
            System.out.println(random.nextInt(10));
            // 8
    
            // [0, 1)
            System.out.println(Math.random());
            // 0.4743026139690609
        }
    }
    
    

    更多随机数据获取方法

    用到的依赖

    <dependency>
        <groupId>commons-lang</groupId>
        <artifactId>commons-lang</artifactId>
        <version>2.6</version>
    </dependency>
    

    示例

    package com.demo.random;
    
    import org.apache.commons.lang.RandomStringUtils;
    
    import java.security.NoSuchAlgorithmException;
    import java.security.SecureRandom;
    import java.util.Random;
    import java.util.concurrent.ThreadLocalRandom;
    
    public class RandomDemo {
        public static void main(String[] args) throws NoSuchAlgorithmException {
            // 1、Random
            Random random = new Random();
            System.out.println(random.nextDouble());
    
    
            // 2、Math.random
            System.out.println(Math.random());
    
    
            // 3、ThreadLocalRandom
            System.out.println(ThreadLocalRandom.current().nextDouble());
    
    
            // 4、SecureRandom
            SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
            System.out.println(secureRandom.nextDouble());
    
    
            // 5、RandomStringUtils
            String result = RandomStringUtils.random(64);
            System.out.println(result);
    
            // 长度为64位的字符串
            result = RandomStringUtils.randomAlphabetic(64);
            System.out.println(result);
    
            // 32位ascii码
            result = RandomStringUtils.randomAscii(32);
            System.out.println(result);
    
            // 指定字符数组
            result = RandomStringUtils.random(32, "qw32rfHIJk9iQ8Ud7h0X");
            System.out.println(result);
    
            /**
             * 0.6842526472648046
             * 0.968969349495142
             * 0.27962124767826213
             * 0.012367070163319283
             * 汕真庣뉔햯殫腍ꡊꁝ㨂Ǒ蒐霫瓯䟤ሠ漧ᎊ򜐍끘෦𧆕惘횕緛暑⫺ꟻ䟻↕㽱륪鶋㛿ᔑ㓇䢙뿍鼗ꦡ첡缹﷪濎릅솣떽裴ﱆ뙠曜蘝せⶏ潻➣▨澜채
             * niSaTPTkUfrdqjcgFbZcyAqdGsnZQKoKSWpUxYSffMDiNBMVBcGfkxGOphVkAhMe
             * :xB__?hx/W,,?7bEdr@~E4GjLh6yxp0U
             * I80QH8Uffwkh8r03ddrrHHUk8w9h0rJw
             */
        }
    }
    
    

    参考
    Java 生成随机数的 5 种方式,你知道几种?

    展开全文
  • 详细介绍了ThreadLocalRandom伪随机数生成器的原理,以及对Random的优化!

    详细介绍了ThreadLocalRandom伪随机数生成器的原理,以及对Random的优化!

    1 伪随机数

    简单的了解一下伪随机数的概念。

    通过固定算法产生的随机数都是伪随机数,Java语言的随机数生成器或者说整个计算机中的随机数函数,生成的都是伪随机数。只有通过真实的随机事件产生的随机数才是真随机数。比如,通过机器的硬件、CPU温度、当天天气、噪音等真随机事件产生随机数,如果想要产生真随机数,那么需要一定的物理手段,开销极大,或许得不偿失!因此目前的随机数都是通过一个非常复杂的算法计算出来的!

    Random生成的随机数都是伪随机数,是由可确定的函数(常用线性同余算法),通过一个seed(种子,常用时钟),产生的伪随机数。这意味着:如果知道了种子,或者已经产生的随机数,都可能获得接下来随机数序列的信息(可预测性)。

    我们对两个Random对象指定相同的种子,测试结果如下:

    //新建random对象,指定种子
    Random random1 = new Random(100);
    //生成10个[0,100)的伪随机数
    for (int i = 0; i < 10; i++) {
        System.out.print(random1.nextInt(100) + "    ");
    }
    System.out.println();
    System.out.println("===============");
    //新建random对象,指定种子
    Random random2 = new Random(100);
    //生成10个[0,100)的伪随机数
    for (int i = 0; i < 10; i++) {
        System.out.print(random2.nextInt(100) + "    ");
    }
    
    

    由于算法一样,当时用了相同的seed(种子),生成了一样的伪随机数,结果为:

    15    50    74    88    91    66    36    88    23    13    
    ===============
    15    50    74    88    91    66    36    88    23    13
    

    这里不讨论过多的真随机数和伪随机数,主要是讲解Random和新的ThreadLocalRandom这个两个类的性能差异的原理。

    2 Random

    Random是非常常见的伪随机数生成工具类,而且java.Iang.Math 中的伪随机数生成使用的也是Random 的实例。

    @Test
    public void test1() {
        //新建random对象,使用默认种子
        Random random = new Random();
        ///生成10个[0,100)的伪随机数
        for (int i = 0; i < 10; i++) {
            System.out.print(random.nextInt(100) + "    ");
        }
        double random1 = Math.random();
    }
    
    @Test
    public void test4() {
        //Math.random()用于生成[0.0,1.0)之间的double正数
        for (int i = 0; i < 10; i++) {
            System.out.println(Math.random());
        }
        //Math.random()内部也是使用的Random类
        //public static double random() {
        //    return RandomNumberGeneratorHolder.randomNumberGenerator.nextDouble();
        //}
    
        //private static final class RandomNumberGeneratorHolder {
        //    static final Random randomNumberGenerator = new Random();
        //}
    }
    

    2.1 随机数的生成和局限性

    随机数的生成需要一个默认的long类型的“种子”,可以在创建Random 对象时通过构造函数指定,如果不指定则在默认构造函数内部生成一个默认的值。这个种子用于生成第一个随机数,并且生成下一个随机数种子,之后的以后产生的随机数都与前一个随机数种子有关。

    随机数的生成逻辑主要在nextint方法中。主要分为两步:

    1. 根据老的send(种子)生成新的种子,并且初步生成随机数r;
    2. 对伪随机数r使用固定算法进行进一步处理,最后返回。
    /**
     * @param bound 要返回的随机数的上限范围。必须为正数。
     * @return 返回位于[0, bound]之间的伪随机整数
     * @throws IllegalArgumentException 如果 n 不是正数
     */
    public int nextInt(int bound) {
        //bound小于等于0则抛出异常
        if (bound <= 0)
            throw new IllegalArgumentException(BadBound);
        //初步生成伪随机数r以及更新下一个种子值
        int r = next(31);
        //对r使用固定算法进行进一步处理
        int m = bound - 1;
        if ((bound & m) == 0)  // i.e., bound is a power of 2
            r = (int) ((bound * (long) r) >> 31);
        else {
            for (int u = r;
                 u - (r = u % bound) + m < 0;
                 u = next(31))
                ;
        }
        return r;
    }
    

    在多线程环境下Random也能正常使用,主要是得益于next方法中生成下一个种子的CAS处理:

    /**
     * @param bits 随机数位
     * @return 初步生的成随机数,以及下一个种子
     */
    protected int next(int bits) {
        long oldseed, nextseed;
        //获取此时的seed,可以看到种子变量是使用AtomicLong变量来保存的
        AtomicLong seed = this.seed;
        do {
            //获取此时最新的seed值oldseed
            oldseed = seed.get();
            //计算下一个seed值nextseed
            nextseed = (oldseed * multiplier + addend) & mask;
            //尝试CAS的将seed从oldseed更新为nextseed值,成功后返回,失败重试
            //这里保证了多线程下数据的安全性,即每一个线程都不会获得错误或者重复的随机数
        } while (!seed.compareAndSet(oldseed, nextseed));
        //根据新种子计算出随机数并返回
        return (int) (nextseed >>> (48 - bits));
    }
    
    /**
     * 种子
     */
    private final AtomicLong seed;
    
    /**
     * 构造器
     */
    public Random() {
        //调用有参构造器,采用时钟System.nanoTime()进行计算作为初始种子
        this(seedUniquifier() ^ System.nanoTime());
    }
    

    CAS 操作保证每次只有一个线程可以获取并成功更新种子,失败的线程则需要自旋重试,自旋的时候又会获取最新的种子。因此每一个线程最终总会计算出不同的种子,保证了多线程环境下的数据安全。初始种子可以自己指定,没有参数的构造器中采用当前时间戳来计算种子。

    在多线程下使用单个Random 实例生成随机数时,可能会存在多个线程同时尝试CAS更新同一个种子的操作,CAS保证并发操作只有一个线程能够成功,其他线程则会自旋重试,保证了线程安全。但是如果大量线程频繁的尝试生成随机数,那么可能会造成大量线程因为失败而自旋重试,降低并发性能,消耗CPU资源。因此在JDK1.7的时候出现了ThreadLocalRandom ,就是为了解决这个问题!

    3 ThreadLocalRandom

    3.1 概述

    public class ThreadLocalRandom
    extends Random

    ThreadLocalRandom 类来自于JDK 1.7的JUC包,继承并扩展了Random类,主要是弥补了Random类在多线程下由于竞争同一个seed造成性能低下的缺陷。

    简单的说就是一个线程隔离的随机数生成器,使用了ThreadLocal的机制(ThreadLocal源码深度解析与应用案例)。因此ThreadLocalRandom非常适合在并发程序中使用,比如在线程池中需要使用随机数的时候时!

    不同于Random多个线程共享一个seed种子,每个线程维护自己的一个普通long类型的种子变量,就是Thread中的threadLocalRandomSeed变量,每个线程生成随机数时候根据自己老的种子计算新的种子,并使用新种子更新老的种子,然后根据新种子计算随机数,这样就不会存在竞争问题,这会大大提高并发性能。ThreadLocalRandom类似于ThreadLocal,就像是一个工具,对外提供API方法,实际的种子数据都是每一个线程自己保存。

    ThreadLocalRandom内部的属性操作使用到了Unsafe类,这是一个根据字段偏移量来操作对象的字段的类,是JUC包实现的底层基石类,Unsafe直接操作JVM内存,效率更高,同时也提供了CAS实现的Java本地接口!

    在这里插入图片描述

    简单使用方法如下,我们不需要像Random那样建立一个全局ThreadLocalRandom对象,而是在当前线程中获取即可!

    public static void main(String[] args) {
        Run run = new Run();
        new Thread(run).start();
        new Thread(run).start();
    }
    
    
    static class Run implements Runnable {
    
        @Override
        public void run() {
            //获取ThreadLocalRandom伪随机数生成器
            ThreadLocalRandom current = ThreadLocalRandom.current();
            ///生成10个[0,100)的伪随机数
            for (int i = 0; i < 10; i++) {
                System.out.print(current.nextInt(100) + "    ");
            }
            System.out.println(Thread.currentThread().getName());
        }
    }
    

    3.2 current方法

    public static ThreadLocalRandom current()

    ThreadLocalRandom的构造函数是私有的,只能使用静态工厂方法ThreadLocalRandom.current()返回它的实例–instance。instance 是ThreadLocalRandom 的一个static final属性,该变量是static 的。在ThreadLocalRandom类加载的初始化阶段就初始化好了的,因此实际上不同的线程的current()方法返回的是同一个对象,这是单例模式的应用。

    当线程调用ThreadLocalRandom.current静态方法时候,ThreadLocalRandom就会初始化调用线程的threadLocalRandomSeed变量,也就是当前线程的初始化种子。另外返回的ThreadLocalRandom对象实际上是在ThreadLocalRandom类加载的初始化阶段就初始化好了的,因此实际上不同的线程的current方法返回的是同一个对象,这是一个工作方法。

    该静态方法获取 ThreadLocalRandom 实例,并初始化调用线程中 threadLocalRandomSeed 和 threadLocalRandomProbe 变量。源码如下:

    //Thread中保存的变量,只能在当前线程中被访问,使用了缓存填充(注解方式)来避免伪共享。
    
    /**
     * 线程本地随机的当前种子。
     */
    @sun.misc.Contended("tlr")
    long threadLocalRandomSeed;
    
    /**
     * 探测哈希值;如果线程本地随机种子被初始化,那么该值也非0。使用缓存填充(注解方式)来避免伪共享。
     */
    @sun.misc.Contended("tlr")
    int threadLocalRandomProbe;
    
    
    //ThreadLocalRandom中保存的变量和方法
    
    /**
     * 单例对象,在类加载的时候就被初始化了,后续的线程每次都是获取同一个实例
     */
    static final ThreadLocalRandom instance = new ThreadLocalRandom();
    
    /**
     * @return 返回当前线程的 ThreadLocalRandom
     */
    public static ThreadLocalRandom current() {
        //使用UNSAFE获取当前线程对象的PROBE偏移量处的int类型的值(PROBE就是static静态块中获取的threadLocalRandomProbe变量的偏移量)
        //如果等于0(每一个线程的threadLocalRandomProbe变量在默认情况下是没有初始化的,默认值就是0)
        //说明当前线程第一次调用 ThreadLocalRandom 的 current 方法,那么就需要调用 localInit 方法计算当前线程的初始化种子变量。
        if (UNSAFE.getInt(Thread.currentThread(), PROBE) == 0)
            //初始化种子
            localInit();
        //返回单例
        return instance;
    }
    
    /**
     * 初始化种子
     */
    static final void localInit() {
        int p = probeGenerator.addAndGet(PROBE_INCREMENT);
        //跳过0
        int probe = (p == 0) ? 1 : p; //
        long seed = mix64(seeder.getAndAdd(SEEDER_INCREMENT));
        //获取当前线程
        Thread t = Thread.currentThread();
        //设置当前线程的初始化种子,SEED就是static静态块中获取的threadLocalRandomSeed变量的偏移量,值就是seed
        UNSAFE.putLong(t, SEED, seed);
        //设置当前线程的初始化探针,PROBE就是static静态块中获取的threadLocalRandomProbe变量的偏移量,值就是probe
        UNSAFE.putInt(t, PROBE, probe);
    }
    
    /**
     * 该字段用于计算当前线程中 threadLocalRandomProbe 的初始化值
     * 这是一个static final变量,但是它的值却是可变的,多线程共享
     */
    private static final AtomicInteger probeGenerator = new AtomicInteger();
    /**
     * 初始化threadLocalRandomProbe值的默认增量,每个线程初始化时调用一次,就增加0x9e3779b9,值为-1640531527
     * 这个数字的得来是 2^32 除以一个常数,而这个常数就是传说中的黄金比例 1.6180339887
     * 目的是为了让随机数取值更加均匀:https://www.javaspecialists.eu/archive/Issue164.html(0x61c88647就是1640531527)
     */
    private static final int PROBE_INCREMENT = 0x9e3779b9;
    /**
     * 该字段用于计算初始化SEED值,这是一个static final常量,但是它的值却是可变的
     */
    private static final AtomicLong seeder = new AtomicLong(initialSeed());
    /**
     * 初始化seeder值的默认增量,每个线程初始化时调用一次,就会增加SEEDER_INCREMENT
     */
    private static final long SEEDER_INCREMENT = 0xbb67ae8584caa73bL;
    

    3.3 nextInt方法

    public int nextInt(int bound)

    返回0(包括)和指定的绑定(排除)之间的伪随机 int值。

    当调用ThreadLocalRandom.nextInt方法时候,实际上是获取当前线程的threadLocalRandomSeed变量作为当前种子来计算新的种子,然后更新新的种子到当前线程的threadLocalRandomSeed变量,然后在根据新种子和具体算法计算随机数。

    /**
     * @param bound 伪随机数上限
     * @return 获取[0, bound)的伪随机整数
     */
    public int nextInt(int bound) {
        //bound范围校验
        if (bound <= 0)
            throw new IllegalArgumentException(BadBound);
        //根据当前线程中的种子计算新种子
        int r = mix32(nextSeed());
        //根据新种子和bound计算随机数
        int m = bound - 1;
        if ((bound & m) == 0) // power of two
            r &= m;
        else { // reject over-represented candidates
            for (int u = r >>> 1;
                 u + m - (r = u % bound) < 0;
                 u = mix32(nextSeed()) >>> 1)
                ;
        }
        return r;
    }
    
    /**
     * 用于根据当前种子,计算和更新下一个种子
     *
     * @return
     */
    final long nextSeed() {
        Thread t;
        long r; // read and update per-thread seed
        //更新计算出的种子,即更新当前线程的threadLocalRandomSeed变量
        UNSAFE.putLong(t = Thread.currentThread(), SEED,
                //计算新种子,为原种子+增量
                r = UNSAFE.getLong(t, SEED) + GAMMA);
        return r;
    }
    
    /**
     * 种子增量
     */
    private static final long GAMMA = 0x9e3779b97f4a7c15L;
    

    3.4 总结

    ThreadLocalRandom 使用ThreadLocal的原理,让每个线程都持有一个本地的种子变量,该种子变量只有在使用随机数时才会被初始化。在多线程下计算新种子时每一个线程是根据自己内部维护的种子变量进行更新,从而避免了竞争,提升了效率!

    相关文章:

    1. JUC—Unsafe类的原理详解与使用案例
    2. ThreadLocal源码深度解析与应用案例

    如有需要交流,或者文章有误,请直接留言。另外希望点赞、收藏、关注,我将不间断更新各种Java学习博客!

    展开全文
  • prng伪随机数生成器 这将是Kai Michaelis,JörgSchwenk和我撰写的论文的总结,该论文在RSA Conference 2013的密码学家会议上发表 。 你可以得到我的演讲的幻灯片在这里和我们的全文在这里 。 我们对PRNG(主要是...
  • 这将是Kai Michaelis,JörgSchwenk... 我们对PRNG(主要是SecureRandom)附带的常见Java库生成的随机序列进行了分析,发现在特殊条件下存在明显的弱点。 为了使文章尽可能简短,PRNG使用的算法的描述,详细的错误描...
  • 高级噪声 用于创建自定义伪随机数Java 库。
  • 引用类型:Random,随机数,作用:产生随机数(伪随机数)。 步骤:导入包(在java.util包里面)-&gt;创建Random类型变量-&gt;使用变量,产生随机数。 import java.util.Random;//导入包 public clas...
  • CTF之java伪随机数random函数破解 预测

    千次阅读 2020-10-25 17:02:38
    某个后台访问之后,首先映入眼帘的只有一个登录框 抓包如下: ...因为有源码,看看源码怎么说: 大概意思就是当cookie_token不等于空...2、搞定这个伪随机 在师傅疯狂暗示下,我放弃了暴力美学,走上了第二条路,有大佬
  • 伪随机数算法-源码

    2021-02-14 21:41:20
    伪随机数算法
  • random.nextInt(max)表示生成[0,max]之间的随机数,然后对(max-min+1)取模。 生成范围值: 方法1.以生成[10,20]随机数为例,首先生成0-20的随机数,然后对(20-10+1)取模得到[0-10]之间的随机数,然后加上min=10...
  • JAVA创建Random伪随机数 Random随机数的创建 1.简单范围的随机数 Random num = new Random();//这里的()代表每一次都随机,输入整数代表某个固定的随机数 for(int i=0;i<5;i++) {//生成5个随机数 int ran ...
  • java中的伪随机数

    2020-05-07 15:22:34
    在计算伪随机数时,若使用的初值(种子)不变,那么伪随机数的数序也不变。伪随机数可以用计算机大量生成,在模拟研究中为了提高模拟效率,一般采用伪随机数代替真正的随机数。模拟中使用的一般是循环周期极长并能通过...
  • 真随机数和伪随机数

    千次阅读 2019-03-15 17:34:37
    随机数的特性 ...真随机数和伪随机数 真随机数  真随机数是伴随着物理实验的,比如:抛硬币、掷骰子、电子元件的噪音、核裂变等,它的结果符合三大特性的。  具体实现:intel通过电阻和振荡器生成...
  • Java Random类 伪随机数

    2019-03-15 08:58:13
    什么是伪随机数? 只要这个随机数是由确定算法生成的,那就是伪随机,只能通过不断算法优化,使你的随机数更接近随机 Java随机数产生原理 Java的随机数产生是通过线性同余公式产生的,也就是说通过一个复杂的算法生成的...
  • java 伪随机数安全性

    千次阅读 2015-08-01 18:10:10
    在实际应用中往往使用伪随机数就足够了。这些数列看似是随机的数,实际上它们是通过一个固定的、可以重复的计算方法产生的。计算机产生的随机数有很长的周期性。它们不真正地随机,因为它们实际上是可以计算出来的,...
  • CTF中的伪随机数

    2020-11-13 11:08:19
    mt_rand()函数的默认范围是0到mt_getrandmax()之间的伪随机数 有这么多 存在漏洞 相同的种子生成的随机数是相同的 推荐一个工具 看这里 所以 漏洞来了 知道种子后,可以确定输出伪随机数的序列。 知道随机数序列...
  • 问题 今天想让程序返回一个区间内的随机数。...import java.util.Random; /** * @author HP * @date 2019/4/16 */ public class randomTest { public static void main(String[] args) { Random r...
  • 文章目录1Random类:1.1Random的构造方法1.2...无参数的构造方法:默认使用系统的时间的毫秒作为随机种子 有参数的构造方法:自己输入种子 使用实例: Random random1=new Random(100); for (int i = 0; i < 10
  • 伪随机数

    2017-09-15 10:52:17
    有一个随机数生成器:首先输入一个正整数n表示要生成随机数的位数,然后它会生成一个n位的不包含前导数为0的正十进制,生成器还有一个性质,就是它生成的第i位上(从左到右)的数字永远不等于i。 比如生成的位数...
  • java伪随机数生成的两种方式

    千次阅读 2014-06-29 10:21:20
    生成伪随机数: 一、
  • 这是一个随机数生成软件,可以随机生成指定书目的随机数,而不重复
  • 什么是伪随机数? 1.伪随机数是看似随机实质是固定的周期性序列,也就是有规则的随机。 2.只要这个随机数是由确定算法生成的,那就是伪随机,只能通过不断算法优化,使你的随机数更接近随机。 (随机这个属性和算法...
  • 伪随机数算法

    万次阅读 多人点赞 2017-05-03 21:46:14
    伪随机数概念在我大学一年级接触C语言基础的时候就听说过,并熟练掌握C语言中rand()函数的使用方法。不过,当时我对伪随机数的认识基本也就停留在百度百科那种小白水平,最多就知道老师说我们用的随机数是假的,是...
  • Random类——生成伪随机数

    千次阅读 2018-04-02 23:52:36
    Java Random介绍一、简介Random类位于java.util包下,此类的实例用于生成伪随机数流。之所以称之为伪随机,是因为真正意义上的随机数(或者称为随机事件)在某次产生过程中是按照实验过程表现的分布概率随机产生的,...
  • Random伪随机数

    2019-05-17 08:11:24
    Random伪随机数 开发工具与关键技术:My Eclipse 10、Java 作者:郑凯丰 撰写时间:2019年5月16日 解释:用Random写三种随机数,然后你就会发现Random伪随机数其实也是有规律的,当同事写多个Random方法的时候就会...
  • 一: Random类(java.util.Random) 构造器:   示例: /** * 功能描述:随机获取6位纯数字 * * @param */ public static String getRandom() { int code = 0; while (code ) { code = new Random...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 28,551
精华内容 11,420
关键字:

伪随机数java

java 订阅