Home How do I generate random integers within a specific range in Java?

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

user42155
1#
user42155 Published in 2008-12-12 18:20:57Z
 I am trying to generate a random intvalue with Java, but in a specific range. For example: My range is 5-10, meaning that 5 is the smallest possible value and 10 is the biggest. Any other number in between these numbers is possible to be a value, too. In Java, there is a method random() in the Math class, which returns a double value between 0.0 and 1.0. In the class Random there is the method nextInt(int n), which returns a random int value in the range of 0 (inclusive) and n (exclusive). I couldn't find a method, which returns a random integer value between two numbers. I have tried the following things, but I still have problems: (minimum and maximum are the smallest and biggest numbers). Solution 1: randomNum = minimum + (int)(Math.random() * maximum);  Problem: randomNum can be bigger than maximum. Solution 2: Random rn = new Random(); int n = maximum - minimum + 1; int i = rn.nextInt() % n; randomNum = minimum + i;  Problem: randomNum can be smaller than minimum. How do I solve these problems? I have tried also browsing through the archive and found: Expand a random range from 1–5 to 1–7 Generate random numbers uniformly over an entire range But I couldn't solve the problem.
Peter Mortensen
2#
Peter Mortensen Reply to 2014-06-22 22:22:52Z
 Use: minimum + rn.nextInt(maxValue - minvalue + 1) 
Greg Case
3#
Greg Case Reply to 2018-01-04 07:02:27Z
 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 * Integer.MAX_VALUE - 1. * * @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.
YCF_L
4#
  rand.nextInt((max+1) - min) + min; 
beat
5#
 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
Peter Mortensen
6#
Peter Mortensen Reply to 2014-06-22 22:23:28Z
 int random = minimum + Double.valueOf(Math.random()*(maximum-minimun)).intValue();  Or take a look to RandomUtils from Apache Commons.
Bill the Lizard
7#
Bill the Lizard Reply to 2008-12-12 18:31:28Z
 You can edit your second code example to: Random rn = new Random(); int range = maximum - minimum + 1; int randomNum = rn.nextInt(range) + minimum; 
Community
8#
 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)) 
Peter Mortensen
9#
Peter Mortensen Reply to 2013-08-01 18:02:34Z
 When you need a lot of random numbers, I do not recommend the Random class in the API. It has just a too small period. Try the Mersenne twister instead. There is a Java implementation.
Matt R
10#
Matt R Reply to 2016-10-13 18:03:56Z
 The Math.Random class in Java is 0-based. So, if you write something like 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).
dnuka
11#
 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.
GAMITG
12#
 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); 
GAMITG
13#
 rand.nextInt((max+1) - min) + min;  This is working fine.
Joel Sjöstrand
14#
Joel Sjöstrand Reply to 2011-01-10 13:31:37Z
 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 naïve 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.
Peter Mortensen
15#
Peter Mortensen Reply to 2013-08-01 18:25:39Z
 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); } 
GAMITG
16#
 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); 
Garrett Hall
17#
Garrett Hall Reply to 2012-02-15 16:19:03Z
 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; } } 
YCF_L
18#
 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. 
YCF_L
19#
 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; } 
GAMITG
20#
 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).
YCF_L
21#
 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).
GAMITG
22#
 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)); 
GAMITG
23#
 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)
Peter Mortensen
24#
Peter Mortensen Reply to 2013-08-01 18:07:15Z
 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; } } 
Peter Mortensen
25#
Peter Mortensen Reply to 2014-06-22 22:26:02Z
 If you want to try the answer with the most votes above, you can simply use this code: public class Randomizer { public static int generate(int min,int max) { return min + (int)(Math.random() * ((max - min) + 1)); } public static void main(String[] args) { System.out.println(Randomizer.generate(0,10)); } }  It is just clean and simple.
GAMITG
26#
 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); } } 
Peter Mortensen
27#
Peter Mortensen Reply to 2014-01-18 12:47:07Z
 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); } 
GAMITG
28#
 Just use the Random class: Random ran = new Random(); // Assumes max and min are non-negative. int randomInt = min + ran.nextInt(max - min + 1); 
GAMITG
29#
 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.
 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; } }