#### [SOLVED] How do I generate random integers within a specific range in Java?

How do I generate a random `int` value in a specific range?

I have tried the following, but those do not work:

Attempt 1:

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

Attempt 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`.
`````` #### @Anand 2020-05-29 04:47:33

Use Apache Lang3 Commons

``````RandomStringUtils.randomNumeric(6, 6);
``````

Min Value 100000 to Max Value 999999 #### @Rahul Dhiman 2019-12-16 10:56:17

The following snippet will give a random value between 0 and 10000:

``````import java.util.Random;
public class Main
{
public static void main(String[] args) {
Random rand = new Random();
System.out.printf("%04d%n", rand.nextInt(10000));
}
}
`````` #### @Toby Speight 2019-12-16 11:17:54

Thank you for this code snippet, which might provide some limited short-term help. A proper explanation would greatly improve its long-term value by showing why this is a good solution to the problem, and would make it more useful to future readers with other, similar questions. Please edit your answer to add some explanation, including the assumptions you've made. In particular, it's not obvious how this code accepts the lower and upper bounds of the problem statement. #### @Lokesh Sharma 2020-05-04 14:48:10

int func(int max, int min){

``````  int range = max - min + 1;

// Math.random() function will return a random no between [0.0,1.0).
int res = (int) ( Math.random()*range)+min;

return res;
``````

} #### @Alexis C. 2014-11-26 18:29:07

With they introduced the method `ints(int randomNumberOrigin, int randomNumberBound)` in the `Random` class.

For example if you want to generate five random integers (or a single one) in the range [0, 10], just do:

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

The first parameter indicates just the size of the `IntStream` generated (which is the overloaded method of the one that produces an unlimited `IntStream`).

If you need to do multiple separate calls, you can create an infinite primitive iterator from the stream:

``````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();
}
}
``````

You can also do it for `double` and `long` values. I hope it helps! :) #### @Naxos84 2018-02-26 07:13:43

I would suggest that you instantiate the randomIterator only once. See Greg Case comment on his own answer. #### @Erfan Ahmed 2018-04-10 10:39:40

if you may, can you explain what is the significance of `streamSize` - the first param of this method given `streamSize !=0`. What is the difference if `streamSize` 1/2/n is given? #### @andrew 2013-02-12 23:19:46

`ThreadLocalRandom` equivalent of class `java.util.Random` for multithreaded environment. Generating a random number is carried out locally in each of the threads. So we have a better performance by reducing the conflicts.

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

`x`,`y` - intervals e.g. (1,10) #### @Simon 2017-05-28 14:30:49

I use this:

`````` /**
* @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;
}
``````

You can cast it to an Integer if you want. #### @sokras 2017-07-20 07:38:51

This function produces the same number over and over again. In my case it was: 2147483647 #### @Maarten Bodewes 2018-04-23 21:26:54

Fail: you have a function that requires a double and then perform + 1? This certainly goes against the principle of least surprise. What happens if you use min = 0.1 and max = 0.2? #### @Maarten Bodewes 2018-04-23 21:36:31

@sokras the method calls `new Random` (check the JavaDoc): "Creates a new random number generator. This constructor sets the seed of the random number generator to a value very likely to be distinct from any other invocation of this constructor." Very likely might just involve using the current time as seed. If that time uses milliseconds then current computers are fast enough to generate the same number. But besides that 2147483647 is `Integer.MAX_VALUE`; the output obviously depends on the input, which you haven't specified. #### @Jency 2019-12-24 11:11:37

Finally found the one that actually works #### @Kaplan 2019-07-06 09:02:40

here's a function that returns exactly one integer random number in a range defined by `lowerBoundIncluded` and `upperBoundIncluded`, as requested by user42155

`SplittableRandom splittableRandom = new SplittableRandom();`

``````BiFunction<Integer,Integer,Integer> randomInt = (lowerBoundIncluded, upperBoundIncluded)
-> splittableRandom.nextInt( lowerBoundIncluded, upperBoundIncluded + 1 );
``````

`randomInt.apply( …, … ); // gets the random number`

…or shorter for the one-time generation of a random number

