Here you will learn to generate random number in java between two given number by different means. I will try to provide cons for different mechanism so that you can choose what is best for you.

1- Math.random()

This method will always return number between 0(inclusive) and 1(exclusive). Simple tweak can be used to generate random number between give two numbers.

package com.jbt.random;

import java.util.Random;

/*
 * Generate random number between given high and low number.
 */
public class generate_random_between_two_number {
	public static void main(String[] args) {
		// It will generate random number between 0 and 50
		System.out.println((int) (Math.random() * 50));

		/*
		 * Below code will generate random number
		 * between 10 and 50. ((int)
		 * (Math.random()*(maximum - minimum))) +
		 * minimum
		 * 
		 * This is simple tweak which is used
		 * here. First we generate random number
		 * between 0 and (maximum - minimum)(40 in
		 * current scenario) and then adding
		 * minimum number after random number gets
		 * generated.
		 * 
		 */
		System.out.println(
				((int) (Math.random() * (50 - 10))) + 10);

	}
}

Bullet Points :

• Internally it uses java.util.Random() to generate random numbers.
• First time when called, it creates random number generator and for future calls it uses nextDouble() method from random class.
• Method is synchronized hence multiple thread is accessing this to generate numbers it may reduce contention for each thread to have its own pseudorandom-number generator.
• For better performance for multi threaded environment you can use ThreadLocalRandom introduced in JDK 1.7.
• As Math.random internally uses nextDouble method, it will always return double number.
• In order to get Integer you have to cast the value to integer.

 

2- java.util.Random

package com.jbt.random;

import java.util.Random;

/*
 * Generate random number between given high and low number.
 */
public class generate_random_between_two_number {
	public static void main(String[] args) {

		Random randomObj = new Random();

		/*
		 * Below code will generate random number
		 * between 10 and 50. ((int)
		 * (Math.random()*(maximum - minimum))) +
		 * minimum
		 * 
		 * This is simple tweak which is used
		 * here. First we generate random number
		 * between 0 and (maximum - minimum)(40 in
		 * current scenario) and then adding
		 * minimum number after random number gets
		 * generated.
		 * 
		 * Max value is exclusive in case of
		 * nextInt to make it inclusive you need
		 * to add 1.
		 */
		int randomNum = randomObj.nextInt((50 - 10)) + 10;
		System.out.println(randomNum);

	}
}

Bullet Points:

• Same as above, Here contention problem will occur in case of multi threaded environment. As random is only used in case of Math.random.
• To overcome performance problem you can use ThreadLocalRandom.
• As opposed to Math.random, Random class have multiple methods for generating different type of numbers(e.g. int/double/long etc).
• There are multiple algorithms that can be used by random class for generating random numbers.
• For portability it is necessary to let random class use all algorithms available.
• Random class is not final meaning it can extended and extended class can use any specific algorithms to generate random number.

 

3- ThreadLocalRandom

ThreadLocalRandom extends Random class and provide enhancement for multi threaded environment.

package com.jbt.random;

import java.util.concurrent.ThreadLocalRandom;

public class ThreadLocalRandom_Example {
	public static void main(String[] args) {
		
		/*
		 * Returns random integer value between 0(Inclusive) and given value(exclusive).
		 */
		System.out.println(ThreadLocalRandom.current().nextInt(50));
		
		// Returns random integer value between given numbers.
		System.out.println(ThreadLocalRandom.current().nextInt(10, 50));
	}
}

Bullet Point

• ThreadLocalRandom provides better performance than random in case of multi threaded environment.
• Explicit seed setting is not allowed.

 

4- Java 8

In java 8 some new methods have been included in Random class. Which can be used to generate random number without any hiccups. You can use Java 8 Lambda feature to get the result.

package com.jbt.random;

import java.util.Random;

/*
 * Generate random integer between two given number using methods 
 * introduced in JDK 1.8.
 */
public class generate_random_between_two_number_jdk_8 {
	public static void main(String[] args) {
		Random randomObj = new Random();
		System.out.println(randomObj.ints(10, 50).findFirst().getAsInt()); ;
	}
}

References

• Official Doc Math.random()
• Official Doc java.util.Random 
• Official Doc ThreadLocalRandom