精华内容
下载资源
问答
  • java生成随机数
    2022-05-09 16:31:47

    在java.util.Random中提供了产生随机数的API:

    int nextInt(int bound)

    返回从随机数生成器序列中提取的,均匀分布在0(包含)和bound(不包含)之间的一个int类型的伪随机数。简单说,就是返回[0,bound)区间中的一个int值。

    0 <= x < bound

    返回指定范围的随机数

    如果想在范围 [MIN, MAX]之间产生随机数,即:MIN <= x <= MAX,只需要这样:

    nextInt(MAX - MIN + 1) + MIN

    示例:

    生成一个6位的随机数作为验证码:

    String result = "";
    Random random = new Random();
    for (int i = 0; i < 6; i++) {
        result += random.nextInt(10);
    }

    生成一个大于等于100小于等于999的随机数:

    Random random = new Random();
    Integer result = random.nextInt(999-100+1)+100;

    生成一个小写字母组成的字符串:

    String val = "";
    Random random = new Random();
    for (int i = 0; i < 8; i++) {
        val += (char) (97 + random.nextInt(26));
    }

    生成一个由大小写字母和数字组成的字符串:

    String val = "";
    Random random = new Random();
    for (int i = 0; i < 8; i++) {
        // 输出字母还是数字
        String charOrNum = random.nextInt(2) % 2 == 0 ? "char" : "num";
        // 字符串
        if ("char".equalsIgnoreCase(charOrNum)) {
            // 取得大写字母还是小写字母
            int choice = random.nextInt(2) % 2 == 0 ? 65 : 97;
            val += (char) (choice + random.nextInt(26));
        } else if ("num".equalsIgnoreCase(charOrNum)) { // 数字
            val += String.valueOf(random.nextInt(10));
        }
    }

    更多相关内容
  • Java Random类的详细介绍(Java生成随机数)一、Random类的使用1.Random类生成随机数(int)的基本语法:2.几种常用的随机数生成二、Random类的详细介绍1.生成指定范围的数字2.Random.nextInt()与Math.random()的区别 ...
  • 生成随机数 三个方法 java.util.Random class Math.random 方法,创建一个double类型的随机数 ThreadLocalRandom class 1) java.util.Random 要使用这个方法,首先要生成一个实例。来调用它的nextInt(),nextDouble()...
  • 主要介绍了java生成随机数(字符串)示例分享,需要的朋友可以参考下
  • java生成随机数

    2014-04-23 15:49:16
    java生成一个随机数,可以设置生成随机数的位数,来生成任意位数的随机数,范围从0-9,a-z
  • 主要介绍了java生成随机数的常用方法,结合实例形式分析了java生成随机数常用的方法功能与相关使用技巧,需要的朋友可以参考下
  • JAVA 生成随机数

    2016-11-25 15:52:50
    编写一个彩票开奖的模拟程序,注意类的定义,必须...根据用户选择的玩法,随机生成开奖号码,与用户输入的号码比较,判断是否中奖、中几等奖,并输出结果。(中奖性的属性,判断是否中奖的方法定义成抽象用子类实现)
  • Java生成随机数的几种方式

    千次阅读 2022-04-16 23:16:35
    Java 中,生成随机数的场景有很多,所以本文我们就来盘点一下 4 种生成随机数的方式,以及它们之间的区别和每种生成方式所对应的场景。 1.Random Random 类诞生于 JDK 1.0,它产生的随机数是伪随机数,也就是有...

    在 Java 中,生成随机数的场景有很多,所以本文我们就来盘点一下 4 种生成随机数的方式,以及它们之间的区别和每种生成方式所对应的场景。

    1.Random

    Random 类诞生于 JDK 1.0,它产生的随机数是伪随机数,也就是有规则的随机数。Random 使用的随机算法为 linear congruential pseudorandom number generator (LGC) 线性同余法伪随机数。在随机数生成时,随机算法的起源数字称为种子数(seed),在种子数的基础上进行一定的变换,从而产生需要的随机数字。

    **Random 对象在种子数相同的情况下,相同次数生成的随机数是相同的。**比如两个种子数相同的 Random 对象,第一次生成的随机数字完全相同,第二次生成的随机数字也完全相同。默认情况下 new Random() 使用的是当前纳秒时间作为种子数的。

    ① 基础使用

    使用 Random 生成一个从 0 到 10 的随机数(不包含 10),实现代码如下:

    // 生成 Random 对象
    Random random = new Random();
    for (int i = 0; i < 10; i++) {
        // 生成 0-9 随机整数
        int number = random.nextInt(10);
        System.out.println("生成随机数:" + number);
    }
    

    以上程序的执行结果为:
    在这里插入图片描述

    ② 优缺点分析

    Random 使用 LGC 算法生成伪随机数的优点是执行效率比较高,生成的速度比较快。

    它的缺点是**如果 Random 的随机种子一样的话,每次生成的随机数都是可预测的(都是一样的)。**如下代码所示,当我们给两个线程设置相同的种子数的时候,会发现每次产生的随机数也是相同的:

    // 创建两个线程
    for (int i = 0; i < 2; i++) {
        new Thread(() -> {
            // 创建 Random 对象,设置相同的种子
            Random random = new Random(1024);
            // 生成 3 次随机数
            for (int j = 0; j < 3; j++) {
                // 生成随机数
                int number = random.nextInt();
                // 打印生成的随机数
                System.out.println(Thread.currentThread().getName() + ":" +
                                   number);
                // 休眠 200 ms
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("---------------------");
            }
        }).start();
    }
    

    以上程序的执行结果为:
    在这里插入图片描述

    ③ 线程安全问题

    当我们要使用一个类时,我们首先关心的第一个问题是:它是否为线程安全?对于 Random 来说,Random 是线程安全的。

    PS:线程安全指的是在多线程的场景下,程序的执行结果和预期的结果一致,就叫线程安全的,否则则为非线程安全的(也叫线程安全问题)。比如有两个线程,第一个线程执行 10 万次 ++ 操作,第二个线程执行 10 万次 – 操作,那么最终的结果应该是没加也没减,如果程序最终的结果和预期不符,则为非线程安全的。

    我们来看 Random 的实现源码:

    public Random() {
        this(seedUniquifier() ^ System.nanoTime());
    }
    
    public int nextInt() {
        return next(32);
    }
    
    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)); // CAS(Compare and Swap)生成随机数
        return (int)(nextseed >>> (48 - bits));
    }
    

    PS:本文所有源码来自于 JDK 1.8.0_211。

    从以上源码可以看出,Random 底层使用的是 CAS(Compare and Swap,比较并替换)来解决线程安全问题的,因此对于绝大数随机数生成的场景,使用 Random 不乏为一种很好的选择。

    PS:Java 并发机制实现原子操作有两种:一种是锁,一种是 CAS。

    CAS 是 Compare And Swap(比较并替换)的缩写,java.util.concurrent.atomic 中的很多类,如(AtomicInteger AtomicBoolean AtomicLong等)都使用了 CAS 机制来实现。

    2.ThreadLocalRandom

    ThreadLocalRandom 是 JDK 1.7 新提供的类,它属于 JUC(java.util.concurrent)下的一员,为什么有了 Random 之后还会再创建一个 ThreadLocalRandom?

    原因很简单,通过上面 Random 的源码我们可以看出,Random 在生成随机数时使用的 CAS 来解决线程安全问题的,然而 CAS 在线程竞争比较激烈的场景中效率是非常低的,原因是 CAS 对比时老有其他的线程在修改原来的值,所以导致 CAS 对比失败,所以它要一直循环来尝试进行 CAS 操作。所以在多线程竞争比较激烈的场景可以使用 ThreadLocalRandom 来解决 Random 执行效率比较低的问题。

    当我们第一眼看到 ThreadLocalRandom 的时候,一定会联想到一次类 ThreadLocal,确实如此。ThreadLocalRandom 的实现原理与 ThreadLocal 类似,它相当于给每个线程一个自己的本地种子,从而就可以避免因多个线程竞争一个种子,而带来的额外性能开销了。
    在这里插入图片描述

    ① 基础使用

    接下来我们使用 ThreadLocalRandom 来生成一个 0 到 10 的随机数(不包含 10),实现代码如下:

    // 得到 ThreadLocalRandom 对象
    ThreadLocalRandom random = ThreadLocalRandom.current();
    for (int i = 0; i < 10; i++) {
        // 生成 0-9 随机整数
        int number = random.nextInt(10);
        // 打印结果
        System.out.println("生成随机数:" + number);
    }
    

    以上程序的执行结果为:
    在这里插入图片描述

    ② 实现原理

    ThreadLocalRandom 的实现原理和 ThreadLocal 类似,它是让每个线程持有自己的本地种子,该种子在生成随机数时候才会被初始化,实现源码如下:

    public int nextInt(int bound) {
        // 参数效验
        if (bound <= 0)
            thrownew IllegalArgumentException(BadBound);
        // 根据当前线程中种子计算新种子
        int r = mix32(nextSeed());
        int m = bound - 1;
        // 根据新种子和 bound 计算随机数
        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;
    }
    
    final long nextSeed() {
        Thread t; long r; // read and update per-thread seed
        // 获取当前线程中 threadLocalRandomSeed 变量,然后在种子的基础上累加 GAMMA 值作为新种子
        // 再使用 UNSAFE.putLong 将新种子存放到当前线程的 threadLocalRandomSeed 变量中
        UNSAFE.putLong(t = Thread.currentThread(), SEED,
                       r = UNSAFE.getLong(t, SEED) + GAMMA); 
        return r;
    }
    

    ③ 优缺点分析

    ThreadLocalRandom 结合了 Random 和 ThreadLocal 类,并被隔离在当前线程中。因此它通过避免竞争操作种子数,从而在多线程运行的环境中实现了更好的性能,而且也保证了它的线程安全。

    另外,不同于 Random, ThreadLocalRandom 明确不支持设置随机种子。它重写了 Random 的setSeed(long seed) 方法并直接抛出了 UnsupportedOperationException 异常,因此降低了多个线程出现随机数重复的可能性。

    源码如下:

    public void setSeed(long seed) {
        // only allow call from super() constructor
        if (initialized)
            thrownew UnsupportedOperationException();
    }
    

    只要程序中调用了 setSeed() 方法就会抛出 UnsupportedOperationException 异常,如下图所示:
    在这里插入图片描述

    ThreadLocalRandom 缺点分析

    虽然 ThreadLocalRandom 不支持手动设置随机种子的方法,但并不代表 ThreadLocalRandom 就是完美的,当我们查看 ThreadLocalRandom 初始化随机种子的方法 initialSeed() 源码时发现,默认情况下它的随机种子也是以当前时间有关,源码如下:

    private static long initialSeed() {
        // 尝试获取 JVM 的启动参数
        String sec = VM.getSavedProperty("java.util.secureRandomSeed");
        // 如果启动参数设置的值为 true,则参数一个随机 8 位的种子
        if (Boolean.parseBoolean(sec)) {
            byte[] seedBytes = java.security.SecureRandom.getSeed(8);
            long s = (long)(seedBytes[0]) & 0xffL;
            for (int i = 1; i < 8; ++i)
                s = (s << 8) | ((long)(seedBytes[i]) & 0xffL);
            return s;
        }
        // 如果没有设置启动参数,则使用当前时间有关的随机种子算法
        return (mix64(System.currentTimeMillis()) ^
                mix64(System.nanoTime()));
    }
    

    从上述源码可以看出,当我们设置了启动参数“-Djava.util.secureRandomSeed=true”时,ThreadLocalRandom 会产生一个随机种子,一定程度上能缓解随机种子相同所带来随机数可预测的问题,然而默认情况下如果不设置此参数,那么在多线程中就可以因为启动时间相同,而导致多个线程在每一步操作中都会生成相同的随机数。

    3.SecureRandom

    SecureRandom 继承自 Random,该类提供加密强随机数生成器。SecureRandom 不同于 Random,它收集了一些随机事件,比如鼠标点击,键盘点击等,SecureRandom 使用这些随机事件作为种子。这意味着,种子是不可预测的,而不像 Random 默认使用系统当前时间的毫秒数作为种子,从而避免了生成相同随机数的可能性。

    ①基础使用

    // 创建 SecureRandom 对象,并设置加密算法
    SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
    for (int i = 0; i < 10; i++) {
        // 生成 0-9 随机整数
        int number = random.nextInt(10);
        // 打印结果
        System.out.println("生成随机数:" + number);
    }
    

    以上程序的执行结果为:
    在这里插入图片描述
    SecureRandom 默认支持两种加密算法:

    SHA1PRNG 算法,提供者 sun.security.provider.SecureRandom;
    NativePRNG 算法,提供者 sun.security.provider.NativePRNG。
    当然除了上述的操作方式之外,你还可以选择使用 new SecureRandom() 来创建 SecureRandom 对象,实现代码如下:

    SecureRandom secureRandom = new SecureRandom();
    

    通过 new 初始化 SecureRandom,默认会使用 NativePRNG 算法来生成随机数,但是也可以配置 JVM 启动参数“-Djava.security”参数来修改生成随机数的算法,或选择使用 getInstance(“算法名称”) 的方式来指定生成随机数的算法。

    4.Math

    Math 类诞生于 JDK 1.0,它里面包含了用于执行基本数学运算的属性和方法,如初等指数、对数、平方根和三角函数,当然它里面也包含了生成随机数的静态方法 Math.random() ,此方法会产生一个 0 到 1 的 double 值,如下代码所示。

    ① 基础使用

    for (int i = 0; i < 10; i++) {
        // 产生随机数
        double number = Math.random();
        System.out.println("生成随机数:" + number);
    }
    

    以上程序的执行结果为:
    在这里插入图片描述

    ② 扩展

    当然如果你想用它来生成一个一定范围的 int 值也是可以的,你可以这样写:

    for (int i = 0; i < 10; i++) {
        // 生成一个从 0-99 的整数
        int number = (int) (Math.random() * 100);
        System.out.println("生成随机数:" + number);
    }
    

    以上程序的执行结果为:
    在这里插入图片描述

    ③ 实现原理

    通过分析 Math 的源码我们可以得知:当第一次调用 Math.random() 方法时,自动创建了一个伪随机数生成器,实际上用的是 new java.util.Random(),当下一次继续调用 Math.random() 方法时,就会使用这个新的伪随机数生成器。

    源码如下:

    public static double random() {
        return RandomNumberGeneratorHolder.randomNumberGenerator.nextDouble();
    }
    
    privatestaticfinalclass RandomNumberGeneratorHolder {
        staticfinal Random randomNumberGenerator = new Random();
    }
    

    总结

    本文我们介绍了 4 种生成随机数的方法,其中 Math 是对 Random 的封装,所以二者比较类似。Random 生成的是伪随机数,是以当前纳秒时间作为种子数的,并且在多线程竞争比较激烈的情况下因为要进行 CAS 操作,所以存在一定的性能问题,但对于绝大数应用场景来说,使用 Random 已经足够了。当在竞争比较激烈的场景下可以使用 ThreadLocalRandom 来替代 Random,但如果对安全性要求比较高的情况下,可以使用 SecureRandom 来生成随机数,因为 SecureRandom 会收集一些随机事件来作为随机种子,所以 SecureRandom 可以看作是生成真正随机数的一个工具类。

    以上为个人经验,希望能给大家一个参考,如有错误或未考虑完全的地方,望不吝赐教!

    展开全文
  • 怎样用Java生成随机数

    万次阅读 2021-12-09 17:31:25
    Java中要生成一个指定范围之内的随机数字有两种方法:一种是调用 Math 类的 random() 方法,一种是使用 Random 类。 Random 类提供了丰富的随机数生成方法,可以产生 boolean、int、long、float、byte 数组以及 ...

            在Java中要生成一个指定范围之内的随机数字有两种方法:一种是调用 Math 类的 random() 方法,一种是使用 Random 类。

            Random 类提供了丰富的随机数生成方法,可以产生 boolean、int、long、float、byte 数组以及 double 类型的随机数,这是它与 random() 方法最大的不同之处。random() 方法只能产生 double 类型的 0~1 的随机数。

    Random 类位于 java.util 包中,该类常用的有如下两个构造方法。

    • Random():该构造方法使用一个和当前系统时间对应的数字作为种子数,然后使用这个种子数构造 Random 对象。
    • Random(long seed):使用单个 long 类型的参数创建一个新的随机数生成器。


            Random 类提供的所有方法生成的随机数字都是均匀分布的,也就是说区间内部的数字生成的概率是均等的,在表 1 中列出了 Random 类中常用的方法。

    Random 类的常用方法
    方法说明
    boolean nextBoolean()生成一个随机的 boolean 值,生成 true 和 false 的值概率相等
    double nextDouble()生成一个随机的 double 值,数值介于 [0,1.0),含 0 而不包含 1.0
    int nextlnt()生成一个随机的 int 值,该值介于 int 的区间,也就是 -231~231-1。如果
    需要生成指定区间的 int 值,则需要进行一定的数学变换
    int nextlnt(int n)生成一个随机的 int 值,该值介于 [0,n),包含 0 而不包含 n。如果想生成
    指定区间的 int 值,也需要进行一定的数学变换
    void setSeed(long seed)重新设置 Random 对象中的种子数。设置完种子数以后的 Random 对象
    和相同种子数使用 new 关键字创建出的 Random 对象相同
    long nextLong()返回一个随机长整型数字
    boolean nextBoolean()返回一个随机布尔型值
    float nextFloat()返回一个随机浮点型数字
    double nextDouble()返回一个随机双精度值

    例 1

            下面编写一个 Java 程序,演示如何使用 Random 类提供的方法来生成随机数。具体代码如下:

    import java.util.Random;
    
    public class Test06 {
    
    public static void main(String[] args) {
    
    Random r = new Random();
    
    double d1 = r.nextDouble(); // 生成[0,1.0]区间的小数
    
    double d2 = r.nextDouble() * 7; // 生成[0,7.0]区间的小数
    
    int i1 = r.nextInt(10); // 生成[0,10]区间的整数
    
    int i2 = r.nextInt(18) - 3; // 生成[-3,15)区间的整数
    
    long l1 = r.nextLong(); // 生成一个随机长整型值
    
    boolean b1 = r.nextBoolean(); // 生成一个随机布尔型值
    
    float f1 = r.nextFloat(); // 生成一个随机浮点型值
    
    System.out.println("生成的[0,1.0]区间的小数是:" + d1);
    
    System.out.println("生成的[0,7.0]区间的小数是:" + d2);
    
    System.out.println("生成的[0,10]区间的整数是:" + i1);
    
    System.out.println("生成的[-3,15]区间的整数是:" + i2);
    
    System.out.println("生成一个随机长整型值:" + l1);
    
    System.out.println("生成一个随机布尔型值:" + b1);
    
    System.out.println("生成一个随机浮点型值:" + f1);
    
    System.out.print("下期七星彩开奖号码预测:");
    
    for (int i = 1; i < 8; i++) {
    
    int num = r.nextInt(9); // 生成[0,9]区间的整数
    
    System.out.print(num);
    
    }
    
    }
    
    }

            本实例每次运行时结果都不相同,这就实现了随机产生数据的功能。该程序的运行结果如下:

    生成的[0,1.0]区间的小数是:0.8773165855918825
    生成的[0,7.0]区间的小数是:6.407083074782282
    生成的[0,10]区间的整数是:5
    生成的[-3,15]区间的整数是:4
    生成一个随机长整型值:-8462847591661221914
    生成一个随机布尔型值:false
    生成一个随机浮点型值:0.6397003
    下期七星彩开奖号码预测:0227168

    例 2

            Math 类的 random() 方法没有参数,它默认会返回大于等于 0.0、小于 1.0 的 double 类型随机数,即 0<=随机数<1.0。对 random() 方法返回的数字稍加处理,即可实现产生任意范围随机数的功能。

            下面使用 random() 方法实现随机生成一个 2~100 偶数的功能。具体代码如下:

    public class Test07 {
    
    public static void main(String[] args) {
    
    int min = 2; // 定义随机数的最小值
    
    int max = 102; // 定义随机数的最大值
    
    // 产生一个2~100的数
    
    int s = (int) min + (int) (Math.random() * (max - min));
    
    if (s % 2 == 0) {
    
    // 如果是偶数就输出
    
    System.out.println("随机数是:" + s);
    
    } else {
    
    // 如果是奇数就加1后输出
    
    System.out.println("随机数是:" + (s + 1));
    
    }
    
    }
    
    }

            由于 m+(int)(Math.random()*n) 语句可以获取 m~m+n 的随机数,所以 2+(int)(Math. random()*(102-2)) 表达式可以求出 2~100 的随机数。在产生这个区间的随机数后还需要判断是否为偶数,这里使用了对 2 取余数,如果余数不是零,说明随机数是奇数,此时将随机数加 1 后再输出。

            该程序的运行结果如下:

    随机数是:20

            这就是用Java生成随机数的内容,如果有疑问的话可以参考以下视频哦,更容易理解!而且还有更多Java基础可以学习!

    Java学习视频:全新的Java300集课程来啦!java零基础小白自学Java必备优质教程

    展开全文
  • java生成随机数方法

    2022-04-24 11:12:04
    第一种需要借助java.util.Random类来产生一个随机数发生器,也是最常用的一种,构造函数有两个,Random()和Random(long seed)。第一个就是以当前时间为默认种子,第二个是以指定的种子值进行。产生之后,借助不同的...

    方式一 new Random()

    第一种需要借助java.util.Random类来产生一个随机数发生器,也是最常用的一种,构造函数有两个,Random()和Random(long seed)。第一个就是以当前时间为默认种子,第二个是以指定的种子值进行。产生之后,借助不同的语句产生不同类型的数。
    种子就是产生随机数的第一次使用值,机制是通过一个函数,将这个种子的值转化为随机数空间中的某一个点上,并且产生的随机数均匀的散布在空间中。以后产生的随机数都与前一个随机数有关

    Random r = new Random();
    int k = r.nextInt(100);
    System.out.println(k);
    

    方式二 Math.random()

    而第二种方法返回的数值是[0.0,1.0)的double型数值,由于double类数的精度很高,可以在一定程度下看做随机数,借助(int)来进行类型转换就可以得到整数随机数了

    Random rd = new Random();
    int r = rd.nextInt(100)
    

    方式三 System.currentTimeMillis()

    long randomNum = System.currentTimeMillis();
    int k= (int) (randomNum%100);
    System.out.println(k);
    
    展开全文
  • 主要介绍了java生成字母数字组合的随机数的示例,大家参考使用吧
  • java生成随机数的方法

    2020-09-03 16:36:38
    主要介绍了java生成随机数的方法,涉及java随机数及字符串操作的相关技巧,需要的朋友可以参考下
  • Java中,生成随机数有两种方法。1是使用Random类。2是使用Math类中的random方法。看下面的例子使用吧
  • Java生成随机数的方法

    千次阅读 2021-04-25 22:44:19
    直接使用Math.random()这个静态的方法,random()方法返回一个[0,1)的随机数; Math.random() 产生的随机数是0-1之间的一个double,我们可以把他乘以一定的数,比如说乘以100,他就是个100以内的随机 int ran = ...
  • JAVA生成随机数工具类

    2021-06-18 00:41:09
    import java.util.regex.Matcher; import java.util.regex.Pattern; /** * 随机数的工具类 * @param args */ public class RandomNumber { private static int LENGTH = 6; /** * 随机数方法1:返回整数...
  • Java生成随机数几种方式

    千次阅读 2021-09-24 14:46:25
    java中产生随机数的方法主要有三种: 第一种:new Random() 第二种:Math.random() 第三种:currentTimeMillis() 第一种 第一种需要借助java.util.Random类来产生一个随机数发生器,也是最常用的一种,构造函数有...
  • import java.util.Random; public class Demo4_1 { public static void main(String[] args) { String code = createCode(5); System.out.println("随机验证码:" + code); } public static String create...
  • java生成随机数的代码

    2021-02-12 20:21:21
    /** * 产生10个随机数的各种方法 * @author Administrator * */ public class Test3 { //利用Math.random产生 public static void generateRandom1(){ for(int i =0;i<10;i++){ double tmp = Math.rando...
  • Java简易随机数生成

    2018-06-25 11:14:41
    Java简易随机数生成 下载完请输入测试代码 public static void main(String[] args) { System.out.println(random(50,100));//example System.out.println(random(50.0,100.0)); }
  • java生成随机数最常用的有3种方法,3种方法如下 方法1 Math.random() Math.random()可以生成[0,1)范围的随机数 方法2 java.util.Random 构造方法 Random r=new Random()不带随机种子,每次执行都产生不一样的结果 ...
  • Math.random()生成的是0.0~1.0的小数(不包括1.0哦),如果你想要的正好就是小数,那么直接乘以一个值就好了 例如:生成 [0.0,100.0) 的double数 但是大部分情况下,都是生成一个整数,所以这时候我们就要用到...
  • Random类似Scanner,也是Java提供好的API,内部提供了产生随机数的功能 使用步骤: 导入包 import java.util.Random; 创建对象 Random r = new Random(); 产生随机数 int num = r.nextInt(10); 解释: 10...
  • JAVA生成随机数

    万次阅读 2018-07-17 13:47:13
    随机数Int的生成 生成无边界的Int @Test public void testRandom_generatingIntegerUnbounded() throws Exception { int intUnbounded = new Random().nextInt(); System.out.println(intUnbounded); } 生成...
  • 作者 | 王磊来源 | Java中文社群(ID:javacn666)转载请联系授权(微信ID:GG_Stone)在 Java 中,生成随机数的场景有很多,所以本文我们就来盘点一下 4 种生...
  • Java生成随机数并执行冒泡排序

    千次阅读 2020-06-27 13:24:12
    import java.util.Random; public class Order { public static void main(String[] args) { int array[] = new int[13]; /* 定义一个长度为13的整数型数组 */ Random num = new Random(); /* 实例化随机数...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 92,130
精华内容 36,852
关键字:

java生成随机数

友情链接: x线程test.rar