精华内容
下载资源
问答
  • 相信大家的脑海里也都若隐若现地记得以前学过的很多编程语言,比如我们小学的时候都学过的Pascal里生成随机数似乎都要用到random什么什么的语句。那么,Java生成随机数自然也要用到Random喽! 这个结论是不错的。 ...

    1、导言

    Random这个英文单词,我想绝大多数人应该都不陌生。它就是“随机”的意思。相信大家的脑海里也都若隐若现地记得以前学过的很多编程语言,比如我们小学的时候都学过的Pascal里生成随机数似乎都要用到random什么什么的语句。那么,Java里生成随机数自然也要用到Random喽!
    这个结论是不错的。
    但是,具体应该怎么写呢?我想,大多数通过求助度娘找到这篇文章的人,瓶颈也就在于此。可以说上个大概的一二,但到了具体确切的实现方法这一步就一头雾水,懵了。
    那么,就让我来为你详细解答这个问题,手把手教到你能随心所欲地创建自己想要的随机数为止。

    2、Java实现与伪码模型

    话不多说,先给各位读者呈上使用方法,以解燃眉之急。比如我们想生成一个619~2016之间的随机整数吧,那么代码应该是这么写:

    import java.util.Random;
    
    public class Stochastic{
    	public static void main(String[] args){
    		Random rand = new Random();  //创建Random类的工具实例rand
    		
    		int num = 619 + rand.nextInt(1398);  //在619~2016(包括俩临界值)的范围内随机生成一个整数
    
    		System.out.println("所生成之随机数为:"+num);  //控制台输出生成的随机整数
    		
    	}
    }
    

    当然,如果你觉得实际代码不好记,我也准备了伪码模型,以便大家背流程。

    伪码如下:

    	导入类包
    	
    	function 生成随机数(最小值, 最大值){
    		创建工具对象rand
    		num ← 最小值 + rand.nextInt(最大值 - 最小值 + 1)
    		return num
    	}
    
    	main{
    		randNum ← 生成随机数(最小值, 最大值)
    	}
    

    之所以将其以函数的形式写出来,进行封装,目的是为了方便读者同志们理解随机数生成时各参数之间的关系。大家在写实际的代码时,不妨也将getRandZahlen(min, max)方法写在main方法的外面。这样,你以后想要生成随机数可以变得简单一些——只需要调用getRandZahlen(min, max)方法即可生成min到max范围内(包括临界值)的随机数了。其本质和min + rand.nextInt(max - min + 1)是完全一致的,要说区别,也只是形式上的区别而已:封装与不封装、方便使用与不方便使用。

    3、nextInt(bound)方法解析

    为了巩固大家的记忆,接下来就进入nextInt()方法的解析环节。——如果你理解了它的原理,你想要忘掉它都难。
    首先我们要了解的是,这个nextInt()是一个方法,而OOP(面向对象编程)范畴所说的方法,就是POP(面向过程编程)里面所说的函数。对,也完全可以将其视作是数学范畴的函数。绕来绕去,说白了,nextInt()本身就是一个数,它自己就是一个随机整数。
    那么,这个随机整数的产生范围有什么限制呢?它是在整数这个无限集合里任意产生的吗?我生成个-73也可以,生成个31415926535897932384626这样的超大整数也可以吗?不尽然也。Random类下的nextInt(bound)方法是可以设定范围限制的。而它的形参bound,就是控制随机数生成范围的唯一参数。随机数产生的范围,在0(包括0本身)到bound(不包括bound)之间。举个例子,比如说你直接调用Random.nextInt(1234),并且不加任何修剪吧,那么你将看到的随机数,最小可能是0,最大可能是1233。而不可能是负数,也不可能是比1233还要大的数。
    废话啰嗦了这么多,小结一下:

    使用Random类下的nextInt(bound)方法,可以在0到bound的范围内(前包后不包)随机生成一个整数。

    4、nextInt(bound)方法高级玩法:控制随机数的生成范围

    为了同志们能更好地理解接下来的内容,我先给大家出一道高中数学题热热身吧。大家拿出小本本和笔,先自己解解看。

    现有函数f(x), 已知:
    f ( x ) = 随 机 生 成 一 个 正 整 数 n , 使 0 ≤ n < x f(x)=随机生成一个正整数n,使0≤n<x f(x)=n使0nx
    又有函数y=10+f(x)
    求:
    ①f(x)当前的值域是多少?
    ②y当前的值域是多少?
    ③现欲使y的值域为10≤y<100,则f(x)的自变量应该取值多少?
    ④设第③题答案为a,则f(a)的值域是多少?
    ⑤现已知f(x)的自变量x=303,求此时y的值域。
    ⑥欲使y的值域为15≤y≤332(注意审题,后面是小于等于),则等号右侧的表达式应该如何改写?

    这六道题的参考答案我将在评论区内公布。已经全部解出来的同志可以继续往下读了。

    大家有没有发现,这和Random.nextInt()方法的使用有点类似?我们是不是也可以通过对Random.nextInt()方法进行加加减减、以控制随机数在我们想要的范围之内生成呢?
    现在就让我们来试着生成一个两位整数,容纳在变量target里吧。
    所谓的两位整数,就是10~99之间的数字。出现100就是犯规,出现9也是犯规。怎么做呢?
    首先最大值是99,我就很容易想到写nextInt(100)。可是这样它的最小值是0啊?还是会生成比10小的数字,还是有可能犯规啊?怎么办呢?
    接着我又想,既然nextInt()的最小值是0(而不是-1),那么我就给target先不管三七二十一来一个10就是了!这样,考虑最坏情况,target再小(nextInt(100)生成了随机数0)也不可能是小于10的数吧!诶嘿,这样子最小值问题就解决了,可是最大值问题又来了:你nextInt(100)既然最大能生成99,那我target最大岂不是10+99=109?不还是犯规?
    又怎么做呢?对了,我们只需要控制一下nextInt(bound)本身的范围就好。
    显而易见,在这个例子里,我们只需要用bound参数的值100减去最小值10,令bound=90,即可解决这个问题。如此,target的最小值便是10+0=10,最大值便是10+89=99了。完美地将target的取值范围控制在了10和99之间。

    小结:如果我们要生成0到max之间的随机整数(前后都包),我们只需要调用方法并且将max+1作为参数传递给方法即可:Random.nextInt(max+1)。而如果我们想要控制最小值为min,我们只需让函数加上min,然后再于函数的参数里减去min即可:min + Random.nextInt(max+1 - min)。

    什么?还是有点晕?那就看图吧。
    在这里插入图片描述
    这是nextInt(100)对不对?它的范围是0到99,对不对?
    在这里插入图片描述
    现在我们给它加上10,它的最终结果是不是只可能是10到(99+10)之间的数字,而绝不可能小于10?
    但是以上生成的最大数字为109,是超过我们理想的范围的。所以,我们要再给它减去多出来的最小值(在这个例子里也就是10)。
    在这里插入图片描述
    现在,它是不是又绝对不可能超过99了?范围不就控制在10到99之间了么?
    现在,总该知道bound = max-min+1这个公式是怎么来的了吧……

    5、心得

    首先,大家要搞清楚函数、类、方法这些概念,深刻地理解它,感受它。然后,建议重拾你尘封已久的高中数学课本,好好复习,锻炼自己善于建立数学模型以满足自己的需求、解决问题。另外,大家还可以通过编写像猜数字、猜拳之类的小游戏来练习自己对生成随机数的掌握,这带有一定的趣味性。最后,Java的工具库是很丰富的,大家多学点工具类。在学习的过程中,自己去探索学习方法使用时的思维模式,增强自己对关于方法使用知识的吸收能力。最好自己整一个方法辞典。对于初学者来说,这还可以加强自己对面向对象编程的理解。
    好了,有关随机整数的生成方法,就介绍到此了。当然了,Java里也有小数随机数的生成方法,在此篇就不多说了。以后或许会另写一篇进行解释说明。

    6、随机数逸话

    现阶段,计算机范畴的“随机数”并不完全等同于数学意义上的“随机数”。严格来说,计算机生成的不是“随机数”,而是“伪随机数”——似是而非的随机数。为什么这么说呢?这是因为它并不是真正的随机产生,而是按照一定的规律、按照固定的计算公式去产生的。只不过,投递给生成函数的种子(参数)不同,从而实现了不同的参数通过固定的公式、其计算结果(返回值)也不同。换句话说,如果每次投进去的种子一样,其返回结果一定也是固定不变的,而不是我们所看到的貌似“随机”。而这个随机种子又从哪获取呢?通常是取计算机的系统时间(以纳秒等人类难以把握的因子为单位)。将这些数值经过一系列复杂的计算过程,最终变成了我们需要的范围内的“随机”数字。于是,在我们人类看来,传同样的参数(指bound)给这个函数,每次返回的结果也都不一样,看起来就好像是随机数一样。而实际上,正常调用随机函数时,一般也没有人会去控制随机函数的种子,因此使用计算机产生的“随机数”,对于我们来说就和用骰子、硬币产生的随机数并无应用层级的(表象上的)区别。

    展开全文
  • 如何生成特定范围内的随机int数值? 我已经尝试了以下方法,但是这些方法不起作用: 尝试1: randomNum = minimum + (int)(Math.random() *

    如何生成特定范围内的随机int数值?

    我已经尝试了以下方法,但是这些方法不起作用:

    尝试1:

    randomNum = minimum + (int)(Math.random() * maximum);
    // Bug: `randomNum` can be bigger than `maximum`.
    

    尝试2:

    Random rn = new Random();
    int n = maximum - minimum + 1;
    int i = rn.nextInt() % n;
    randomNum =  minimum + i;
    // Bug: `randomNum` can be smaller than `minimum`.
    

    #1楼

    我发现此示例生成随机数


    本示例生成特定范围内的随机整数。

    import java.util.Random;
    
    /** Generate random integers in a certain range. */
    public final class RandomRange {
    
      public static final void main(String... aArgs){
        log("Generating random integers in the range 1..10.");
    
        int START = 1;
        int END = 10;
        Random random = new Random();
        for (int idx = 1; idx <= 10; ++idx){
          showRandomInteger(START, END, random);
        }
    
        log("Done.");
      }
    
      private static void showRandomInteger(int aStart, int aEnd, Random aRandom){
        if ( aStart > aEnd ) {
          throw new IllegalArgumentException("Start cannot exceed End.");
        }
        //get the range, casting to long to avoid overflow problems
        long range = (long)aEnd - (long)aStart + 1;
        // compute a fraction of the range, 0 <= frac < range
        long fraction = (long)(range * aRandom.nextDouble());
        int randomNumber =  (int)(fraction + aStart);    
        log("Generated : " + randomNumber);
      }
    
      private static void log(String aMessage){
        System.out.println(aMessage);
      }
    } 
    

    此类的示例运行:

    Generating random integers in the range 1..10.
    Generated : 9
    Generated : 3
    Generated : 3
    Generated : 9
    Generated : 4
    Generated : 1
    Generated : 3
    Generated : 9
    Generated : 10
    Generated : 10
    Done.
    

    #2楼

    使用此方法可能很方便:

    此方法将在提供的最小值和最大值之间返回一个随机数:

    public static int getRandomNumberBetween(int min, int max) {
        Random foo = new Random();
        int randomNumber = foo.nextInt(max - min) + min;
        if (randomNumber == min) {
            // Since the random number is between the min and max values, simply add 1
            return min + 1;
        } else {
            return randomNumber;
        }
    }
    

    这种方法会所提供的最小和最大值返回一个随机数(如此生成的数字也可以是最小或最大数):

    public static int getRandomNumberFrom(int min, int max) {
        Random foo = new Random();
        int randomNumber = foo.nextInt((max + 1) - min) + min;
    
        return randomNumber;
    }
    

    #3楼

    采用:

    Random ran = new Random();
    int x = ran.nextInt(6) + 5;
    

    现在,整数x是可能的结果为5-10的随机数。


    #4楼

    ThreadLocalRandom等效于类java.util.Random,用于多线程环境。 生成随机数是在每个线程中本地执行的。 因此,通过减少冲突,我们可以获得更好的性能。

    int rand = ThreadLocalRandom.current().nextInt(x,y);
    

    x,y-间隔,例如(1,10)


    #5楼

    只需执行以下语句即可完成:

    Randomizer.generate(0,10); //min of zero, max of ten
    

    以下是其源代码

    Randomizer.java

    public class Randomizer {
        public static int generate(int min,int max) {
            return min + (int)(Math.random() * ((max - min) + 1));
        }
    }
    

    这只是干净和简单。


    #6楼

    只需使用Random类:

    Random ran = new Random();
    // Assumes max and min are non-negative.
    int randomInt = min + ran.nextInt(max - min + 1);
    

    #7楼

    如果掷骰子,则它是1到6之间的随机数(而不是0到6),因此:

    face = 1 + randomNumbers.nextInt(6);
    

    #8楼

    rand.nextInt((max+1) - min) + min;
    

    一切正常。


    #9楼

    让我们举个例子。

    假设我希望生成5-10之间的数字:

    int max = 10;
    int min = 5;
    int diff = max - min;
    Random rn = new Random();
    int i = rn.nextInt(diff + 1);
    i += min;
    System.out.print("The Random Number is " + i);
    

    让我们了解一下 ...

    用最大值初始化最大值,用最小值初始化最小值。

    现在,我们需要确定可以获取多少个可能的值。 对于此示例,它将是:

    5、6、7、8、9、10

    因此,此计数为max-min + 1。

    即10-5 + 1 = 6

    随机数将生成一个介于0-5之间的数字。

    即0、1、2、3、4、5

    最小值添加到随机数将产生:

    5、6、7、8、9、10

    因此,我们获得了所需的范围。


    #10楼

    使用他们在Random类中引入了方法ints(int randomNumberOrigin, int randomNumberBound)

    例如,如果要生成[0,10]范围内的五个随机整数(或单个整数),请执行以下操作:

    Random r = new Random();
    int[] fiveRandomNumbers = r.ints(5, 0, 11).toArray();
    int randomNumber = r.ints(1, 0, 11).findFirst().getAsInt();
    

    第一个参数仅指示生成的IntStream的大小(这是产生无限IntStream方法的重载方法)。

    如果需要执行多个单独的调用,则可以从流中创建一个无限的原始迭代器:

    public final class IntRandomNumberGenerator {
    
        private PrimitiveIterator.OfInt randomIterator;
    
        /**
         * Initialize a new random number generator that generates
         * random numbers in the range [min, max]
         * @param min - the min value (inclusive)
         * @param max - the max value (inclusive)
         */
        public IntRandomNumberGenerator(int min, int max) {
            randomIterator = new Random().ints(min, max + 1).iterator();
        }
    
        /**
         * Returns a random number in the range (min, max)
         * @return a random number in the range (min, max)
         */
        public int nextInt() {
            return randomIterator.nextInt();
        }
    }
    

    您也可以为double long值和long整型值进行此操作。

    希望能帮助到你! :)


    #11楼

    这是一个简单的示例,显示了如何从封闭的[min, max]范围生成随机数,而min <= max is true

    您可以将其作为孔类中的字段重用,也可以将所有Random.class方法放在一个位置

    结果示例:

    RandomUtils random = new RandomUtils();
    random.nextInt(0, 0); // returns 0
    random.nextInt(10, 10); // returns 10
    random.nextInt(-10, 10); // returns numbers from -10 to 10 (-10, -9....9, 10)
    random.nextInt(10, -10); // throws assert
    

    资料来源:

    import junit.framework.Assert;
    import java.util.Random;
    
    public class RandomUtils extends Random {
    
        /**
         * @param min generated value. Can't be > then max
         * @param max generated value
         * @return values in closed range [min, max].
         */
        public int nextInt(int min, int max) {
            Assert.assertFalse("min can't be > then max; values:[" + min + ", " + max + "]", min > max);
            if (min == max) {
                return max;
            }
    
            return nextInt(max - min + 1) + min;
        }
    }
    

    #12楼

    只需对您的第一个解决方案进行少量修改就可以了。

    Random rand = new Random();
    randomNum = minimum + rand.nextInt((maximum - minimum) + 1);
    

    在此处查看更多有关Random执行的信息


    #13楼

    最好使用SecureRandom而不是Random。

    public static int generateRandomInteger(int min, int max) {
        SecureRandom rand = new SecureRandom();
        rand.setSeed(new Date().getTime());
        int randomNum = rand.nextInt((max - min) + 1) + min;
        return randomNum;
    }
    

    #14楼

    使用nextint(n)方法为min和max的差生成一个随机数,然后将min数加到结果中:

    Random rn = new Random();
    int result = rn.nextInt(max - min + 1) + min;
    System.out.println(result);
    

    #15楼

    采用:

    minimum + rn.nextInt(maxValue - minvalue + 1)
    

    #16楼

    Java 1.7或更高版本中 ,执行此操作的标准方法如下:

    import java.util.concurrent.ThreadLocalRandom;
    
    // nextInt is normally exclusive of the top value,
    // so add 1 to make it inclusive
    int randomNum = ThreadLocalRandom.current().nextInt(min, max + 1);
    

    请参阅相关的JavaDoc 。 这种方法的优点是不需要显式初始化java.util.Random实例,如果使用不当,可能会引起混乱和错误。

    但是,相反,没有办法明确设置种子,因此在有用的情况下(例如测试或保存游戏状态或类似情况),很难重现结果。 在这种情况下,可以使用下面显示的Java 1.7之前的技术。

    在Java 1.7之前 ,执行此操作的标准方法如下:

    import java.util.Random;
    
    /**
     * Returns a pseudo-random number between min and max, inclusive.
     * The difference between min and max can be at most
     * <code>Integer.MAX_VALUE - 1</code>.
     *
     * @param min Minimum value
     * @param max Maximum value.  Must be greater than min.
     * @return Integer between min and max, inclusive.
     * @see java.util.Random#nextInt(int)
     */
    public static int randInt(int min, int max) {
    
        // NOTE: This will (intentionally) not run as written so that folks
        // copy-pasting have to think about how to initialize their
        // Random instance.  Initialization of the Random instance is outside
        // the main scope of the question, but some decent options are to have
        // a field that is initialized once and then re-used as needed or to
        // use ThreadLocalRandom (if using at least Java 1.7).
        // 
        // In particular, do NOT do 'Random rand = new Random()' here or you
        // will get not very good / not very random results.
        Random rand;
    
        // nextInt is normally exclusive of the top value,
        // so add 1 to make it inclusive
        int randomNum = rand.nextInt((max - min) + 1) + min;
    
        return randomNum;
    }
    

    请参阅相关的JavaDoc 。 实际上, java.util.Random类通常比java.lang.Math.random()更可取。

    特别是,当标准库中有简单的API完成任务时,就无需重新发明随机整数生成轮。


    #17楼

     rand.nextInt((max+1) - min) + min;
    

    #18楼

    我想知道由Apache Commons Math库提供的任何随机数生成方法是否符合要求。

    例如: RandomDataGenerator.nextIntRandomDataGenerator.nextLong


    #19楼

    int random = minimum + Double.valueOf(Math.random()*(maximum-minimum )).intValue();
    

    或查看Apache Commons中的 RandomUtils。


    #20楼

    您可以将第二个代码示例编辑为:

    Random rn = new Random();
    int range = maximum - minimum + 1;
    int randomNum =  rn.nextInt(range) + minimum;
    

    #21楼

    请注意,此方法比nextInt方法https://stackoverflow.com/a/738651/360211更具偏见且效率较低

    实现此目的的一种标准模式是:

    Min + (int)(Math.random() * ((Max - Min) + 1))
    

    Java Math库函数Math.random()生成[0,1)范围内的双精度值。 请注意,此范围不包括1。

    为了首先获得特定的值范围,您需要乘以要覆盖的值范围的大小。

    Math.random() * ( Max - Min )
    

    这将返回[0,Max-Min)范围内的值,其中不包括“ Max-Min”。

    例如,如果您想要[5,10) ,则需要覆盖五个整数值,因此您可以使用

    Math.random() * 5
    

    这将返回[0,5)范围内的值,其中不包括5。

    现在,您需要将此范围上移到您要定位的范围。 您可以通过添加最小值来实现。

    Min + (Math.random() * (Max - Min))
    

    现在,您将获得[Min,Max)范围内的值。 按照我们的示例,这意味着[5,10)

    5 + (Math.random() * (10 - 5))
    

    但是,这仍然不包括Max ,您将获得双倍的价值。 为了获得包括的Max ,您需要在范围参数(Max - Min)上加1,然后通过强制转换为整数来截断小数部分。 这是通过以下方式完成的:

    Min + (int)(Math.random() * ((Max - Min) + 1))
    

    那里有它。 范围为[Min,Max]或根据示例[5,10]的随机整数值:

    5 + (int)(Math.random() * ((10 - 5) + 1))
    

    #22楼

    当您需要大量随机数时,建议不要在API中使用Random类。 周期太短了。 请尝试使用梅森捻线机 。 有一个Java实现


    #23楼

    Java中Math.Random类基于0。 因此,如果您编写如下内容:

    Random rand = new Random();
    int x = rand.nextInt(10);
    

    x将介于0-90-9之间(含0-9

    因此,给定以下由25项目组成的数组,用于生成介于0 (数组的基数)和array.length之间的随机数的代码为:

    String[] i = new String[25];
    Random rand = new Random();
    int index = 0;
    
    index = rand.nextInt( i.length );
    

    由于i.length将返回25 ,因此nextInt( i.length )将返回介于0-24之间的数字。 另一个选择是使用Math.Random ,它以相同的方式工作。

    index = (int) Math.floor(Math.random() * i.length);
    

    为了更好地理解,请查看论坛帖子Random Intervals(archive.org)


    #24楼

    我用这个:

     /**
       * @param min - The minimum.
       * @param max - The maximum.
       * @return A random double between these numbers (inclusive the minimum and maximum).
       */
     public static double getRandom(double min, double max) {
       return (Math.random() * (max + 1 - min)) + min;
     }
    

    如果需要,可以将其转换为整数。


    #25楼

    您可以在Java 8中简洁地实现:

    Random random = new Random();
    
    int max = 10;
    int min = 5;
    int totalNumber = 10;
    
    IntStream stream = random.ints(totalNumber, min, max);
    stream.forEach(System.out::println);
    

    #26楼

    原谅我过于挑剔,但是大多数人建议的解决方案,即min + rng.nextInt(max - min + 1))似乎很危险,原因是:

    • rng.nextInt(n)无法达到Integer.MAX_VALUE
    • min为负数时(max - min)可能导致溢出。

    一个万无一失的解决方案将为[ Integer.MIN_VALUEInteger.MAX_VALUE ]中的任何min <= max返回正确的结果。 考虑以下简单的实现:

    int nextIntInRange(int min, int max, Random rng) {
       if (min > max) {
          throw new IllegalArgumentException("Cannot draw random int from invalid range [" + min + ", " + max + "].");
       }
       int diff = max - min;
       if (diff >= 0 && diff != Integer.MAX_VALUE) {
          return (min + rng.nextInt(diff + 1));
       }
       int i;
       do {
          i = rng.nextInt();
       } while (i < min || i > max);
       return i;
    }
    

    尽管效率很低,但请注意, while循环中成功的概率将始终为50%或更高。


    #27楼

    要生成“在两个数字之间”的随机数,请使用以下代码:

    Random r = new Random();
    int lowerBound = 1;
    int upperBound = 11;
    int result = r.nextInt(upperBound-lowerBound) + lowerBound;
    

    这为您提供了一个介于1(含)和11(不含)之间的随机数,因此请通过添加1来初始化upperBound值。例如,如果要生成介于1到10之间的随机数,请使用11而不是初始化InitialBound数10。


    #28楼

    从Java 7开始,您不应再使用Random 。 对于大多数用途,现在选择的随机数生成器是ThreadLocalRandom

    对于派生连接池和并行流,请使用SplittableRandom

    约书亚·布洛赫(Joshua Bloch)。 有效的Java。 第三版。

    从Java 8开始

    对于派生连接池和并行流,请使用SplittableRandom ,该方法通常更快,与Random相比具有更好的统计独立性和统一性。

    生成范围为[0, 1_000]:的随机int [0, 1_000]:

    int n = new SplittableRandom().nextInt(0, 1_001);
    

    要生成范围为[0, 1_000]:的值的随机int[100]数组[0, 1_000]:

    int[] a = new SplittableRandom().ints(100, 0, 1_001).parallel().toArray();
    

    要返回随机值流:

    IntStream stream = new SplittableRandom().ints(100, 0, 1_001);
    

    #29楼

    public static Random RANDOM = new Random(System.nanoTime());
    
    public static final float random(final float pMin, final float pMax) {
        return pMin + RANDOM.nextFloat() * (pMax - pMin);
    }
    

    #30楼

    另一个选择是仅使用Apache Commons

    import org.apache.commons.math.random.RandomData;
    import org.apache.commons.math.random.RandomDataImpl;
    
    public void method() {
        RandomData randomData = new RandomDataImpl();
        int number = randomData.nextInt(5, 10);
        // ...
     }
    

    #31楼

    这是一个有用的类,可以在包含范围内的任意ints的范围内生成随机ints

    import java.util.Random;
    
    public class RandomRange extends Random {
        public int nextIncInc(int min, int max) {
            return nextInt(max - min + 1) + min;
        }
    
        public int nextExcInc(int min, int max) {
            return nextInt(max - min) + 1 + min;
        }
    
        public int nextExcExc(int min, int max) {
            return nextInt(max - min - 1) + 1 + min;
        }
    
        public int nextIncExc(int min, int max) {
            return nextInt(max - min) + min;
        }
    }
    
    展开全文
  • java随机生成十个

    千次阅读 2019-10-01 14:39:45
    一、设计思路 1.首先定义输出结果为0 ...3.循环十次,随机生成十个 4.求和并且输出结果 二、流程图 三、代码 四、实验结果 转载于:https://www.cnblogs.com/likegg/p/4931363.html...

    一、设计思路

    1.首先定义输出结果为0

    2.定义数组

    3.循环十次,随机生成十个数

    4.求和并且输出结果

    二、流程图

    三、代码

    四、实验结果

    转载于:https://www.cnblogs.com/likegg/p/4931363.html

    展开全文
  • public static String getCharAndNumr(int length) { String val = ""; Random random = new Random(); for (int i = 0; i < length; i++) { // 输出字母还是数字 String charOrNum = random.nextInt...
            public static String getCharAndNumr(int length) {
    		String val = "";
    		Random random = new Random();
    		for (int i = 0; i < length; 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));
    			}
    		}
    		return val;
    	}

    字符串随机排序

                    String code = "afdea1asd1231";
                    List<String> list = Arrays.asList(code.split(""));
    		Collections.shuffle(list);
    		String out = new String();
    		for(String s : list){
    			out += s;
    		}
                    System.out.println(out);

     

    展开全文
  • 我想让一个数组里面填满我生成的随机数,该怎么办呢 第一,要用规定一个数组 int [] arr = new int[]; 第二,要将随机数填进来 所以要用到Random import java.util.Random; //导包 Random random = new ...
  • 前言 不知道你们发现没有,在很多互联网公司基本上都是80后,90后居多,很少还有超过40岁的程序员。可能很多人心里都有一个疑问,那就是这些40多岁的程序员都干... Java面试精选题、架构实战文档传送门:戳这里免费领取
  • 1.java生成32位随机不重复数字+字母(做主键) 调用:  String ID = GuidUtil.generate(); GuidUtil.java: /** * */ package com.select.controller; /** * 生成GUID编码(使用hibernate的uuid生成机制) ...
  • Java生成随机长度的随机字符串1. 效果展示2. 代码及注释3. 字符生成4. 多多点赞交流! 1. 效果展示 生成10个长度为5-10的字符串: 可以看到,这里的字符串长度均在要求的范围内,字符串内容包含了常用的字符。 2. ...
  • JAVA随机生成10个100以内的,并判断出最大。 import java.util.Random; public class Qsab { public static void main(String[] args) { int y=0; for(int i=0;i<10;i++){ Random rand =new Random(); ...
  • java随机生成随机数 Generating a series of random numbers is one of those common tasks that crop up from time to time. In Java, it can be achieved simply by using the java.util.Random class. 生成一...
  • 大家好!我是小崇。希望大家不吝赐教,我们互相学习,共同进步! if-else语句是最常用的选择结构,它根据条件是真是假,决定执行的路径。if-else结构的一般格式是: if(conditon){ ...程序开始运行随机生成2个
  • 随机生成字段值 拼接成sql语句 输出到.sql文件 在数据库中执行sql文件 import java.io.FileOutputStream; import java.io.IOException; import java.nio.charset.StandardCharsets; import java.util.Random; ...
  • 今天遇到这样一个问题:在for循环和while循环中如何更好的使用continue语句。... * 实现功能:求10个随机整数中能被5整除的个数 */ public class Study { public static void main(String args[...
  • JAVA笔试题360 随机化考试 脚本简介。 此脚本的 v1 由 Saurav Kumar(或)编写,用于准备 2016 年秋季 CE2385 课程的期末考试。 简而言之,脚本从 Excel 表中读取两列(“Question_text”和“Key”),并使用它们...
  • Java中的判断语句

    千次阅读 2020-09-17 14:47:04
    Day03 1.基本数据类型转换 1.隐式转换 2.显式转换 2.引用数据类型转换 ...1.判断语句(条件语句) 某些代码在满足特定条件才会执行 1.if语句 1.单分支 if(条件){} 例如: if(a=0){ System.out.prin...
  • java 随机生成数技巧

    2020-06-20 16:04:15
    下面是java随机数生成语句生成6位随机数(不会是5位或者7位,仅只有6位): System.out.println((int)((Math.random()*9+1)*100000)); 同理,生成5位随机数: System.out.println((int)((Math.random()*9+1)*...
  • Java随机产生月份

    2017-05-28 14:50:17
    do-while语句 package random; //do while语句 import java.util.Scanner; public class Switch1 { public static void main(String[] args){ int x=(int)(1+Math.random()*12-1+1); @SuppressWarnings(...
  • java在数组中放入随机数... 有两种方法可以在Java随机播放数组。 Collections.shuffle() Method Collections.shuffle()方法 Random Class 随机类 1.使用Collections类对数组元素进行混洗 (1. Shuffle Array El...
  • Java产生1-10的随机整数

    千次阅读 2016-05-16 19:25:17
    int iRandom = (int)(1+Math.random()*10);
  • 程序三种结构:顺序结构,选择结构,循环结构;... 2、if(条件表达式){一条或者多条语句}   3、switch多分支开关语句  支持部分基本数据类型(原始数据类型),如:byte、short、int、long、char;不支...
  • import java.util.Random; import java.util.Scanner; public class GuestNumber { static int inputNumber02; public static void main(String []args){ guestNumber(); } public static void ...
  • Java随机数生成(简单)

    千次阅读 2020-12-07 18:35:11
    Java随机生成数是我们程序员必须掌握的一项技能,那么java随机生成数主要的有两种方法: 第一种:new Random() 第二种:Math.random() 第一种是要借助java.util.Random类来产生一个随机数发生器,也是常见的一...
  • 论文实验中需要给PM、VM的资源容量随机赋值,所以在网上查了一些Java中生成随机数的方法。 Java生成随机数Random Random Random是一个用于产生随机数的生成器。 ...
  • 问题:随机生成100个,任何单值重复不超过两次,取值1~50之间的整数 知识点: 思路:老师写的代码,还没有完全吃透理解,先记录下来 Random rand = new Random(); final int N=100; int[]arr = new int[N]; int...
  • 最近在做数据模型相关 需要手动将图形化操作转换成 数据库关联查询join 语句 这里就有一个表别名的问题 所以需要随机的字母组合 代码 // 这里是种子字母 当然如果需要可以加上数字 已经把大小写区分不明显的去掉了 ...
  • 随机生成 1-100 的一个,直到生成了 97 这个,看看你一共用了几次? 提示使用 (int)(Math.random() * 100) + 1 思路分析: 循环,但是循环的次数不知道. -> break ,当某个条件满足时,终止循环 通过该需求可以...
  • Java练习-if语句

    2019-10-30 12:59:47
    假设你想开发一个玩彩票的游戏,程序随机产生一个两位的彩票,提示用户输入 一个两位,然后按照下面的规则判定用户是否能赢。 1)如果用户输入的匹配彩票的实际顺序,奖金10 000美元。 2)如果用户输入的...
  • import random a=1 while a!=3: a=random.randint(1,10) print(a)
  • 随机数函:rand() * 10,产生0-0.999999999999999(小数点后15位)四舍五入函数:round(字段)向下取整函数:floor(字段),通俗的理解,如果是正小数,那么会直接取整数部分,如果是负小数那么将数值-1再取整数部分 ...
  • Mysql 生成随机数字

    千次阅读 2019-09-21 16:21:27
    其实思路很简单,利用MySQL现有的函数,然后进行加工处理,达到预期的结果。可以用到的MySQL函数为rand() ,以及 round() 函数。 具体为:select round(rand()*1000000000,0) id 转载于:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 59,794
精华内容 23,917
关键字:

java生成随机整数的语句

java 订阅