``````new SplittableRandom().nextInt( lowerBoundIncluded, upperBoundIncluded + 1 );
`````` #### @Abel Callejo 2013-09-01 02:53:53

It can be done by simply doing the statement:

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

Below is its source-code

### Randomizer.java

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

It is just clean and simple. #### @Maarten Bodewes 2017-06-19 21:23:47

This could have been an edit of the other example, now it is just a blatant copy for reputation. Pointing out the "answer with the most votes" is also not very direct, it can change. #### @Abel Callejo 2017-06-20 00:36:07

That is right @MaartenBodewes. When I wrote this answer, the answer with the most votes above was still written as an algorithm-like solution. Now, the solution above has changed a lot and now this answer looked like a copy-cat. #### @Leevi L 2019-10-08 08:31:53

I really don't get why such fundamental bits of code are not part of Java standard libraries. Why do I have to implement this? #### @anshul 2019-05-13 09:04:30

Following code could be used:

``````ThreadLocalRandom.current().nextInt(rangeStart, rangeEndExclusive)
`````` #### @Maarten Bodewes 2019-07-01 11:28:27

There have been multiple answers that already suggested `ThreadLocalRandom`. If a question has been protected then please take extra care not to duplicate answers. #### @AZ_ 2011-07-13 11:31:55

``````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);
}
`````` #### @Prof Mo 2013-12-24 13:33:13

Just use the Random class:

``````Random ran = new Random();
// Assumes max and min are non-negative.
int randomInt = min + ran.nextInt(max - min + 1);
`````` #### @Maarten Bodewes 2017-06-19 21:21:53

I don't see anything new here that hadn't been posted in countless earlier posts. #### @gifpif 2015-05-27 10:43:08

Generate a random number for the difference of min and max by using the nextint(n) method and then add min number to the result:

``````Random rn = new Random();
int result = rn.nextInt(max - min + 1) + min;
System.out.println(result);
`````` #### @Gihan Chathuranga 2017-08-12 14:10:39

This is the easy way to do this.

``````import java.util.Random;
class Example{
public static void main(String args[]){
/*-To test-
for(int i = 1 ;i<20 ; i++){
System.out.print(randomnumber()+",");
}
*/

int randomnumber = randomnumber();

}

public static int randomnumber(){
Random rand = new Random();
int randomNum = rand.nextInt(6) + 5;

return randomNum;
}
}
``````

In there 5 is the starting point of random numbers. 6 is the range including number 5. #### @Sam2016 2017-10-04 14:18:05

A simple way to generate n random numbers between a and b e.g a =90, b=100, n =20

``````Random r = new Random();
for(int i =0; i<20; i++){
System.out.println(r.ints(90, 100).iterator().nextInt());
}
``````

`r.ints()` returns an `IntStream` and has several useful methods, have look at its API. #### @Maarten Bodewes 2020-05-05 19:51:55

Besides there being other answers that use streams, at least they don't create a new stream within a loop, now that really doesn't make sense. #### @Hospes 2012-06-07 10:38:41

I found this example Generate random numbers :

This example generates random integers in a specific range.

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

An example run of this class :

``````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.
`````` #### @Luke Taylor 2012-08-12 15:01:37

This methods might be convenient to use:

This method will return a random number between the provided min and max value:

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

and this method will return a random number from the provided min and max value (so the generated number could also be the min or max number):

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

return randomNumber;
}
`````` #### @Maarten Bodewes 2017-03-01 21:26:35

`// Since the random number is between the min and max values, simply add 1`. Why? Doesn't min count? Usually the range is [min, max) where min is included and max is excluded. Wrong answer, voted down. #### @Luke Taylor 2017-03-02 09:53:53

@MaartenBodewes +1 is added because getRandomNumberBetween generates a random number exclusive of the provided endpoints. #### @Lii 2018-06-17 12:21:50

The number `min + 1` will be twice as likely than the other number to be the result of `getRandomNumberBetween`! #### @BMAM 2018-02-01 04:54:58

The below code generates a random number between 100,000 and 900,000. This code will generate six digit values. I'm using this code to generate a six-digit OTP.

Use `import java.util.Random` to use this random method.

``````import java.util.Random;

