random java隨機數 - 如何在Java中生成特定範圍內的隨機整數?




java随机数 random區間 (25)

在java-8他們在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();
    }
}

您也可以為doublelong值執行此操作。

希望能幫助到你! :)

如何在特定範圍內生成隨機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`.

從Java 7開始,您不應再使用Random 。 對於大多數用途,選擇的隨機數生成器現在是ThreadLocalRandom

對於fork連接池和並行流,請使用SplittableRandom

約書亞布洛赫。 有效的Java。 第三版。

從Java 8開始

對於fork連接池和並行流,使用通常更快的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);

您可以編輯第二個代碼示例:

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

最好使用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;
}

如果您想嘗試上述投票最多的答案,您可以使用以下代碼:

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

    public static void main(String[] args)
    {
        System.out.println(Randomizer.generate(0,10));
    }
}

它乾淨而簡單。


只需對您的第一個解決方案進行一些小修改就足夠了。

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

有關Random實現,請參閱此處


這是一個簡單的示例,顯示如何從閉合[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;
    }
}

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

或者看一下Apache Commons的 RandomUtils。


只需使用Random類:

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

請注意,這種方法比nextInt方法更具偏見且效率更低, https://.com/a/738651/360211 : nextInt

實現這一目標的一個標準模式是:

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

Java Math庫函數Math.random()生成範圍[0,1)的double值。 請注意,此範圍不包括1。

為了首先獲得特定範圍的值,您需要乘以您想要覆蓋的值範圍的大小。

Math.random() * ( Max - Min )

這將返回[0,Max-Min)範圍內的值,其中不包括“Max-Min”。

例如,如果你想要[5,10) ,你需要覆蓋五個整數值,以便你使用

Math.random() * 5

這將返回[0,5)範圍內的值,其中不包括5。

現在,您需要將此範圍更改為您要定位的範圍。 您可以通過添加Min值來完成此操作。

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

您現在將獲得[Min,Max)範圍內的值。 按照我們的例子,這意味著[5,10)

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

但是,這仍然不包括Max ,你得到的是雙倍價值。 為了獲得Max值,您需要在範圍參數(Max - Min)加1,然後通過強制轉換為int來截斷小數部分。 這是通過以下方式完成

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

你有它。 [Min,Max]或每個示例[5,10]範圍內的隨機整數值:

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

使用:

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

整數x現在是可能的結果為5-10的隨機數。


使用nextint(n)方法生成min和max之差的隨機數,然後將min number添加到結果中:

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


請原諒我的挑剔,但大多數建議的解決方案,即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%或更高。


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來完成任務時,不需要重新發明隨機整數生成輪。


在滾動骰子的情況下,它將是1到6之間的隨機數(不是0到6),因此:

face = 1 + randomNumbers.nextInt(6);

讓我們舉個例子。

假設我希望生成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);

讓我們理解這一點 ......

使用最高值初始化max,使用最低值初始化min。

現在,我們需要確定可以獲得多少可能的值。 對於這個例子,它將是:

5,6,7,8,9,10

因此,這將是最大 - 最小+ 1的計數。

即10 - 5 + 1 = 6

隨機數將生成0-5之間的數字。

即0,1,2,3,4,5

min值添加到隨機數將產生:

5,6,7,8,9,10

因此,我們獲得了所需的範圍。


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


我發現這個例子生成隨機數

此示例生成特定範圍內的隨機整數。

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.

另一種選擇是使用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);
    // ...
 }

JavaMath.Random類是從0開始的。 所以,如果你寫這樣的東西:

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

x將介於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將返回25nextInt( i.length )將返回0-24範圍之間的數字。 另一種選擇是使用Math.Random ,它以相同的方式工作。

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

為了更好地理解,請查看論壇帖子Random Intervals(archive.org)


這種方法可能很方便使用:

此方法將在提供的最小值和最大值之間返回一個隨機數:

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;
}

使用:

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





java random integer