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.
Another option is just using 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);
// ...
}
You can use this code snippet which will resolve your problem:
Random r = new Random();
int myRandomNumber = 0;
myRandomNumber = r.nextInt(maxValue-minValue+1)+minValue;
Use myRandomNumber (which will give you a number within a range).
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));
}
}
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 );
In Java 1.7 or later, the standard way to do this is as follows:
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);
See the relevant JavaDoc. This approach has the advantage of not needing to explicitly initialize a java.util.Random instance, which can be a source of confusion and error if used inappropriately.
However, conversely there is no way to explicitly set the seed so it can be difficult to reproduce results in situations where that is useful such as testing or saving game states or similar. In those situations, the pre-Java 1.7 technique shown below can be used.
Before Java 1.7, the standard way to do this is as follows:
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;
}
See the relevant JavaDoc. In practice, the java.util.Random class is often preferable to java.lang.Math.random().
In particular, there is no need to reinvent the random integer generation wheel when there is a straightforward API within the standard library to accomplish the task.
Forgive me for being fastidious, but the solution suggested by the majority, i.e., min + rng.nextInt(max - min + 1)), seems perilous due to the fact that:
rng.nextInt(n) cannot reach Integer.MAX_VALUE.(max - min) may cause overflow when min is negative.A foolproof solution would return correct results for any min <= max within [Integer.MIN_VALUE, Integer.MAX_VALUE]. Consider the following naive implementation:
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;
}
Although inefficient, note that the probability of success in the while loop will always be 50% or higher.
I have created a method to get a unique integer in a given range.
/*
* minNum is the minimum possible random number
* maxNum is the maximum possible random number
* numbersNeeded is the quantity of random number required
* the give method provides you with unique random number between min & max range
*/
public static Set<Integer> getUniqueRandomNumbers( int minNum , int maxNum ,int numbersNeeded ){
if(minNum >= maxNum)
throw new IllegalArgumentException("maxNum must be greater than minNum");
if(! (numbersNeeded > (maxNum - minNum + 1) ))
throw new IllegalArgumentException("numberNeeded must be greater then difference b/w (max- min +1)");
Random rng = new Random(); // Ideally just create one instance globally
// Note: use LinkedHashSet to maintain insertion order
Set<Integer> generated = new LinkedHashSet<Integer>();
while (generated.size() < numbersNeeded)
{
Integer next = rng.nextInt((maxNum - minNum) + 1) + minNum;
// As we're adding to a set, this will automatically do a containment check
generated.add(next);
}
return generated;
}
rand.nextInt((max+1) - min) + min;
In case of rolling a dice it would be random number between 1 to 6 (not 0 to 6), so:
face = 1 + randomNumbers.nextInt(6);
Using Java 8 Streams,
public static List<Integer> generateNumbers(int initialCapacity, int randomBound, Boolean sorted, Random random) {
List<Integer> numbers = random.ints(initialCapacity, 1, randomBound).boxed().collect(Collectors.toList());
if (sorted)
numbers.sort(null);
return numbers;
}
It generates numbers from 1-Randombound in this example.
Here's a helpful class to generate random ints in a range with any combination of inclusive/exclusive bounds:
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;
}
}
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);
Try using org.apache.commons.lang.RandomStringUtils class. Yes, it sometimes give a repeated number adjacently, but it will give the value between 5 and 15:
while (true)
{
int abc = Integer.valueOf(RandomStringUtils.randomNumeric(1));
int cd = Integer.valueOf(RandomStringUtils.randomNumeric(2));
if ((cd-abc) >= 5 && (cd-abc) <= 15)
{
System.out.println(cd-abc);
break;
}
}
I wonder if any of the random number generating methods provided by an Apache Commons Math library would fit the bill.
For example: RandomDataGenerator.nextInt or RandomDataGenerator.nextLong
Another option is just using 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);
// ...
}
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.
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))
You can edit your second code example to:
Random rn = new Random();
int range = maximum - minimum + 1;
int randomNum = rn.nextInt(range) + minimum;
Use:
minimum + rn.nextInt(maxValue - minvalue + 1)
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);
}
Random number from the range [min..max] inclusive:
int randomFromMinToMaxInclusive = ThreadLocalRandom.current()
.nextInt(min, max + 1);
I am thinking to linearly normalize the generated random numbers into desired range by using the following. Let x be a random number, let a and b be the minimum and maximum range of desired normalized number.
Then below is just a very simple code snipplet to test the range produced by the linear mapping.
public static void main(String[] args) {
int a = 100;
int b = 1000;
int lowest = b;
int highest = a;
int count = 100000;
Random random = new Random();
for (int i = 0; i < count; i++) {
int nextNumber = (int) ((Math.abs(random.nextDouble()) * (b - a))) + a;
if (nextNumber < a || nextNumber > b) {
System.err.println("number not in range :" + nextNumber);
}
else {
System.out.println(nextNumber);
}
if (nextNumber < lowest) {
lowest = nextNumber;
}
if (nextNumber > highest) {
highest = nextNumber;
}
}
System.out.println("Produced " + count + " numbers from " + lowest
+ " to " + highest);
}
Following code could be used:
ThreadLocalRandom.current().nextInt(rangeStart, rangeEndExclusive)
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.
import java.util.Random;
public class RandomSSNTest {
public static void main(String args[]) {
generateDummySSNNumber();
}
//831-33-6049
public static void generateDummySSNNumber() {
Random random = new Random();
int id1 = random.nextInt(1000);//3
int id2 = random.nextInt(100);//2
int id3 = random.nextInt(10000);//4
System.out.print((id1+"-"+id2+"-"+id3));
}
}
You can also use
import java.util.concurrent.ThreadLocalRandom;
Random random = ThreadLocalRandom.current();
However, this class doesn’t perform well in a multi-threaded environment.
You can do something like this:
import java.awt.*;
import java.io.*;
import java.util.*;
import java.math.*;
public class Test {
public static void main(String[] args) {
int first, second;
Scanner myScanner = new Scanner(System.in);
System.out.println("Enter first integer: ");
int numOne;
numOne = myScanner.nextInt();
System.out.println("You have keyed in " + numOne);
System.out.println("Enter second integer: ");
int numTwo;
numTwo = myScanner.nextInt();
System.out.println("You have keyed in " + numTwo);
Random generator = new Random();
int num = (int)(Math.random()*numTwo);
System.out.println("Random number: " + ((num>numOne)?num:numOne+num));
}
}
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))
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;
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))
With java-8 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! :)
Use:
minimum + rn.nextInt(maxValue - minvalue + 1)
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.
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.
One of my friends had asked me this same question in university today (his requirements was to generate a random number between 1 & -1). So I wrote this, and it works fine so far with my testing. There are ideally a lot of ways to generate random numbers given a range. Try this:
Function:
private static float getRandomNumberBetween(float numberOne, float numberTwo) throws Exception{
if (numberOne == numberTwo){
throw new Exception("Both the numbers can not be equal");
}
float rand = (float) Math.random();
float highRange = Math.max(numberOne, numberTwo);
float lowRange = Math.min(numberOne, numberTwo);
float lowRand = (float) Math.floor(rand-1);
float highRand = (float) Math.ceil(rand+1);
float genRand = (highRange-lowRange)*((rand-lowRand)/(highRand-lowRand))+lowRange;
return genRand;
}
Execute like this:
System.out.println( getRandomNumberBetween(1,-1));
Use:
minimum + rn.nextInt(maxValue - minvalue + 1)
I just generate a random number using Math.random() and multiply it by a big number, let's say 10000. So, I get a number between 0 to 10,000 and call this number i. Now, if I need numbers between (x, y), then do the following:
i = x + (i % (y - x));
So, all i's are numbers between x and y.
To remove the bias as pointed out in the comments, rather than multiplying it by 10000 (or the big number), multiply it by (y-x).
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);
Using Java 8 Streams,
public static List<Integer> generateNumbers(int initialCapacity, int randomBound, Boolean sorted, Random random) {
List<Integer> numbers = random.ints(initialCapacity, 1, randomBound).boxed().collect(Collectors.toList());
if (sorted)
numbers.sort(null);
return numbers;
}
It generates numbers from 1-Randombound in this example.
The following is another example using Random and forEach
int firstNum = 20;//Inclusive
int lastNum = 50;//Exclusive
int streamSize = 10;
Random num = new Random().ints(10, 20, 50).forEach(System.out::println);
Just use the Random class:
Random ran = new Random();
// Assumes max and min are non-negative.
int randomInt = min + ran.nextInt(max - min + 1);
Following code could be used:
ThreadLocalRandom.current().nextInt(rangeStart, rangeEndExclusive)
rand.nextInt((max+1) - min) + min;
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);
}
In case of rolling a dice it would be random number between 1 to 6 (not 0 to 6), so:
face = 1 + randomNumbers.nextInt(6);
To generate a random number "in between two numbers", use the following code:
Random r = new Random();
int lowerBound = 1;
int upperBound = 11;
int result = r.nextInt(upperBound-lowerBound) + lowerBound;
This gives you a random number in between 1 (inclusive) and 11 (exclusive), so initialize the upperBound value by adding 1. For example, if you want to generate random number between 1 to 10 then initialize the upperBound number with 11 instead of 10.
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 );
You can either use the Random class to generate a random number and then use the .nextInt(maxNumber) to generate a random number. The maxNumber is the number that you want the maximum when generating a random number. Please remember though, that the Random class gives you the numbers 0 through maxNumber-1.
Random r = new Random();
int i = r.nextInt();
Another way to do this is to use the Math.Random() class which many classes in schools require you to use because it is more efficient and you don't have to declare a new Random object. To get a random number using Math.Random() you type in:
Math.random() * (max - min) + min;
import java.util.Random;
public class RandomUtil {
// Declare as class variable so that it is not re-seeded every call
private static Random random = new Random();
/**
* Returns a psuedo-random number between min and max (both inclusive)
* @param min Minimim value
* @param max Maximim value. Must be greater than min.
* @return Integer between min and max (both inclusive)
* @see java.util.Random#nextInt(int)
*/
public static int nextInt(int min, int max) {
// nextInt is normally exclusive of the top value,
// so add 1 to make it inclusive
return random.nextInt((max - min) + 1) + min;
}
}
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);
I think this code will work for it. Please try this:
import java.util.Random;
public final class RandomNumber {
public static final void main(String... aArgs) {
log("Generating 10 random integers in range 1..10.");
int START = 1;
int END = 10;
Random randomGenerator = new Random();
for (int idx=1; idx<=10; ++idx) {
// int randomInt=randomGenerator.nextInt(100);
// log("Generated : " + randomInt);
showRandomInteger(START,END,randomGenerator);
}
log("Done");
}
private static void log(String aMessage) {
System.out.println(aMessage);
}
private static void showRandomInteger(int aStart, int aEnd, Random aRandom) {
if (aStart > aEnd) {
throw new IllegalArgumentException("Start cannot exceed End.");
}
long range = (long)aEnd - (long)aStart + 1;
long fraction = (long) (range * aRandom.nextDouble());
int randomNumber = (int) (fraction + aStart);
log("Generated" + randomNumber);
}
}
You could use
RandomStringUtils.randomNumeric(int count)
method also which is from apache commons.
rand.nextInt((max+1) - min) + min;
Making the following change in Attempt 1 should do the work -
randomNum = minimum + (int)(Math.random() * (maximum - minimum) );
Check this for working code.
You can edit your second code example to:
Random rn = new Random();
int range = maximum - minimum + 1;
int randomNum = rn.nextInt(range) + minimum;
int random = minimum + Double.valueOf(Math.random()*(maximum-minimum )).intValue();
Or take a look to RandomUtils from Apache Commons.
You can do as below.
import java.util.Random;
public class RandomTestClass {
public static void main(String[] args) {
Random r = new Random();
int max, min;
Scanner scanner = new Scanner(System.in);
System.out.println("Enter maximum value : ");
max = scanner.nextInt();
System.out.println("Enter minimum value : ");
min = scanner.nextInt();
int randomNum;
randomNum = r.nextInt(max) + min;
System.out.println("Random Number : " + randomNum);
}
}
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);
You can use following way to do that
int range = 10;
int min = 5
Random r = new Random();
int = r.nextInt(range) + min;
I wonder if any of the random number generating methods provided by an Apache Commons Math library would fit the bill.
For example: RandomDataGenerator.nextInt or RandomDataGenerator.nextLong
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;
}
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.
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);
}
To generate a random number "in between two numbers", use the following code:
Random r = new Random();
int lowerBound = 1;
int upperBound = 11;
int result = r.nextInt(upperBound-lowerBound) + lowerBound;
This gives you a random number in between 1 (inclusive) and 11 (exclusive), so initialize the upperBound value by adding 1. For example, if you want to generate random number between 1 to 10 then initialize the upperBound number with 11 instead of 10.
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[25];
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).
It's better to use SecureRandom rather than just 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;
}
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
There is a library at https://sourceforge.net/projects/stochunit/ for handling selection of ranges.
StochIntegerSelector randomIntegerSelector = new StochIntegerSelector();
randomIntegerSelector.setMin(-1);
randomIntegerSelector.setMax(1);
Integer selectInteger = randomIntegerSelector.selectInteger();
It has edge inclusion/preclusion.
I have created a method to get a unique integer in a given range.
/*
* minNum is the minimum possible random number
* maxNum is the maximum possible random number
* numbersNeeded is the quantity of random number required
* the give method provides you with unique random number between min & max range
*/
public static Set<Integer> getUniqueRandomNumbers( int minNum , int maxNum ,int numbersNeeded ){
if(minNum >= maxNum)
throw new IllegalArgumentException("maxNum must be greater than minNum");
if(! (numbersNeeded > (maxNum - minNum + 1) ))
throw new IllegalArgumentException("numberNeeded must be greater then difference b/w (max- min +1)");
Random rng = new Random(); // Ideally just create one instance globally
// Note: use LinkedHashSet to maintain insertion order
Set<Integer> generated = new LinkedHashSet<Integer>();
while (generated.size() < numbersNeeded)
{
Integer next = rng.nextInt((maxNum - minNum) + 1) + minNum;
// As we're adding to a set, this will automatically do a containment check
generated.add(next);
}
return generated;
}
Making the following change in Attempt 1 should do the work -
randomNum = minimum + (int)(Math.random() * (maximum - minimum) );
Check this for working code.
rand.nextInt((max+1) - min) + min;
This is working fine.
private static Random random = new Random();
public static int getRandomInt(int min, int max){
return random.nextInt(max - min + 1) + min;
}
OR
public static int getRandomInt(Random random, int min, int max)
{
return random.nextInt(max - min + 1) + min;
}
I am thinking to linearly normalize the generated random numbers into desired range by using the following. Let x be a random number, let a and b be the minimum and maximum range of desired normalized number.
Then below is just a very simple code snipplet to test the range produced by the linear mapping.
public static void main(String[] args) {
int a = 100;
int b = 1000;
int lowest = b;
int highest = a;
int count = 100000;
Random random = new Random();
for (int i = 0; i < count; i++) {
int nextNumber = (int) ((Math.abs(random.nextDouble()) * (b - a))) + a;
if (nextNumber < a || nextNumber > b) {
System.err.println("number not in range :" + nextNumber);
}
else {
System.out.println(nextNumber);
}
if (nextNumber < lowest) {
lowest = nextNumber;
}
if (nextNumber > highest) {
highest = nextNumber;
}
}
System.out.println("Produced " + count + " numbers from " + lowest
+ " to " + highest);
}
You can use this code snippet which will resolve your problem:
Random r = new Random();
int myRandomNumber = 0;
myRandomNumber = r.nextInt(maxValue-minValue+1)+minValue;
Use myRandomNumber (which will give you a number within a range).
You can do as below.
import java.util.Random;
public class RandomTestClass {
public static void main(String[] args) {
Random r = new Random();
int max, min;
Scanner scanner = new Scanner(System.in);
System.out.println("Enter maximum value : ");
max = scanner.nextInt();
System.out.println("Enter minimum value : ");
min = scanner.nextInt();
int randomNum;
randomNum = r.nextInt(max) + min;
System.out.println("Random Number : " + randomNum);
}
}
There is a library at https://sourceforge.net/projects/stochunit/ for handling selection of ranges.
StochIntegerSelector randomIntegerSelector = new StochIntegerSelector();
randomIntegerSelector.setMin(-1);
randomIntegerSelector.setMax(1);
Integer selectInteger = randomIntegerSelector.selectInteger();
It has edge inclusion/preclusion.
Forgive me for being fastidious, but the solution suggested by the majority, i.e., min + rng.nextInt(max - min + 1)), seems perilous due to the fact that:
rng.nextInt(n) cannot reach Integer.MAX_VALUE.(max - min) may cause overflow when min is negative.A foolproof solution would return correct results for any min <= max within [Integer.MIN_VALUE, Integer.MAX_VALUE]. Consider the following naive implementation:
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;
}
Although inefficient, note that the probability of success in the while loop will always be 50% or higher.
Random random = new Random();
int max = 10;
int min = 3;
int randomNum = random.nextInt(max) % (max - min + 1) + min;
import java.util.Random;
public class RandomSSNTest {
public static void main(String args[]) {
generateDummySSNNumber();
}
//831-33-6049
public static void generateDummySSNNumber() {
Random random = new Random();
int id1 = random.nextInt(1000);//3
int id2 = random.nextInt(100);//2
int id3 = random.nextInt(10000);//4
System.out.print((id1+"-"+id2+"-"+id3));
}
}
You can also use
import java.util.concurrent.ThreadLocalRandom;
Random random = ThreadLocalRandom.current();
However, this class doesn’t perform well in a multi-threaded environment.
I wonder if any of the random number generating methods provided by an Apache Commons Math library would fit the bill.
For example: RandomDataGenerator.nextInt or RandomDataGenerator.nextLong
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);
}
Most of above suggestion don't consider 'overflow', For example: min = Integer.MIN_VALUE, max = 100. One of correct approaches I have so far is:
final long mod = max- min + 1L;
final int next = (int) (Math.abs(rand.nextLong() % mod) + min);
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;
You can edit your second code example to:
Random rn = new Random();
int range = maximum - minimum + 1;
int randomNum = rn.nextInt(range) + minimum;
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.
You can either use the Random class to generate a random number and then use the .nextInt(maxNumber) to generate a random number. The maxNumber is the number that you want the maximum when generating a random number. Please remember though, that the Random class gives you the numbers 0 through maxNumber-1.
Random r = new Random();
int i = r.nextInt();
Another way to do this is to use the Math.Random() class which many classes in schools require you to use because it is more efficient and you don't have to declare a new Random object. To get a random number using Math.Random() you type in:
Math.random() * (max - min) + min;
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);
}
Use:
minimum + rn.nextInt(maxValue - minvalue + 1)
A different approach using Java 8 IntStream and Collections.shuffle
import java.util.stream.IntStream;
import java.util.ArrayList;
import java.util.Collections;
public class Main {
public static void main(String[] args) {
IntStream range = IntStream.rangeClosed(5,10);
ArrayList<Integer> ls = new ArrayList<Integer>();
//populate the ArrayList
range.forEach(i -> ls.add(new Integer(i)) );
//perform a random shuffle using the Collections Fisher-Yates shuffle
Collections.shuffle(ls);
System.out.println(ls);
}
}
The equivalent in Scala
import scala.util.Random
object RandomRange extends App{
val x = Random.shuffle(5 to 10)
println(x)
}
Most of above suggestion don't consider 'overflow', For example: min = Integer.MIN_VALUE, max = 100. One of correct approaches I have so far is:
final long mod = max- min + 1L;
final int next = (int) (Math.abs(rand.nextLong() % mod) + min);
rand.nextInt((max+1) - min) + min;
This is working fine.
As of Java 7, you should no longer use
Random. For most uses, the random number generator of choice is nowThreadLocalRandom.
For fork join pools and parallel streams, useSplittableRandom.
Joshua Bloch. Effective Java. Third Edition.
For fork join pools and parallel streams, use SplittableRandom that is usually faster, has a better statistical independence and uniformity properties in comparison with Random.
To generate a random int in the range [0, 1_000]:
int n = new SplittableRandom().nextInt(0, 1_001);
To generate a random int[100] array of values in the range [0, 1_000]:
int[] a = new SplittableRandom().ints(100, 0, 1_001).parallel().toArray();
To return a Stream of random values:
IntStream stream = new SplittableRandom().ints(100, 0, 1_001);
You can edit your second code example to:
Random rn = new Random();
int range = maximum - minimum + 1;
int randomNum = rn.nextInt(range) + minimum;
In Java 1.7 or later, the standard way to do this is as follows:
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);
See the relevant JavaDoc. This approach has the advantage of not needing to explicitly initialize a java.util.Random instance, which can be a source of confusion and error if used inappropriately.
However, conversely there is no way to explicitly set the seed so it can be difficult to reproduce results in situations where that is useful such as testing or saving game states or similar. In those situations, the pre-Java 1.7 technique shown below can be used.
Before Java 1.7, the standard way to do this is as follows:
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;
}
See the relevant JavaDoc. In practice, the java.util.Random class is often preferable to java.lang.Math.random().
In particular, there is no need to reinvent the random integer generation wheel when there is a straightforward API within the standard library to accomplish the task.
rand.nextInt((max+1) - min) + min;
In Java 1.7 or later, the standard way to do this is as follows:
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);
See the relevant JavaDoc. This approach has the advantage of not needing to explicitly initialize a java.util.Random instance, which can be a source of confusion and error if used inappropriately.
However, conversely there is no way to explicitly set the seed so it can be difficult to reproduce results in situations where that is useful such as testing or saving game states or similar. In those situations, the pre-Java 1.7 technique shown below can be used.
Before Java 1.7, the standard way to do this is as follows:
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;
}
See the relevant JavaDoc. In practice, the java.util.Random class is often preferable to java.lang.Math.random().
In particular, there is no need to reinvent the random integer generation wheel when there is a straightforward API within the standard library to accomplish the task.
int random = minimum + Double.valueOf(Math.random()*(maximum-minimum )).intValue();
Or take a look to RandomUtils from Apache Commons.
With java-8 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! :)
Try using org.apache.commons.lang.RandomStringUtils class. Yes, it sometimes give a repeated number adjacently, but it will give the value between 5 and 15:
while (true)
{
int abc = Integer.valueOf(RandomStringUtils.randomNumeric(1));
int cd = Integer.valueOf(RandomStringUtils.randomNumeric(2));
if ((cd-abc) >= 5 && (cd-abc) <= 15)
{
System.out.println(cd-abc);
break;
}
}
Random number from the range [min..max] inclusive:
int randomFromMinToMaxInclusive = ThreadLocalRandom.current()
.nextInt(min, max + 1);
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;
}
It can be done by simply doing the statement:
Randomizer.generate(0,10); //min of zero, max of ten
Below is its source-code
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.
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.
Here is a simple sample that shows how to generate random number from closed [min, max] range, while min <= max is true
You can reuse it as field in hole class, also having all Random.class methods in one place
Results example:
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
Sources:
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;
}
}
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)
I will simply state what is wrong with the solutions provided by the question and why the errors.
Solution 1:
randomNum = minimum + (int)(Math.random()*maximum);
Problem: randomNum is assigned values numbers bigger than maximum.
Explanation: Suppose our minimum is 5, and your maximum is 10. Any value from Math.random() greater than 0.6 will make the expression evaluate to 6 or greater, and adding 5 makes it greater than 10 (your maximum). The problem is you are multiplying the random number by the maximum (which generates a number almost as big as the maximum) and then adding the minimum. Unless the minimum is 1, it's not correct. You have to switch to, as mentioned in other answers
randomNum = minimum + (int)(Math.random()*(maximum-minimum+1))
The +1 is because Math.random() will never return 1.0.
Solution 2:
Random rn = new Random();
int n = maximum - minimum + 1;
int i = rn.nextInt() % n;
randomNum = minimum + i;
Your problem here is that '%' may return a negative number if the first term is smaller than 0. Since rn.nextInt() returns negative values with ~50% chance, you will also not get the expected result.
This, was, however, almost perfect. You just had to look a bit further down the Javadoc, nextInt(int n). With that method available, doing
Random rn = new Random();
int n = maximum - minimum + 1;
int i = rn.nextInt(n);
randomNum = minimum + i;
Would also return the desired result.
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);
Use Apache Lang3 Commons
Integer.parseInt(RandomStringUtils.randomNumeric(6, 6));
Min Value 100000 to Max Value 999999
In Java 1.7 or later, the standard way to do this is as follows:
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);
See the relevant JavaDoc. This approach has the advantage of not needing to explicitly initialize a java.util.Random instance, which can be a source of confusion and error if used inappropriately.
However, conversely there is no way to explicitly set the seed so it can be difficult to reproduce results in situations where that is useful such as testing or saving game states or similar. In those situations, the pre-Java 1.7 technique shown below can be used.
Before Java 1.7, the standard way to do this is as follows:
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;
}
See the relevant JavaDoc. In practice, the java.util.Random class is often preferable to java.lang.Math.random().
In particular, there is no need to reinvent the random integer generation wheel when there is a straightforward API within the standard library to accomplish the task.
private static Random random = new Random();
public static int getRandomInt(int min, int max){
return random.nextInt(max - min + 1) + min;
}
OR
public static int getRandomInt(Random random, int min, int max)
{
return random.nextInt(max - min + 1) + min;
}
This will generate Random numbers list with range (Min - Max) with no duplicate.
generateRandomListNoDuplicate(1000, 8000, 500);
Add this method.
private void generateRandomListNoDuplicate(int min, int max, int totalNoRequired) {
Random rng = new Random();
Set<Integer> generatedList = new LinkedHashSet<>();
while (generatedList.size() < totalNoRequired) {
Integer radnomInt = rng.nextInt(max - min + 1) + min;
generatedList.add(radnomInt);
}
}
Hope this will help you.
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));
}
}
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.
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[25];
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).
You could use
RandomStringUtils.randomNumeric(int count)
method also which is from apache commons.
import java.util.Random;
public class RandomUtil {
// Declare as class variable so that it is not re-seeded every call
private static Random random = new Random();
/**
* Returns a psuedo-random number between min and max (both inclusive)
* @param min Minimim value
* @param max Maximim value. Must be greater than min.
* @return Integer between min and max (both inclusive)
* @see java.util.Random#nextInt(int)
*/
public static int nextInt(int min, int max) {
// nextInt is normally exclusive of the top value,
// so add 1 to make it inclusive
return random.nextInt((max - min) + 1) + min;
}
}
If you already use Commons Lang API 2.x or latest version then there is one class for random number generation RandomUtils.
public static int nextInt(int n)
Returns a pseudorandom, uniformly distributed int value between 0 (inclusive) and the specified value (exclusive), from the Math.random() sequence.
Parameters: n - the specified exclusive max-value
int random = RandomUtils.nextInt(1000000);
Note: In RandomUtils have many methods for random number generation
Here's a helpful class to generate random ints in a range with any combination of inclusive/exclusive bounds:
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;
}
}
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;
}
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))
A different approach using Java 8 IntStream and Collections.shuffle
import java.util.stream.IntStream;
import java.util.ArrayList;
import java.util.Collections;
public class Main {
public static void main(String[] args) {
IntStream range = IntStream.rangeClosed(5,10);
ArrayList<Integer> ls = new ArrayList<Integer>();
//populate the ArrayList
range.forEach(i -> ls.add(new Integer(i)) );
//perform a random shuffle using the Collections Fisher-Yates shuffle
Collections.shuffle(ls);
System.out.println(ls);
}
}
The equivalent in Scala
import scala.util.Random
object RandomRange extends App{
val x = Random.shuffle(5 to 10)
println(x)
}
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
Use Apache Lang3 Commons
Integer.parseInt(RandomStringUtils.randomNumeric(6, 6));
Min Value 100000 to Max Value 999999
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.
To avoid repeating what have been said multiple times, I am showing an alternative for those that need a cryptographically stronger pseudo-random number generator by using the SecureRandom class, which extends the class Random. From source one can read:
This class provides a cryptographically strong random number generator (RNG). A cryptographically strong random number minimally complies with the statistical random number generator tests specified in FIPS 140-2, Security Requirements for Cryptographic Modules, section 4.9.1. Additionally, SecureRandom must produce non-deterministic output. Therefore any seed material passed to a SecureRandom object must be unpredictable, and all SecureRandom output sequences must be cryptographically strong, as described in RFC 1750: Randomness Recommendations for Security.
A caller obtains a SecureRandom instance via the no-argument constructor or one of the getInstance methods:
SecureRandom random = new SecureRandom();Many SecureRandom implementations are in the form of a pseudo-random number generator (PRNG), which means they use a deterministic algorithm to produce a pseudo-random sequence from a true random seed. Other implementations may produce true random numbers, and yet others may use a combination of both techniques.
To generate a random number between a min and max values inclusive:
public static int generate(SecureRandom secureRandom, int min, int max) {
return min + secureRandom.nextInt((max - min) + 1);
}
for a given a min (inclusive) and max (exclusive) values:
return min + secureRandom.nextInt((max - min));
A running code example:
public class Main {
public static int generate(SecureRandom secureRandom, int min, int max) {
return min + secureRandom.nextInt((max - min) + 1);
}
public static void main(String[] arg) {
SecureRandom random = new SecureRandom();
System.out.println(generate(random, 0, 2 ));
}
}
Source such as stackoverflow, baeldung, geeksforgeeks provide comparisons between Random and SecureRandom classes.
From baeldung one can read:
The most common way of using SecureRandom is to generate int, long, float, double or boolean values:
int randomInt = secureRandom.nextInt();
long randomLong = secureRandom.nextLong();
float randomFloat = secureRandom.nextFloat();
double randomDouble = secureRandom.nextDouble();
boolean randomBoolean = secureRandom.nextBoolean();For generating int values we can pass an upper bound as a parameter:
int randomInt = secureRandom.nextInt(upperBound);
In addition, we can generate a stream of values for int, double and long:
IntStream randomIntStream = secureRandom.ints();
LongStream randomLongStream = secureRandom.longs();
DoubleStream randomDoubleStream = secureRandom.doubles();For all streams we can explicitly set the stream size:
IntStream intStream = secureRandom.ints(streamSize);
This class offers several other options (e.g., choosing the underlying random number generator) that are out of the scope of this question.
I think this code will work for it. Please try this:
import java.util.Random;
public final class RandomNumber {
public static final void main(String... aArgs) {
log("Generating 10 random integers in range 1..10.");
int START = 1;
int END = 10;
Random randomGenerator = new Random();
for (int idx=1; idx<=10; ++idx) {
// int randomInt=randomGenerator.nextInt(100);
// log("Generated : " + randomInt);
showRandomInteger(START,END,randomGenerator);
}
log("Done");
}
private static void log(String aMessage) {
System.out.println(aMessage);
}
private static void showRandomInteger(int aStart, int aEnd, Random aRandom) {
if (aStart > aEnd) {
throw new IllegalArgumentException("Start cannot exceed End.");
}
long range = (long)aEnd - (long)aStart + 1;
long fraction = (long) (range * aRandom.nextDouble());
int randomNumber = (int) (fraction + aStart);
log("Generated" + randomNumber);
}
}
Just use the Random class:
Random ran = new Random();
// Assumes max and min are non-negative.
int randomInt = min + ran.nextInt(max - min + 1);
As of Java 7, you should no longer use
Random. For most uses, the random number generator of choice is nowThreadLocalRandom.
For fork join pools and parallel streams, useSplittableRandom.
Joshua Bloch. Effective Java. Third Edition.
For fork join pools and parallel streams, use SplittableRandom that is usually faster, has a better statistical independence and uniformity properties in comparison with Random.
To generate a random int in the range [0, 1_000]:
int n = new SplittableRandom().nextInt(0, 1_001);
To generate a random int[100] array of values in the range [0, 1_000]:
int[] a = new SplittableRandom().ints(100, 0, 1_001).parallel().toArray();
To return a Stream of random values:
IntStream stream = new SplittableRandom().ints(100, 0, 1_001);
I wonder if any of the random number generating methods provided by an Apache Commons Math library would fit the bill.
For example: RandomDataGenerator.nextInt or RandomDataGenerator.nextLong
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.
It's better to use SecureRandom rather than just 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;
}
If you already use Commons Lang API 2.x or latest version then there is one class for random number generation RandomUtils.
public static int nextInt(int n)
Returns a pseudorandom, uniformly distributed int value between 0 (inclusive) and the specified value (exclusive), from the Math.random() sequence.
Parameters: n - the specified exclusive max-value
int random = RandomUtils.nextInt(1000000);
Note: In RandomUtils have many methods for random number generation
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.
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)
int random = minimum + Double.valueOf(Math.random()*(maximum-minimum )).intValue();
Or take a look to RandomUtils from Apache Commons.
To avoid repeating what have been said multiple times, I am showing an alternative for those that need a cryptographically stronger pseudo-random number generator by using the SecureRandom class, which extends the class Random. From source one can read:
This class provides a cryptographically strong random number generator (RNG). A cryptographically strong random number minimally complies with the statistical random number generator tests specified in FIPS 140-2, Security Requirements for Cryptographic Modules, section 4.9.1. Additionally, SecureRandom must produce non-deterministic output. Therefore any seed material passed to a SecureRandom object must be unpredictable, and all SecureRandom output sequences must be cryptographically strong, as described in RFC 1750: Randomness Recommendations for Security.
A caller obtains a SecureRandom instance via the no-argument constructor or one of the getInstance methods:
SecureRandom random = new SecureRandom();Many SecureRandom implementations are in the form of a pseudo-random number generator (PRNG), which means they use a deterministic algorithm to produce a pseudo-random sequence from a true random seed. Other implementations may produce true random numbers, and yet others may use a combination of both techniques.
To generate a random number between a min and max values inclusive:
public static int generate(SecureRandom secureRandom, int min, int max) {
return min + secureRandom.nextInt((max - min) + 1);
}
for a given a min (inclusive) and max (exclusive) values:
return min + secureRandom.nextInt((max - min));
A running code example:
public class Main {
public static int generate(SecureRandom secureRandom, int min, int max) {
return min + secureRandom.nextInt((max - min) + 1);
}
public static void main(String[] arg) {
SecureRandom random = new SecureRandom();
System.out.println(generate(random, 0, 2 ));
}
}
Source such as stackoverflow, baeldung, geeksforgeeks provide comparisons between Random and SecureRandom classes.
From baeldung one can read:
The most common way of using SecureRandom is to generate int, long, float, double or boolean values:
int randomInt = secureRandom.nextInt();
long randomLong = secureRandom.nextLong();
float randomFloat = secureRandom.nextFloat();
double randomDouble = secureRandom.nextDouble();
boolean randomBoolean = secureRandom.nextBoolean();For generating int values we can pass an upper bound as a parameter:
int randomInt = secureRandom.nextInt(upperBound);
In addition, we can generate a stream of values for int, double and long:
IntStream randomIntStream = secureRandom.ints();
LongStream randomLongStream = secureRandom.longs();
DoubleStream randomDoubleStream = secureRandom.doubles();For all streams we can explicitly set the stream size:
IntStream intStream = secureRandom.ints(streamSize);
This class offers several other options (e.g., choosing the underlying random number generator) that are out of the scope of this question.
This will generate Random numbers list with range (Min - Max) with no duplicate.
generateRandomListNoDuplicate(1000, 8000, 500);
Add this method.
private void generateRandomListNoDuplicate(int min, int max, int totalNoRequired) {
Random rng = new Random();
Set<Integer> generatedList = new LinkedHashSet<>();
while (generatedList.size() < totalNoRequired) {
Integer radnomInt = rng.nextInt(max - min + 1) + min;
generatedList.add(radnomInt);
}
}
Hope this will help you.
You can do something like this:
import java.awt.*;
import java.io.*;
import java.util.*;
import java.math.*;
public class Test {
public static void main(String[] args) {
int first, second;
Scanner myScanner = new Scanner(System.in);
System.out.println("Enter first integer: ");
int numOne;
numOne = myScanner.nextInt();
System.out.println("You have keyed in " + numOne);
System.out.println("Enter second integer: ");
int numTwo;
numTwo = myScanner.nextInt();
System.out.println("You have keyed in " + numTwo);
Random generator = new Random();
int num = (int)(Math.random()*numTwo);
System.out.println("Random number: " + ((num>numOne)?num:numOne+num));
}
}
Here is a simple sample that shows how to generate random number from closed [min, max] range, while min <= max is true
You can reuse it as field in hole class, also having all Random.class methods in one place
Results example:
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
Sources:
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;
}
}
One of my friends had asked me this same question in university today (his requirements was to generate a random number between 1 & -1). So I wrote this, and it works fine so far with my testing. There are ideally a lot of ways to generate random numbers given a range. Try this:
Function:
private static float getRandomNumberBetween(float numberOne, float numberTwo) throws Exception{
if (numberOne == numberTwo){
throw new Exception("Both the numbers can not be equal");
}
float rand = (float) Math.random();
float highRange = Math.max(numberOne, numberTwo);
float lowRange = Math.min(numberOne, numberTwo);
float lowRand = (float) Math.floor(rand-1);
float highRand = (float) Math.ceil(rand+1);
float genRand = (highRange-lowRange)*((rand-lowRand)/(highRand-lowRand))+lowRange;
return genRand;
}
Execute like this:
System.out.println( getRandomNumberBetween(1,-1));
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);
The following is another example using Random and forEach
int firstNum = 20;//Inclusive
int lastNum = 50;//Exclusive
int streamSize = 10;
Random num = new Random().ints(10, 20, 50).forEach(System.out::println);
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[25];
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).
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);
}
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;
}
You can use following way to do that
int range = 10;
int min = 5
Random r = new Random();
int = r.nextInt(range) + min;
int random = minimum + Double.valueOf(Math.random()*(maximum-minimum )).intValue();
Or take a look to RandomUtils from Apache Commons.
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[25];
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).
It can be done by simply doing the statement:
Randomizer.generate(0,10); //min of zero, max of ten
Below is its source-code
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.
Random random = new Random();
int max = 10;
int min = 3;
int randomNum = random.nextInt(max) % (max - min + 1) + min;
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.
I just generate a random number using Math.random() and multiply it by a big number, let's say 10000. So, I get a number between 0 to 10,000 and call this number i. Now, if I need numbers between (x, y), then do the following:
i = x + (i % (y - x));
So, all i's are numbers between x and y.
To remove the bias as pointed out in the comments, rather than multiplying it by 10000 (or the big number), multiply it by (y-x).
Source: Stackoverflow.com