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

    千次阅读 2018-08-02 15:04:20
    Java中主要提供了两种方式产生随机数,分别为调用Math类的random()方法和Random类提供的产生各种数据类型随机数的方法。 1.Math.random()方法 这个方法默认生成大于等于0.0且小于1.0的double型随机数,即0&...

            在Java中主要提供了两种方式产生随机数,分别为调用Math类的random()方法和Random类提供的产生各种数据类型随机数的方法。

    1.Math.random()方法

    这个方法默认生成大于等于0.0且小于1.0的double型随机数,即0<=Math.random()<1.0。

    虽然Math.random()方法只可以产生0~1之间的double型数字,其实只要在Math.random()语句上稍加处理,就可以使用这个方法产生任意范围的随机数,如:

    (int)(Math.random()*n)----->返回大于等于0且小于n的整数

      m+(int)(Math.random()*n)----->返回大于等于m且小于m+n(不包括m+n)的随机数

    使用Math类的random()方法也可以随机生成字符,可以使用如下代码生成a~z之间的字符:

    (char)('a'+Math.random()*('z'-'a'+1));      //加1是因为要取到z

    2.Random类

    (1)除了Math类中的random()方法可以获取随机数之外,Java中还提供了一种可以获取随机数的方式,那就是java.util.Random类。可以通过实例化一个Random对象创建一个随机数生成器。

    Random r=new Random();

    以这种方式实例化对象时,Java编译器以系统当前时间作为随机数生成器的种子,因为每时每刻的时间不可能相同,所以产生的随机数将不同,但是如果运行速度太快,也会产生两次运行结果相同的随机数。

    (2)同时也可以在实例化Random类对象时,设置随机数生成器的种子。

    Random r=new Random(seedValue);

    在Random类中提供了获取各种数据类型随机数的方法,下面列举几个常用的方法:

            public int nextInt(): 返回一个随机整数
    		public int nextInt(int n): 返回大于等于0且小于n的随机整数
    		public long nextLong(): 返回一个随机长整型值
    		public boolean nextBoolean(): 返回一个随机布尔型值
    		public float nextFloat(): 返回一个随机浮点型值
    		public double nextDouble(): 返回一个随机双精度型值
    		public double nextGaussian(): 返回一个概率密度为高斯分布的双精度值

    展开全文
  • ThreadLocalRandom 不是直接用 new 实例化,而是第一次使用其静态方法 current() 得到 ThreadLocal 实例,然后调用 java.util.Random 类提供的方法获得各种随机数。 使用: public class JavaRandom { ...

    程序员的成长之路

    互联网/程序员/技术/资料共享 

    关注

    阅读本文大概需要 5.5 分钟。

    作者:专职跑龙套
    链接:https://www.jianshu.com/p/2f6acd169202

    1. Math.random() 静态方法

    产生的随机数是 0 - 1 之间的一个 double,即 0 <= random <= 1

    使用:

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

    结果:

    0.3598613895606426 0.2666778145365811 0.25090731064243355 0.011064998061666276 0.600686228175639 0.9084006027629496 0.12700524654847833 0.6084605849069343 0.7290804782514261 0.9923831908303121

    实现原理:

    When this method is first called, it creates a single new pseudorandom-number generator, exactly as if by the expression new java.util.Random() This new pseudorandom-number generator is used thereafter for all calls to this method and is used nowhere else.

    当第一次调用 Math.random() 方法时,自动创建了一个伪随机数生成器,实际上用的是 new java.util.Random()。当接下来继续调用 Math.random() 方法时,就会使用这个新的伪随机数生成器

    源码如下:

    public static double random() {
        Random rnd = randomNumberGenerator;
        if (rnd == null) rnd = initRNG(); // 第一次调用,创建一个伪随机数生成器
        return rnd.nextDouble();
    }
    
    private static synchronized Random initRNG() {
        Random rnd = randomNumberGenerator;
        return (rnd == null) ? (randomNumberGenerator = new Random()) : rnd; // 实际上用的是new java.util.Random()
    }
    
    

    This method is properly synchronized to allow correct use by more than one thread. However, if many threads need to generate pseudorandom numbers at a great rate, it may reduce contention for each thread to have its own pseudorandom-number generator.

    initRNG() 方法是 synchronized 的,因此在多线程情况下,只有一个线程会负责创建伪随机数生成器(使用当前时间作为种子),其他线程则利用该伪随机数生成器产生随机数。

    因此 Math.random() 方法是线程安全的。

    什么情况下随机数的生成线程不安全:

    • 线程1在第一次调用 random() 时产生一个生成器 generator1,使用当前时间作为种子。

    • 线程2在第一次调用 random() 时产生一个生成器 generator2,使用当前时间作为种子。

    • 碰巧 generator1 和 generator2 使用相同的种子,导致 generator1以后产生的随机数每次都和 generator2 以后产生的随机数相同。

    什么情况下随机数的生成线程安全: Math.random() 静态方法使用

    • 线程1在第一次调用 random() 时产生一个生成器 generator1,使用当前时间作为种子。

    • 线程2在第一次调用 random() 时发现已经有一个生成器generator1,则直接使用生成器 generator1

    public class JavaRandom {
        public static void main(String args[]) {
            new MyThread().start();
            new MyThread().start();
        }
    }
    class MyThread extends Thread {
        public void run() {
            for (int i = 0; i < 2; i++) {
                System.out.println(Thread.currentThread().getName() + ": " + Math.random());
            }
        }
    }
    
    

    结果:

    Thread-1: 0.8043581595645333 Thread-0: 0.9338269554390357 Thread-1: 0.5571569413128877 Thread-0: 0.37484586843392464

    2. java.util.Random 工具类

    基本算法:linear congruential pseudorandom number generator (LGC) 线性同余法伪随机数生成器缺点:可预测

    An attacker will simply compute the seed from the output values observed. This takes significantly less time than 2^48 in the case of java.util.Random. 从输出中可以很容易计算出种子值。It is shown that you can predict future Random outputs observing only two(!) output values in time roughly 2^16. 因此可以预测出下一个输出的随机数。You should never use an LCG for security-critical purposes.在注重信息安全的应用中,不要使用 LCG 算法生成随机数,请使用 SecureRandom。

    使用:

    Random random = new Random();
    
    for (int i = 0; i < 5; i++) {
        System.out.println(random.nextInt());
    }
    
    

    结果:

    -24520987 -96094681 -952622427 300260419 1489256498

    Random类默认使用当前系统时钟作为种子:

    public Random() {
        this(seedUniquifier() ^ System.nanoTime());
    }
    
    public Random(long seed) {
        if (getClass() == Random.class)
            this.seed = new AtomicLong(initialScramble(seed));
        else {
            // subclass might have overriden setSeed
            this.seed = new AtomicLong();
            setSeed(seed);
        }
    }
    
    

    Random类提供的方法:API

    • nextBoolean() - 返回均匀分布的 true 或者 false

    • nextBytes(byte[] bytes)

    • nextDouble() - 返回 0.0 到 1.0 之间的均匀分布的 double

    • nextFloat() - 返回 0.0 到 1.0 之间的均匀分布的 float

    • nextGaussian()- 返回 0.0 到 1.0 之间的高斯分布(即正态分布)的 double

    • nextInt() - 返回均匀分布的 int

    • nextInt(int n) - 返回 0 到 n 之间的均匀分布的 int (包括 0,不包括 n)

    • nextLong() - 返回均匀分布的 long

    • setSeed(long seed) - 设置种子

    只要种子一样,产生的随机数也一样: 因为种子确定,随机数算法也确定,因此输出是确定的!

    Random random1 = new Random(10000);
    Random random2 = new Random(10000);
    
    for (int i = 0; i < 5; i++) {
        System.out.println(random1.nextInt() + " = " + random2.nextInt());
    }
    
    

    结果:

    -498702880 = -498702880 -858606152 = -858606152 1942818232 = 1942818232 -1044940345 = -1044940345 1588429001 = 1588429001

    3. java.util.concurrent.ThreadLocalRandom 工具类

    ThreadLocalRandom 是 JDK 7 之后提供,也是继承至 java.util.Random。

    private static final ThreadLocal<ThreadLocalRandom> localRandom =
        new ThreadLocal<ThreadLocalRandom>() {
            protected ThreadLocalRandom initialValue() {
                return new ThreadLocalRandom();
            }
    };
    
    

    每一个线程有一个独立的随机数生成器,用于并发产生随机数,能够解决多个线程发生的竞争争夺。效率更高!

    ThreadLocalRandom 不是直接用 new 实例化,而是第一次使用其静态方法 current() 得到 ThreadLocal<ThreadLocalRandom> 实例,然后调用 java.util.Random 类提供的方法获得各种随机数。

    使用:

    public class JavaRandom {
        public static void main(String args[]) {
            new MyThread().start();
            new MyThread().start();
        }
    }
    class MyThread extends Thread {
        public void run() {
            for (int i = 0; i < 2; i++) {
                System.out.println(Thread.currentThread().getName() + ": " + ThreadLocalRandom.current().nextDouble());
            }
        }
    }
    
    

    结果:

    Thread-0: 0.13267085355389086 Thread-1: 0.1138484950410098 Thread-0: 0.17187774671469858 Thread-1: 0.9305225910262372

    4. java.Security.SecureRandom

    也是继承至 java.util.Random。

    Instances of java.util.Random are not cryptographically secure.Consider instead using SecureRandom to get a cryptographically secure pseudo-random number generator for use by security-sensitive applications.SecureRandom takes Random Data from your os (they can be interval between keystrokes etc - most os collect these data store them in files - /dev/random and /dev/urandom in case of linux/solaris) and uses that as the seed. 操作系统收集了一些随机事件,比如鼠标点击,键盘点击等等,SecureRandom 使用这些随机事件作为种子。

    SecureRandom 提供加密的强随机数生成器 (RNG),要求种子必须是不可预知的,产生非确定性输出。SecureRandom 也提供了与实现无关的算法,因此,调用方(应用程序代码)会请求特定的 RNG 算法并将它传回到该算法的 SecureRandom 对象中。

    • 如果仅指定算法名称,如下所示:SecureRandom random = SecureRandom.getInstance("SHA1PRNG");

    • 如果既指定了算法名称又指定了包提供程序,如下所示:SecureRandom random = SecureRandom.getInstance("SHA1PRNG", "SUN");

    使用:

    SecureRandom random1 = SecureRandom.getInstance("SHA1PRNG");
    SecureRandom random2 = SecureRandom.getInstance("SHA1PRNG");
    
    for (int i = 0; i < 5; i++) {
        System.out.println(random1.nextInt() + " != " + random2.nextInt());
    }
    
    

    结果:

    704046703 != 2117229935 60819811 != 107252259 425075610 != -295395347 682299589 != -1637998900 -1147654329 != 1418666937

    5. 随机字符串

    可以使用 Apache Commons-Lang 包中的 RandomStringUtils 类。Maven 依赖如下:

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

    API 参考:https://commons.apache.org/proper/commons-lang/javadocs/api-2.6/org/apache/commons/lang/RandomStringUtils.html

    示例:

    public class RandomStringDemo {
        public static void main(String[] args) {
            // Creates a 64 chars length random string of number.
            String result = RandomStringUtils.random(64, false, true);
            System.out.println("random = " + result);
    
            // Creates a 64 chars length of random alphabetic string.
            result = RandomStringUtils.randomAlphabetic(64);
            System.out.println("random = " + result);
    
            // Creates a 32 chars length of random ascii string.
            result = RandomStringUtils.randomAscii(32);
            System.out.println("random = " + result);
    
            // Creates a 32 chars length of string from the defined array of
            // characters including numeric and alphabetic characters.
            result = RandomStringUtils.random(32, 0, 20, true, true, "qw32rfHIJk9iQ8Ud7h0X".toCharArray());
            System.out.println("random = " + result);
    
        }
    }
    
    

    RandomStringUtils 类的实现上也是依赖了 java.util.Random 工具类:

    RandomStringUtils 类的定义

    <END>

    推荐阅读:

    27岁、47岁!国内两家知名企业同时传出员工猝死

    超级全面的 SpringBoot 注解介绍,每一个用途都应该清晰

    5T技术资源大放送!包括但不限于:C/C++,Linux,Python,Java,PHP,人工智能,单片机,树莓派,等等。在公众号内回复「2048」,即可免费获取!!

    微信扫描二维码,关注我的公众号

    朕已阅 

    展开全文
  • JAVA随机数

    2013-06-29 13:50:58
    JAVA语言中,随机数的简单练习,主要应用radom的函数
  • 在实际开发工作中经常需要用到随机数。...这就是利用随机数的原理。总之随机数在日常开发工作中经常用到。...在Java语言中生成随机数相对来说比较简单,因为有一个现成的方法可以使用。在Math类中,Java语言提供了一个

    在实际开发工作中经常需要用到随机数。如有些系统中创建用户后会给用户一个随机的初始化密码。这个密码由于是随机的,为此往往只有用户自己知道。他们获取了这个随机密码之后,需要马上去系统中更改。这就是利用随机数的原理。总之随机数在日常开发工作中经常用到。而不同的开发语言产生随机数的方法以及技巧各不相同。笔者这里就以Java语言为例,谈谈随机数生成的方法以及一些技巧。

    1. 利用random方法来生成随机数。
      在Java语言中生成随机数相对来说比较简单,因为有一个现成的方法可以使用。在Math类中,Java语言提供了一个叫做random的方法。通过这个方法可以让系统产生随机数。不过默认情况下,其产生的随机数范围比较小,为大于等于0到小于1的double型随机数。虽然其随机数产生的范围比较小,不能够满足日常的需求。如日常工作中可能需要产生整数的随机数。其实,只要对这个方法进行一些灵活的处理,就可以获取任意范围的随机数。

    如我们可以先通过random方法生成一个随机数,然后将结果乘以10。此时产生的随机数字即为大于等于0小于10的数字。然后再利用Int方法进行转换(它会去掉小数掉后面的数字,即只获取整数部分,不是四舍五入)。最后即可获取一个0到9的整数型随机数字。其实现方法很简单,就是对原有的random方法按照如下的格式进行变型:(int)(Math.Random()*10)即可。其实我们还可以对这个方法进行扩展,让其产生任意范围内的随机数。至需要将这个10换成n即可,如改为(int)(Math.Random()*n)。此时应用程序就会产生一个大于等于0小与n之间的随机数。如将n设置为5,那么其就会产生一个0到5之间的整数型的随机数。如果将这个写成一个带参数的方法,那么只要用户输入需要生成随机数的最大值,就可以让这个方法来生成制定范围的随机数。在Java中定义自己的工具库

    有时候程序员可能需要生成一个指定范围内的随机偶数或者奇数。此时是否可以通过这个方法来实现呢?答案是肯定的。如现在程序要需要生成一个1-100范围内的偶数。此时该如何实现?首先,需要生成一个0到99之内的随机数(至于这里为什么是99,大家耐心看下去就知道原因了)。要实现这个需求,很简单吧,只要通过如下语句就可以实现:i=1+(int)(Math.Random()*100)。其中(int)(Math.Random()*99)产生0到99的整数型随机数。然后再加上1就是产生1到100之间的随机整数。然后将产生的随机数赋值给变量i。但是此时其产生的随机数即有偶数,又有奇数。而现在程序员需要的是一个随机的偶数。那么我们可以在后面加上一个if判断语句。将这个随机数除以2,如果没有余数的话(或者余数为0)则表明这个随机数是偶数,直接返回即可。如果其返回的余数不为零,那么就表明其是奇数,我们只要加上1就变为了偶数,返回即可。注意,在上面的随机数生成中,笔者采用的范围是0到99,然后再加上1让其变为1到100的随机数。最后的结果就是生成1到100之间的随机偶数。其实,如果要范围随机奇数的话,至需要对上面的语句进行稍微的修改即可。Java:改变你我的世界

    假设现在用户想生成一个任意范围内的奇数或者偶数,能够实现吗?假设现在用户想实现一个m到n之间的任意偶数(其中m

    可见虽然random方法其自身产生的随机数有比较严格的范围限制。但是只要对其进行合理的转换,程序员仍然可以采用这个方法产生用户所需要的随机数据。

    1. 通过Random类来生成随机数。

    在Java语言中,除了可以通过random方法来产生随机数之外,还可以通过一个random类来产生随机数。程序开发人员可以通过实例化一个Random对象来创建一个随机数的生成器。如Random i=new Random()。通过这条语句就利用了Random类创建了一个随机数的生成器。不过以这种方法创建随机数时,与采用Random方法产生随机数的机制不同。利用现在这种方式实例化对象时,Java编译器会以系统当前的时间作为随机数生成器的种子。由于时间时时刻刻在变化的。若以这个时间作为生成器的种子,就可以保证生成的随机数真的是随机的,其生成的随机数重复率会大大的降低。

    利用这种方法其比较方便。如可以利用提供的关键字,让程序返回一个随机的整数(采用int nextInt(10))等等。不过其返回控制要比Random方法困难一点。如现在需要系统提供一个10到50之间的随机奇数,利用这个Random类就无法完成。也就是说,利用这个Random类来生成随机数,其只能够控制上限,而不能够控制下限。换一句话说,其可以指定最大的随机数范围,而不能够指定最小的随机数范围。所以,在灵活性上,其比Random方法要稍微差一点。

    另外利用这个方法来实现的话,必须先创建一个对象。也就是说利用Randow类来创建对象。这跟Randow方法不同。像上面举的例子中,Randow方法本身就是一个math类中方法,可以直接调用,省去对象创建的方法。为此笔者建议各位读者与程序开发人员,最好还是使用Random方法来创建随机数。只有在生成一些比较特殊的随机数时采用Random类。如现在需要生成一个概率密度为高斯分布的双精度值随机数时,则通过采用Random类的方法来创建随机数相对来说比较简单一点。

    1. 产生随机的字符。

    上面介绍的两种方法,产生的都是随机的数值型数据。但是有时候用户可能还需要产生随机的字符。其实也可以利用random方法来产生随机字符。如可以利用代码生成一个随机的小写字符:(char)(‘a’+Math.random()*(‘z’-‘a’+1))。其实这跟生成任意两个数之间的随机数类似。通过以上的代码就可以生成一个范围之内的任意随机字符。通过对这个代码进行适当的修整,还可以生成任意两个字符之间的随机字符与任意大写字符的随机字符。其转换的方式跟上面提到的任意范围之内的随机数类似。各位读者若感兴趣的话,可以自己进行测试一下。师傅领进门,修行在自身。如果笔者在这里一股脑儿将所有的答案告诉大家,大家的印象不会很深。大家若回去自己动手试试看,反而更容易记住。

    笔者在这里给大家一个提示,只需要根据m+(int)(Math.Random()(n-m))这条语句来调整(char)(‘a’+Math.random()(‘z’-‘a’+1))这个代码即可。

    1. 进阶

    通过阅读Math.random()的源码,或者干脆利用IDE的自动完成功能,开发人员可以很容易发现,java.lang.Math.random()使用一个内部的随机生成对象-一个很强大的对象可以灵活的随机产生:布尔值、所有数字类型,甚至是高斯分布。例如:

    new java.util.Random().nextInt(10)
    

    它有一个缺点,就是它是一个对象。它的方法必须是通过一个实例来调用,这意味着必须先调用它的构造函数。如果在内存充足的情况下,像上面的表达式是可以接受的;但内存不足时,就会带来问题。

    一个简单的解决方案,可以避免每次需要生成一个随机数时创建一个新实例,那就是使用一个静态类。猜你可能想到了java.lang.Math,很好,我们就是改良java.lang.Math的初始化。虽然这个工程量低,但你也要做一些简单的单元测试来确保其不会出错。

    假设程序需要生成一个随机数来存储,问题就又来了。比如有时需要操作或保护种子(seed),一个内部数用来存储状态和计算下一个随机数。在这些特殊情况下,共用随机生成对象是不合适的。

    并发

    在Java EE多线程应用程序的环境中,随机生成实例对象仍然可以被存储在类或其他实现类,作为一个静态属性。幸运的是,java.util.Random是线程安全的,所以不存在多个线程调用会破坏种子(seed)的风险。

    另一个值得考虑的是多线程java.lang.ThreadLocal的实例。偷懒的做法是通过Java本身API实现单一实例,当然你也可以确保每一个线程都有自己的一个实例对象。

    虽然Java没有提供一个很好的方法来管理java.util.Random的单一实例。但是,期待已久的Java 7提供了一种新的方式来产生随机数:

    java.util.concurrent.ThreadLocalRandom.current().nextInt(10)
    

    这个新的API综合了其他两种方法的优点:单一实例/静态访问,就像Math.random()一样灵活。ThreadLocalRandom也比其他任何处理高并发的方法要更快。

    经验

    Chris Marasti-Georg指出:

    Math.round(Math.random() * 10)
    

    使分布不平衡,例如:0.0-0.499999将四舍五入为0,而0.5至1.499999将四舍五入为1。那么如何使用旧式语法来实现正确的均衡分布,如下:

    Math.floor(Math.random() * 11

    幸运的是,如果我们使用java.util.Random或java.util.concurrent.ThreadLocalRandom就不用担心上述问题了。

    Java实战项目里面介绍了一些不正确使用java.util.Random API的危害。这个教训告诉我们不要使用:

    Math.abs(rnd.nextInt())%n
    

    而使用:

    rnd.nextInt(n)
    
    展开全文
  • Java 排序 随机数 算法收录了几种java常见的排序算法!
  • 一、Random类的使用 1.Random类生成随机数(int)的基本语法: 2.几种常用的随机数生成 二、Random类的详细介绍 1.生成指定范围的数字 2.Random.nextInt()与Math.random()的区别


    一、Random类的使用

    Random类的功能,生成一个随机数

    1.Random类生成随机数(int)的基本语法:

    (1)生成int取值范围的任意一个数

    Random r = new Random();
    int num = r.nextInt();
    

    (2)生成指定范围的任意一个数

    Random r = new Random();
    int num = r.nextInt(n);
    //参数 n 代表指定范围的数字[0,n)
    

    2.几种常用的随机数生成

    方法参数随机数取值范围返回值类型实例
    nextBoolean()true、falseboolean1
    nextDouble()[0.0,1.0)double2
    nextFloat()[0.0,1.0)float3
    nextInt()int的取值范围int4
    nextInt(int bound)参数代表指定范围的数字[0,bound)int5
    nextLong()long取值范围long6
    nextBytes(byte[] bytes)生成byte.length个数字放入byte[]中void7
    代码实例 - 1
    //生成Boolean随机数
    Random r = new Random();
    boolean b = r.nextBoolean();
    System.out.println("生成的Boolean随机数是:"+b);
    
    代码实例 - 2
    //生成double随机数
    Random r = new Random();
    double d = r.nextDouble();
    System.out.println("生成的Double随机数是:"+d);
    
    代码实例 - 3
    //生成Float随机数
    Random r = new Random();
    double f = r.nextFloat();
    System.out.println("生成的Float随机数是:"+f);
    
    代码实例 - 4
    //生成int随机数
    Random r = new Random();
    int i = r.nextInt();
    System.out.println("生成的Int随机数是:"+i);
    
    代码实例 - 5
    //生成[0,5)int随机数
    Random r = new Random();
    int i = r.nextInt(5);
    System.out.println("生成[0,5)的]Int随机数是:"+i);
    
    代码实例 - 6
    //生成Long随机数
    Random r = new Random();
    long l = r.nextLong();
    System.out.println("生成的Long随机数是:"+l);
    
    代码实例 - 7
    //将随机数字放入数组中
    Random r = new Random();
    byte[] arr = new byte[5];
    r.nextBytes(arr);
    for (int i = 0; i < arr.length; i++) {
        System.out.print(arr[i]+",");
    }
    

    二、Random类的详细介绍

    1.生成指定范围的数字

    左闭右闭 [a,b]r.nextInt(b-a+1)+a

    Random r = new Random();
    int a = 5;
    int b = 10;
    int res = r.nextInt(b-a+1)+a;
    System.out.println(res);
    

    左闭右开 [a,b)r.nextInt(b-a)+a

    Random r = new Random();
    int a = 5;
    int b = 10;
    int res = r.nextInt(b-a)+a;
    System.out.println(res);
    

    左开右闭 (a,b]r.nextInt(b-a)+a+1

    Random r = new Random();
    int a = 5;
    int b = 10;
    int res = r.nextInt(b-a)+a+1;
    System.out.println(res);
    

    左开右开 (a,b)r.nextInt(b-a-1)+a+1

    Random r = new Random();
    int a = 5;
    int b = 10;
    int res = r.nextInt(b-a-1)+a+1;
    System.out.println(res);
    

    2.Random.nextInt()与Math.random()的区别

    (1)来源1

    • random.nextInt() 为 java.util.Random类中的方法;
    • Math.random() 为 java.lang.Math 类中的静态方法。

    (2)用法1
    生成[0,n)的随机数

    //Random.nextInt()
    Random r = new Random();
    int r = random.nextInt(n);
    
    //Math.random()
    int res = (int)(Math.random() * n);
    

    (3)总结1

    • Math.random() 方法生成[0, 1)范围内的double类型随机数;Random类中的nextXxxx系列方法生成0-n的随机数;
    • Math.random() 线程安全,多线程环境能被调用;
    • 如无特殊需求,则使用(int)(Math.random()*n)的方式生成随机数即可。

    1. csdn - random.nextInt与Math.random基础用法 ↩︎ ↩︎ ↩︎

    展开全文
  • 产生20个随机数存放到数组,对这20个随机数按升序排序,最后按要求输出随机数。 3 概要设计 4 源代码 /* * Question: * 随机产生20个整数存放到数组中,然后对其按照升序进行排序,最后对排序前后的数组按照每5个...
  • 符合28个概率分布函数的随机数生成的Java代码实现(更新中)具体代码,接口中序号后有---的分布还没有上传进去
  • 随机数生成器 javaToday we will look at how to generate a random number in Java. Sometimes we need to generate random numbers in Java programs. For example, a dice game or to generate a random key id ...
  • 在写代码的过程中常常会用到生成随机数,或者是生成指定范围内的随机数。下面对Java中生成随机数的原理和相关概念、用法进行简要说明。 一、什么是伪随机数? 1.真正意义上的随机数在某次产生过程中是按照实验过程中...
  • Java 产生随机数并写入txt文档中

    千次阅读 2019-04-22 14:29:00
    代码: import java.io.*; import java.util.Random; public class AlgorithmTest { public static void main(String[] args) { String filepath = System.getProperty("user.dir")...
  • java产生是个随机数并排序

    千次阅读 2018-07-17 17:02:23
    public class MathTest {  public static void main(String[] args) {  int ram = 100;  int [] sjs = new int[10];    for(int k =0;k&lt;10;k++){  int m = (int) (Mat...
  • 高分悬赏:Java语言生成100个随机数,它们的和要等于1000,具体的代码
  • java中如何生成随机数

    千次阅读 2018-12-20 10:32:07
    JAVA中产生随机数字 代码如下: package swp_sdudy; 产生7-9的随机数 public class SuiJiShu { public static void main(String[] args) { //Math.random()函数是随机生成[0,1)的随机数字 //前面的...
  • 作者 | 王磊来源 | Java中文社群(ID:javacn666)转载请联系授权(微信ID:GG_Stone)在 Java 中,生成随机数的场景有很多,所以本文我们就来盘点一下 4 种生...
  • Java中产生随机数

    2017-03-09 10:59:07
     在Java语言中生成随机数相对来说比较简单,因为有一个现成的方法可以使用。在Math类中,Java语言提供了一个叫做random的方法。  通过这个方法可以让系统产生随机数。不过默认情况下,其产生的随机数范围比较小,...
  • 主要介绍了JAVA 16位ID生成工具类含16位不重复的随机数数字+大小写,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • java生成随机数

    2019-09-25 02:01:00
    Java语言中生成随 机数相对来说比较简单,因为有一个现成的方法可以使用。在Math类中,Java语言提供了一个叫做random的方法。通过这个方法可以让系统产生随机 数。不过默认情况下,其产生的随机数范围比较小,为...
  • java random生成随机数

    2019-09-15 16:06:45
    生成指定范围内的随机数 这个是最常用的技术之一。程序员希望通过随机数的方式来处理众多的业务逻辑,测试过程中也希望通过随机数的...以 Java 语言为例,我们观察其 Random 对象的 nextInt(int) 方法,发现这个方法...
  • java生成指定范围的随机数(太屌了)

    万次阅读 多人点赞 2018-11-29 23:39:04
    生成指定范围内的随机数 这个是最常用的技术之一。程序员希望通过随机数的方式来处理众多的业务逻辑,测试过程中也希望通过随机数的方式生成...以 Java 语言为例,我们观察其 Random 对象的 nextInt(int) 方法,...
  • 首先贴出工具类ArrayUtil:import 随机数生成类:import 快速排序它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分...
  • Java生成指定范围的随机数

    万次阅读 多人点赞 2019-06-12 16:04:29
    生成指定范围内的随机数 这个是最常用的技术之一。程序员希望通过随机数的方式来处理众多的业务逻辑,测试过程中也希望通过随机数的方式生成...以 Java 语言为例,我们观察其 Random 对象的 nextInt(int) 方法,...
  • java生成指定范围的随机数

    万次阅读 多人点赞 2017-06-20 10:00:31
    java生成指定范围的随机数
  • java设置随机数教程

    2017-07-11 16:36:00
    java作为程序猿开发人员都在使用的一款编程语言,许多入门的朋友都陷入了一个简单的问题就是,使用java开发时随机数要怎么设置?java怎么设置随机数?经常会有地方需要用到随机数,不用着急,一起来看看java设置随机数...
  • JAVA语言随机数的产生及其应用 【摘要】随机数在现代密码学领域有着极其广泛地应用。在密码学中,对一个序列的随机性是这样定义的:①看起来是随机的,即能通过我们所能找到的所有正确的随机性检验。②这个序列是不...
  • java 生成随机数 写入文件中

    千次阅读 2011-09-22 13:56:34
    public static void writeTxt(String path,String p){ File file=new File(path); try { if(!file.exists()) file.createNewFile();... BufferedWriter writer = new BufferedWriter(new FileW...
  • Java随机数生成(简单)

    千次阅读 2020-12-07 18:35:11
    第一种是要借助java.util.Random类来产生一个随机数发生器,也是常见的一种,构造函数有两个,Random()和Random(long seed)。第一个就是以当前时间为默认种子,第二个是以指定的种子值进行。产生之后,借助不同的语句...
  • Java生成随机数我总共总结了5种方式: (一)Math.random()静态方法: 产生的随机数是0-1之间的一个double,0<=random<=1 使用: for(int i=0;i<10;i++) { System.out.println(Math.println()); } 实现...

空空如也

空空如也

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

java语言随机数代码

java 订阅