This chapter first explains several ways to generate Java random numbers, and then demonstrates them through an example.

Broadly speaking, there are three ways to generate random numbers in Java:

(01). System.currenttimemillis () to get a long number of milliseconds of the current time.

(02). Returns a double value from 0 to 1 by Math.random ().

(03). By random class to produce a random number, this is a professional random tool class, powerful. The 1th kind uses **System.currenttimemillis () to obtain the random number**

The random number is obtained by System.currenttimemillis (). is actually getting the current number of milliseconds, which is a long type. Use the following methods:

Final long L = System.currenttimemillis ();

To get an integer of type int, you only need to change the result above to an int type. For example, get an int integer between [0, 100). The method is as follows:

Final long L = System.currenttimemillis ();
final int i = (int) (l% 100);

**The 2nd kind uses math.random () to obtain the random number**

The random number is obtained by Math.random (). In effect, it returns a double value of 0 (contained) to 1 (not included). Use the following methods:

Final Double D = math.random ();

To get an integer of type int, you only need to change the result above to an int type. For example, get an int integer between [0, 100). The method is as follows:

Final Double D = math.random ();
final int i = (int) (D*100);

**The 3rd kind uses the random class to obtain the random number**

the random class is used to get the random number.

Use the following methods:

(01) Create the Random object. There are two ways to create a random object, as follows:

Random Random = new Random ();//default construction method
Random Random = new Random (1000);//Specify seed number

(02) Obtaining random numbers by random objects. The random value types supported by Random include: Boolean, Byte, int, long, float, double.

For example, get an int integer between [0, 100). The method is as follows:

int i2 = random.nextint (100);

function interface of Random

Constructor (a): Creates a new random number builder.
Random ()
//Constructor (ii): Creates a new random number generator with a single long seed: public Random (Long Seed) {setseed (seed); The next method uses it to hold the state of the random number generator.
Random (Long Seed)
Boolean Nextboolean () //Returns the Next "Boolean" pseudo random number.
void nextbytes (byte[] buf)//generates random bytes and places them in a byte array buf.
double nextdouble () //Returns a random number with a double type between [0.0, 1.0).
float nextfloat () //Returns a random number of float type between "[0.0, 1.0)".
int nextint () //Returns the next "int type" random number.
int nextint (int n) //Returns a random number of type int between "[0, N)".
long Nextlong () //Returns the next "long" random number.
synchronized Double Nextgaussian () //Returns the next "double" random number, which is a double value of Gaussian ("normal") distribution with an average of 0.0 and a standard deviation of 1.0.
synchronized void Setseed (long Seed)///use a single long seed to set the seed of this random number generator.

**Get random Number sample**

**EG1:**

The following example shows the above 3 ways to get random numbers. The source code is as follows (Randomtest.java):

Import Java.util.Random;
Import Java.lang.Math; /** * Java random number test program.
There are 3 ways to get random numbers: * (01), by System.currenttimemillis () to obtain a long number of the current time milliseconds.
* (02), by Math.random () returns a double value from 0 to 1.
* (03), through the random class to produce a random number, this is a professional random tool class, powerful.
* * @author Skywang * @email kuiwu-wang@163.com/public class randomtest{public static void Main (String args[]) {
The random number Testsystemtimemillis () is returned by the Currenttimemillis () of the system.
The random number Testmathrandom () is returned by the random () of the math.
Create a new "seed 1000" Random object and pass the seed to test the Random API Testrandomapis (new Random (1000), "1st Random (1000)");
Testrandomapis (New Random (1000), "2nd Random (1000)");
Create a new Random object for the default seed and pass the seed to test the Random API Testrandomapis (New Random (), "1st Random ()");
Testrandomapis (New Random (), "2nd Random ()"); /** * return random number-01: Test system Currenttimemillis ()/private static void Testsystemtimemillis () {//via fin
Al long L = system.currenttimemillis (); Through l get a [0, 100) of the integers between the final int i = (int) (l% 100);
System.out.printf ("\ n----system.currenttimemillis ()----\ n l=%s i=%s\n", l, I); /** * Returns random number-02: Test math Random ()/private static void Testmathrandom () {//returns a double by the random () function of the math
Type random number, range [0.0, 1.0) Final Double d = math.random ();
The integer final int i = (int) (D*100) is obtained by D to get a [0, 100];
System.out.printf ("\ n----math.random ()----\ n d=%s i=%s\n", D, I); /** * return random number-03: Test Random API/private static void Testrandomapis (Random Random, String title) {Final I
NT Buffer_len = 5;
Gets a random Boolean value of Boolean B = Random.nextboolean ();
Get the random array buf[] byte[] buf = new Byte[buffer_len];
Random.nextbytes (BUF);
Gets a random double value, range [0.0, 1.0) Double d = random.nextdouble ();
Gets the random float value, the range [0.0, 1.0) Float F = random.nextfloat ();
Gets the random int value int i1 = Random.nextint ();
Gets the int value int i2 = random.nextint (100) between the random [0,100]; Get a random Gaussian distribution double double g = random.neXtgaussian ();
Gets a random long value of long L = Random.nextlong (); System.out.printf ("\ n----%s----\nb=%s, d=%s, f=%s, i1=%s, i2=%s, g=%s, l=%s, buf=[", title, B, D, F, I1, I2, G,
L);
for (byte bt:buf) System.out.printf ("%s,", BT);
System.out.println ("]");
}
}

**EG2:**

Problem: A random number of two digits between the generation ( -10,10) that retains the decimal point.

Workaround:

1.java random number generation function Random r=new Random (); Floating-point random number between r.nextfloat ()//Generation (0,1). Multiply the above random number by 10 to get the random number between the generated (0,10).

2. Generate a Boolean type of random number to control the number of positive and negative: R.nextboolean ();

3. The method of keeping the decimal digits two digits: Math.floor (n*100+0.5)/100; The number obtained is double.

The code is as follows:

Import java.util.*;
public class Createrandom {public
float numrandom () {
float num;
Random r=new Random ();
Float value = (float) (Math.floor (R.nextfloat () *1000+0.5)/100);
Boolean B = R.nextboolean ();
if (b) {
num = value;
}
else{
num=0-value;
return
num;
Public
static void Main (string[] args) {
createrandom cr = new Createrandom ();
float num = Cr.numrandom ();
System.out.print (num);
}
}