One. In J2SE we can use the Math.random () method to produce a random number, the resulting random number is a double between 01, 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 pseudorandom number stream, which uses a 48bit 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 pseudorandom number, which is an int value that is evenly distributed in the sequence of this random number generator.
int nextint (int n)
Returns a pseudorandom 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 nonnegative 3> gets the nonrepeating 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++) { if (INTRET[I]==INTRD) { flag = 1; Break }else{ Flag = 0; } } if (flag==0) { Intret[count] = INTRD; count++; } } 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 floattype 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 Randomapp.java. 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 010.
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 Minmax
Implementation principle:
Math.Round (Math.random () * (maxmin) +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) {
return1;
}
return (int) (Math.random () * (endstart+1)) +start;
}
Java Random number Generation principle