How to generate random numbers in Java

How to generate random numbers in Java? This article will introduce to you how to generate random numbers in Java. It has certain reference value. Friends in need can refer to it. I hope it will be helpful to you.

In Java, three methods are provided to generate random numbers using some built-in methods and classes, as follows:

1, java.util.Random class

2 , Math.random method: can generate random numbers of double type.

3. ThreadLocalRandom class

Let’s take a look at how Java implements the generation of random numbers.

1. java.util.Random class

Classes in the Java utility class library: java.util.Random provides methods for generating various types of random numbers. .

To generate random numbers using the java.util.Random class, we must first create an instance of this class and then use that instance to call methods like nextInt(), nextDouble(), nextLong(), etc.

We can use the java.util.Random class to randomly generate: random numbers of integers, floating point numbers, double precision numbers, long integers, Boolean operands and other types.

We can pass parameters to the method to put an upper bound on the range of numbers to be generated. For example, nextInt(6) will generate a number in the range 0 to 5, inclusive.

// 随机数生成
// 使用java.util.Random; 
import java.util.Random; 

public class generateRandom{ 

	public static void main(String args[]) 
	{ 
		// 创建随机类的实例
		Random rand = new Random(); 

		// 在0到999范围内生成随机整数
		int rand_int1 = rand.nextInt(1000); 
		int rand_int2 = rand.nextInt(1000); 

		// 输出随机整数
		System.out.println("随机整数: "+rand_int1); 
		System.out.println("随机整数: "+rand_int2); 

		// 生成随机双精度数
		double rand_dub1 = rand.nextDouble(); 
		double rand_dub2 = rand.nextDouble(); 

		// 输出随机双精度数
		System.out.println("随机双精度数: "+rand_dub1); 
		System.out.println("随机双精度数: "+rand_dub2); 
	} 
}

Run output:

2. Math.random method

Math class contains Various methods for performing various numerical operations, such as exponentiation, logarithms, etc. One of these methods: random(), can return a double number with a positive sign. The value is greater than or equal to 0.0 and less than 1.0, that is, the value range is the left-closed and right-open interval of [0.0, 1.0).

The value returned by the random() method is pseudo-randomly selected and (approximately) uniformly distributed within the range of [0.0,1.0).

Note: It can only generate double type random numbers.

Below we will introduce how to use this method to generate random numbers through java code:

// Math.random() 生成随机数
import java.util.*; 

public class generateRandom 
{ 
	public static void main(String args[]) 
	{ 
		// 随机双精度数的生成
		System.out.println("随机双精度数: " + Math.random()); 
		System.out.println("随机双精度数: " + Math.random()); 
	} 
}

Running results:

3. java.util.concurrent.ThreadLocalRandom class

The ThreadLocalRandom class was introduced in java 1.7. It provides concurrent generation of random numbers and can resolve competition among multiple threads. Can generate random numbers of integer, double precision, Boolean and other types.

The main implementation details of ThreadLocalRandom:

1), use an ordinary long instead of using the AtomicLong in Random as seed

2), you cannot create a ThreadLocalRandom instance yourself, Because its constructor is private, we can use its static method ThreadLocalRandom.current()

3), which is CPU cache aware and uses 8 long virtual fields to fill the 64-bit L1 high speed Cache line

Below we will introduce how to use this class to generate random numbers through simple java code:

// 随机数的产生
// 使用java.util.concurrent.ThreadLocalRandom类
import java.util.concurrent.ThreadLocalRandom; 

public class generateRandom 
{ 
	public static void main(String args[]) 
	{ 
		// 在0到999范围内生成随机整数
		int rand_int1 = ThreadLocalRandom.current().nextInt(); 
		int rand_int2 = ThreadLocalRandom.current().nextInt(); 

		// 输出随机整数
		System.out.println("Random Integers: " + rand_int1); 
		System.out.println("Random Integers: " + rand_int2); 

		// 生成随机双精度数
		double rand_dub1 = ThreadLocalRandom.current().nextDouble(); 
		double rand_dub2 = ThreadLocalRandom.current().nextDouble(); 

		// 输出随机双精度数
		System.out.println("Random Doubles: " + rand_dub1); 
		System.out.println("Random Doubles: " + rand_dub2); 

		// 生成随机布尔值
		boolean rand_bool1 = ThreadLocalRandom.current().nextBoolean(); 
		boolean rand_bool2 = ThreadLocalRandom.current().nextBoolean(); 

		// 输出随机布尔值
		System.out.println("Random Booleans: " + rand_bool1); 
		System.out.println("Random Booleans: " + rand_bool2); 
	} 
}

Run output:

Summary: The above is the entire content of this article, I hope it will be helpful to everyone's study. For more related video tutorials, please visit: JavaTutorial!

The above is the detailed content of How to generate random numbers in Java. For more information, please follow other related articles on the PHP Chinese website!