// Six digits random number generation for OTP
Random rnd = new Random();
long longregisterOTP = 100000 + rnd.nextInt(900000);
System.out.println(longregisterOTP);
`````` #### @hexabunny 2015-03-12 22:44:28

Just a small modification of your first solution would suffice.

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

See more here for implementation of `Random` #### @AxelH 2016-07-08 12:30:15

For minimum <= value < maximum, I did the same with Math : randomNum = minimum + (int)(Math.random() * (maximum-minimum)); but the casting isn't really nice to see ;) #### @Maarten Bodewes 2020-05-05 19:55:11

At least 7 years late duplicate answer. #### @Matt R 2009-01-08 15:04:42

The `Math.Random` class in Java is 0-based. So, if you write something like this:

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

`x` will be between `0-9` inclusive.

So, given the following array of `25` items, the code to generate a random number between `0` (the base of the array) and `array.length` would be:

``````String[] i = new String;
Random rand = new Random();
int index = 0;

index = rand.nextInt( i.length );
``````

Since `i.length` will return `25`, the `nextInt( i.length )` will return a number between the range of `0-24`. The other option is going with `Math.Random` which works in the same way.

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

For a better understanding, check out forum post Random Intervals (archive.org). #### @Tapper7 2016-10-30 05:44:57

+1 for wayBackMachine archive screenshot link & your answer is still useful reference to get "random" ints w/in a range. #### @AjahnCharles 2017-08-02 13:53:53

It baffles me why you instantiate index to 0. #### @Matt R 2017-08-02 14:38:52

@CodeConfident The `index` variable will not affect the result of the random number. You can choose to initialize it any way you would like without having to worry about changing the outcome. Hope this helps. #### @AjahnCharles 2017-08-02 14:41:09

Exactly... it's completely unused. I would initialise it directly to the rand: `int index = rand.nextInt(i.Length);` #### @Mark Storer 2019-09-17 18:24:35

Or not at all. `int index; \n index = rand...` if one is fond of declarations and assignments on different lines. Some coding standards are more stringent (and without apparent purpose) than others. #### @jackson 2009-09-04 04:23:27

Use:

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

The integer `x` is now the random number that has a possible outcome of `5-10`. You can achieve that concisely in 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);
`````` #### @Sunil Chawla 2014-08-03 03:07:54

Let us take an example.

Suppose I wish to generate a number between 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);
``````

Let us understand this...

Initialize max with highest value and min with the lowest value.

Now, we need to determine how many possible values can be obtained. For this example, it would be:

5, 6, 7, 8, 9, 10

So, count of this would be max - min + 1.

i.e. 10 - 5 + 1 = 6

The random number will generate a number between 0-5.

i.e. 0, 1, 2, 3, 4, 5

Adding the min value to the random number would produce:

5, 6, 7, 8, 9, 10

Hence we obtain the desired range. #### @TJ_Fischer 2008-12-12 18:35:49

Note that this approach is more biased and less efficient than a `nextInt` approach, https://stackoverflow.com/a/738651/360211

One standard pattern for accomplishing this is:

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

The Java Math library function Math.random() generates a double value in the range `[0,1)`. Notice this range does not include the 1.

In order to get a specific range of values first, you need to multiply by the magnitude of the range of values you want covered.

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

This returns a value in the range `[0,Max-Min)`, where 'Max-Min' is not included.

For example, if you want `[5,10)`, you need to cover five integer values so you use

``````Math.random() * 5
``````

This would return a value in the range `[0,5)`, where 5 is not included.

Now you need to shift this range up to the range that you are targeting. You do this by adding the Min value.

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

You now will get a value in the range `[Min,Max)`. Following our example, that means `[5,10)`:

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

But, this still doesn't include `Max` and you are getting a double value. In order to get the `Max` value included, you need to add 1 to your range parameter `(Max - Min)` and then truncate the decimal part by casting to an int. This is accomplished via:

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

And there you have it. A random integer value in the range `[Min,Max]`, or per the example `[5,10]`:

``````5 + (int)(Math.random() * ((10 - 5) + 1))
`````` #### @Lilian A. Moraru 2012-02-23 23:26:34

The Sun documentation explicitly says that you should better use Random() if you need an int instead of Math.random() which produces a double. #### @weston 2016-12-29 13:35:53

