Java Random number Generation principle

Source: Internet
Author: User
Tags time in milliseconds

One. In J2SE we can use the Math.random () method to produce a random number, the resulting random number is a double between 0-1, we can multiply him by a certain number, for example, multiplied by 100, he is a random within 100, this is not in the J2ME.

Two. In Java.util this package is provided with a random class, we can create a random object to generate a stochastic number, he can produce random integers, random float, random double, random long, This is also a method that we often use to take random numbers in the J2ME program.

Three. In our system class there is a Currenttimemillis () method, which returns a number of milliseconds from January 1, 1970 0:0 0 seconds to the current one, the return type is long, we can take him as a random number, we can take him to some number modulo, We can limit him to a range.

In fact, in the default constructor method of random, the third method is used to generate random numbers.

The following instructions are available for the random class in method two:

The Java.util.Random class is built in two ways: with seeds and without seeds

Without seeds:
This way will return random numbers, each running a different result

public class Randomtest {
public static void Main (string[] args) {
Java.util.Random r=new java.util.Random ();
for (int i=0;i<10;i++) {
System.out.println (R.nextint ());

With seeds:
This way, no matter how many times the program runs, the result is the same

public static void Main (string[] args) {
Java.util.Random r=new Java.util.Random (10);
for (int i=0;i<10;i++) {
System.out.println (R.nextint ());

The difference between the two approaches is that

(1) First Open the Java Doc, and we'll see a description of the Random class:

An instance of this class is used to generate a pseudo-random number stream, which uses a 48-bit seed that can be modified with a linear congruence formula (see Donald Knuth's "The Art of computer programming, Volume 2", section 3.2.1).

If you create two Random instances with the same seed, the same method call sequence is made for each instance, and they will generate and return the same sequence of numbers. To ensure this, we specify a specific algorithm for the class random. For the full portability of Java code, the Java implementation must have the class Random use all the algorithms shown here. However, subclasses of the Random class are allowed to use other algorithms as long as they conform to the general contract of all methods.

Java Doc has explained the random class very well, and our tests have verified this.

(2) If no seed number is provided, the seed number of the random instance will be the number of milliseconds of the current time, which can be obtained by System.currenttimemillis () to obtain the current time in milliseconds. Open the source code of the JDK and we can see it very clearly.

Public Random () {This (System.currenttimemillis ());}

Other than that:

Description of the Nextint (), nextint (int n) method of the Random object:

int Nextint ()
Returns the next pseudo-random number, which is an int value that is evenly distributed in the sequence of this random number generator.
int nextint (int n)
Returns a pseudo-random number, which is an int value that is taken out of the sequence of this random number generator, evenly distributed between 0 (inclusive) and a specified value (not included).

In Java we can use the Java.util.Random class to produce a random number generator. It has two forms of constructors, namely random () and random (long Seed). Random () uses the current time, System.currenttimemillis () as the seed of the generator, and random (long Seed) uses the specified seed as the seed of the generator.

After the random number generator (randomness) object is produced, different types of random numbers are obtained by calling different Method:nextint (), Nextlong (), Nextfloat (), nextdouble (), and so on.

1> Generating Random numbers
Random random = new random ();
Random random = new random (100);//Specify seed number 100
Random calls a different method to get the stochastic number.
If 2 random objects use the same seed (for example, all 100) and call the same function in the same order, they return exactly the same value. The output of the two random objects in the code below is exactly the same
Import java.util.*;
Class Testrandom {
public static void Main (string[] args) {
Random random1 = new random (100);
System.out.println (Random1.nextint ());
System.out.println (Random1.nextfloat ());
System.out.println (Random1.nextboolean ());
Random random2 = new random (100);
System.out.println (Random2.nextint ());
System.out.println (Random2.nextfloat ());
System.out.println (Random2.nextboolean ());

2> a random number within a specified range
Random number control within a range, using the modulo operator%
Import java.util.*;
Class Testrandom {
public static void Main (string[] args) {
Random random = new random ();
for (int i = 0; i < 10;i++) {
System.out.println (Math.Abs (Random.nextint ()));
The obtained random number has positive negative, using math.abs to make the obtained data range non-negative

3> gets the non-repeating random number in the specified range
Import java.util.*;
Class Testrandom {
public static void Main (string[] args) {
int[] intret = new Int[6];
int INTRD = 0; Store random Numbers
int count = 0; Record the number of random numbers generated
int flag = 0; Whether a flag has been generated
while (count<6) {
Random RDM = new Random (System.currenttimemillis ());
INTRD = Math.Abs (Rdm.nextint ()) 2+1;
for (int i=0;i<count;i++) {
flag = 1;
Flag = 0;
if (flag==0) {
Intret[count] = INTRD;
for (int t=0;t<6;t++) {
System.out.println (t+ ", +intret[t]);

Java random number class introduction

Class Java.util.Random in the Java Utility Class Library provides methods for generating various types of random numbers. It can produce random numbers of types such as int, long, float, double, and Goussian. This is also the biggest difference between it and the method in Java.lang.Math, which only produces a random number of type double.
The method in class random is very simple, it has only two construction methods and six common methods.
Construction Method:
(1) public Random ()
(2) Public Random (long Seed)
Java generates a random number that requires a base value of seed, and in the first method the base value defaults to the system time as seed.
Common methods:
(1) Public synonronized void Setseed (Long Seed)
The method is to set the base value seed.
(2) public int nextint ()
The method is to produce an integer random number.
(3) public long Nextlong ()
The method is to produce a long type random number.
(4) Public float nextfloat ()
The method is to produce a float-type random number.
(5) public double nextdouble ()
The method is to produce a double type random number.
(6) Public synchronized double Nextgoussian ()
The method is to produce a double type of Goussian random number.
Example 2
Import java.lang.*;
Import Java.util.Random;

public class randomapp{
public static void Main (String args[]) {
Random ran1=new random ();
Random ran2=new random (12345);
Two classes of random objects were created.
System.out.println ("The 1st set of random numbers:");
System.out.println ("Integer:" +ran1.nextint ());
System.out.println ("Long:" +ran1.nextlong ());
System.out.println ("Float:" +ran1.nextfloat ());
System.out.println ("Double:" +ran1.nextdouble ());
System.out.println ("Gaussian:" +ran1.nextgaussian ());
Generate various types of random numbers
System.out.print ("The 2nd set of random numbers:");
for (int i=0;i<5;i++) {
System.out.println (Ran2.nextint () + "");
if (i==2) System.out.println ();
produces different random numbers of the same type.
System.out.println ();

Random random=new random ();
Random.nextint ();

can also have nextfloat and so on, all kinds of basic types have

Math.random can also
Say you want a random number between 0-10.
You can write that.
(int) (Math.random () *10);

Java produces a specified range of random numbers

Java generates a specified range of random numbers
Production mechanism:
Generate a number between Min-max
Implementation principle:
Math.Round (Math.random () * (max-min) +min)

Long Temp; cannot be set to int, must be set to long
Generate random numbers from 1000 to 9999
Temp=math.round (Math.random () *8999+1000);

Generate a specified range of random numbers

public static int getrandom (int start,int end) {

if (Start>end | | start <0 | | end <0) {



return (int) (Math.random () * (end-start+1)) +start;


Java Random number Generation principle

Related Article

Contact Us

The content source of this page is from Internet, which doesn't represent Alibaba Cloud's opinion; products and services mentioned on that page don't have any relationship with Alibaba Cloud. If the content of the page makes you feel confusing, please write us an email, we will handle the problem within 5 days after receiving your email.

If you find any instances of plagiarism from the community, please send an email to: and provide relevant evidence. A staff member will contact you within 5 working days.

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.