This is actually biased compared to nextInt methods stackoverflow.com/a/738651/360211 #### @Cephalopod 2019-08-29 09:48:18

"Biased" in this case means that after 2^53 executions, some numbers will have had one extra occourance, on average. #### @Alekya 2018-08-22 06:46:32

``````public static void main(String[] args) {

Random ran = new Random();

int min, max;
Scanner sc = new Scanner(System.in);
System.out.println("Enter min range:");
min = sc.nextInt();
System.out.println("Enter max range:");
max = sc.nextInt();
int num = ran.nextInt(min);
int num1 = ran.nextInt(max);
System.out.println("Random Number between given range is " + num1);

}
`````` #### @user2427 2008-12-12 18:28:35

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

Or take a look to RandomUtils from Apache Commons. #### @zakmck 2015-01-30 09:27:17

That's useful, but beware a small flaw: method signatures are like: nextDouble(double startInclusive, double endInclusive), but if you look inside the methods, endInclusive should actually be endExclusive. #### @Holger 2016-06-03 09:47:15

`Double.valueOf(Math.random()*(maximum-minimun)).intValue()` is quite an obfuscated (and inefficient) way to say `(int)(Math.random()*(maximum-minimun))` #### @Hrishikesh Mishra 2016-12-26 05:14:23

Spelling mismatch for minimum return minimum + Double.valueOf(Math.random() * (maximum - minimum)).intValue(); #### @Anjali Pavithra 2019-01-01 09:39:04

Below is a sample class which shows how to generate random integers within a specific range. Assign any value you want as the maximum value to the variable 'max' and assign any value you want as the minimum value to the variable 'min'.

``````public class RandomTestClass {

public static void main(String[] args) {
Random r = new Random();
int max = 10;
int min = 5;
int x;
x = r.nextInt(max) + min;
System.out.println(x);
}

}
`````` #### @Prakhar Nigam 2018-11-17 07:46:35

Use java.util for Random for general use.

You can define your minimum and maximum range to get those results.

``````Random rand=new Random();
rand.nextInt((max+1) - min) + min;
`````` #### @monster 2018-08-14 12:25:54

Making the following change in Attempt 1 should do the work -

``````randomNum = minimum + (int)(Math.random() * (maximum - minimum) );
``````

Check this for working code. #### @Siddhartha Thota 2018-02-25 20:26:34

Say you want range between 0-9, 0 is minimum and 9 is maximum. The below function will print anything between 0 and 9. It's the same for all ranges.

``````public static void main(String[] args) {
int b = randomNumberRange(0, 9);
int d = randomNumberRange (100, 200);
System.out.println("value of b is " + b);
System.out.println("value of d is " + d);
}

public static int randomNumberRange(int min, int max) {
int n = (max + 1 - min) + min;
return (int) (Math.random() * n);
}
`````` #### @user10253771 2019-01-23 01:03:57

This doesn't look right. In "int n = (max + 1 - min) + min; return (int) (Math.random() * n);" , n = max + 1, and you are just creating an int in [0, max] instead of [min, max]. It should be "int n = max + 1 - min; return (int) (Math.random() * n) + min;" #### @namezhouyu 2017-10-09 08:48:28

``````Random random = new Random();
int max = 10;
int min = 3;
int randomNum = random.nextInt(max) % (max - min + 1) + min;
`````` #### @Peter Mortensen 2019-01-05 10:21:20

An explanation would be in order.

### [SOLVED] Generate random integers between 0 and 9

• 2010-10-22 12:48:29
• aneuryzm
• 1896109 View
• 1335 Score
• Tags:   python random integer

### [SOLVED] Generate random number between two numbers in JavaScript

• 2011-02-10 16:41:22
• Mirgorod
• 1449886 View
• 1795 Score
• Tags:   javascript random

### [SOLVED] How do I generate a random int number?

• 2010-04-24 23:09:11
• Rella
• 2307404 View
• 1916 Score
• Tags:   c# random

### [SOLVED] Generate random string/characters in JavaScript

• 2009-08-28 21:14:41
• Tom Lehman
• 1402469 View
• 1776 Score
• Tags:   javascript random