Java常用算法教程
 Java判断阿姆斯特朗数 Java打印各种图案 

Java生成随机数

1 Java生成随机数的方式

在Java编程中，我们经常需要在开发应用程序时生成随机数。许多应用程序具有随机生成数字的功能。

随机数是使用大量数字并使用数学算法选择一个数字的数字。它满足以下两个条件：

  • 生成的值在确定的时间间隔内均匀分布。
  • 无法根据当前和过去的值来猜测未来的值。

在Java中，使用方法和类可以通过四种方式生成随机数。

  • 使用random()方法
  • 使用Random类
  • 使用ThreadLocalRandom类
  • 使用Random类的ints()方法（Java 8新增）

2 方式一：使用random()方法

2.1 介绍

Java Math类具有许多用于不同数学运算的方法。其中之一是random() 方法。它是Math类的静态方法。我们可以直接调用它。它仅生成大于或等于0.0且小于1.0的双精度型随机数。在使用random() 方法之前，我们必须导入java.lang.Math类。

2.2 语法

public static double random()

该方法不接受任何参数。它返回一个大于或等于0.0且小于1.0的伪随机双精度数。

2.3 案例1

让我们创建一个使用random() 方法生成随机数的程序。

/**
 * 一点教程网： http://www.yiidian.com
 */
import java.lang.Math;   
public class RandomNumberExample1  
{   
public static void main(String args[])   
{   
// Generating random numbers  
System.out.println("1st Random Number: " + Math.random());   
System.out.println("2nd Random Number: " + Math.random());  
System.out.println("3rd Random Number: " + Math.random());   
System.out.println("4th Random Number: " + Math.random());   
}   
}

输出结果为：

1st Random Number: 0.17434160924512265
2nd Random Number: 0.4297410090709448
3rd Random Number: 0.4828656381344487
4th Random Number: 0.13267917059488898

注意：每次执行程序时，我们得到不同的输出。您的输出可能与上面显示的输出不同。

如果要生成指定范围之间的随机数，也可以使用以下公式。

Math.random() * (max - min + 1) + min

在上面的公式中，最小值是包括在内的，而最大值是包括在内的。

2.4 案例2

/**
 * 一点教程网： http://www.yiidian.com
 */
public class RandomNumberExample2  
{  
public static void main( String args[] )   
{  
int min = 200;  
int max = 400;  
//Generate random double value from 200 to 400   
System.out.println("Random value of type double between "+min+" to "+max+ ":");  
double a = Math.random()*(max-min+1)+min;   
System.out.println(a);  
//Generate random int value from 200 to 400   
System.out.println("Random value of type int between "+min+" to "+max+ ":");  
int b = (int)(Math.random()*(max-min+1)+min);  
System.out.println(b);  
}  
}

第一次输出结果为：

Random value of type double between 200 to 400:
233.88329802655377
Random value of type int between 200 to 400:
329

第二次输出结果为：

Random value of type double between 200 to 400:
254.8419979875385
Random value of type int between 200 to 400:
284

3 方式二：使用Random类

产生一个随机数的另一种方法是使用Java的Random类，该类在java.util包中。它生成伪随机数流。我们可以生成任何数据类型的随机数，例如整数，浮点数，双精度型，布尔型和长型。如果要使用此类生成随机数，请按照以下步骤操作：

  • 首先，导入类java.lang.Random。
  • 创建一个Random类的对象。
  • 调用以下任何一种方法：
  • nextInt(int bound)
  • nextInt()
  • nextFloat()
  • nextDouble()
  • nextLong()
  • nextBoolean()

以上所有方法均从该随机数生成器的序列返回下一个伪随机，均质分布的值（对应的方法）。nextDouble() 和nextFloat() 方法产生0.0到1.0之间的随机值。

nextInt(int bound) 方法接受绑定（upper）的参数必须为正。它会生成一个介于0到bound-1之间的随机数。

让我们创建一个使用Random类生成随机数的程序。

/**
 * 一点教程网： http://www.yiidian.com
 */
import java.util.Random;   
public class RandomNumberExample3  
{   
public static void main(String args[])   
{   
// creating an object of Random class   
Random random = new Random();   
// Generates random integers 0 to 49  
int x = random.nextInt(50);   
// Generates random integers 0 to 999  
int y = random.nextInt(1000);   
// Prints random integer values  
System.out.println("Randomly Generated Integers Values");  
System.out.println(x);   
System.out.println(y);   
// Generates Random doubles values  
double a = random.nextDouble();   
double b = random.nextDouble();   
// Prints random double values  
System.out.println("Randomly Generated Double Values");  
System.out.println(a);   
System.out.println(b);    
// Generates Random float values  
float f=random.nextFloat();  
float i=random.nextFloat();  
// Prints random float values  
System.out.println("Randomly Generated Float Values");  
System.out.println(f);   
System.out.println(i);   
// Generates Random Long values  
long p = random.nextLong();   
long q = random.nextLong();   
// Prints random long values  
System.out.println("Randomly Generated Long Values");  
System.out.println(p);   
System.out.println(q);    
// Generates Random boolean values  
boolean m=random.nextBoolean();  
boolean n=random.nextBoolean();  
// Prints random boolean values  
System.out.println("Randomly Generated Boolean Values");  
System.out.println(m);   
System.out.println(n);   
}   
}

输出结果为：

Randomly Generated Integers Values
23
767
Randomly Generated Double Values
0.37823814494212016
0.998058172671956
Randomly Generated Float Values
0.87804186
0.93880254
Randomly Generated Long Values
-4974823544291679198
3650240138416076693
Randomly Generated Boolean Values
false
true

4 方式三：使用ThreadLocalRandom类

java.util.concurrent包中定义的ThreadLocalRandom类，该类可以使用内部生成的种子初始化来生成随机数，与Math类的随机生成器相同。无法修改。我们可以通过以下方式使用此类：

ThreadLocalRandom.current().nextX(...)

其中X是Int，Long等。

注意：不可能在多个线程共享使用ThreadLocalRandom。

我们可以生成任何数据类型的随机数，例如整数，浮点数，双精度型，布尔型和长型。如果要使用此类生成随机数，请按照以下步骤操作：

  • 首先，使用java.util.concurrent.ThreadLocalRandom导入类。
  • 调用您要为其随机生成数字的相应方法。
  • nextInt()
  • nextDouble()
  • nextLong()
  • nextFloat()
  • nextBoolean()

上述所有方法都将覆盖Random类的相应方法，并返回相应的值。

  • nextInt(int bound)
  • nextDouble(int bound)
  • nextLong(int bound)

上面的方法解析（upper）必须为正的参数边界。它返回介于0（含）和指定边界（不含）之间的相应随机生成的值。如果边界为负，则抛出IllegalArgumentExcetion。

  • nextInt(int origin, int bound)
  • nextDouble(int origin, int bound)
  • nextLong(int origin, int bound)

上述方法解析两个参数origin和bound。原点指定返回的最小值，界限指定上限。它返回指定的原点（包括）和边界（排除）之间的相应随机生成的值。另外，如果原点大于或等于bound ，则抛出IllegalArgumentExcetion。

让我们创建一个使用ThreadLocalRandom类生成随机数的程序。

/**
 * 一点教程网： http://www.yiidian.com
 */
import java.util.concurrent.ThreadLocalRandom;   
public class RandomNumberExample4  
{   
public static void main(String args[])   
{   
// Generate random integers between 0 to 999   
int a = ThreadLocalRandom.current().nextInt();   
int b = ThreadLocalRandom.current().nextInt();   
// Print random integer values  
System.out.println("Randomly Generated Integer Values:");  
System.out.println(a);   
System.out.println(b);   
// Generate Random double values  
double c = ThreadLocalRandom.current().nextDouble();   
double d = ThreadLocalRandom.current().nextDouble();   
// Print random doubles   
System.out.println("Randomly Generated Double Values:");  
System.out.println(c);   
System.out.println(d);   
// Generate random boolean values  
boolean e = ThreadLocalRandom.current().nextBoolean();   
boolean f = ThreadLocalRandom.current().nextBoolean();   
// Print random Booleans   
System.out.println("Randomly Generated Boolean Values:");  
System.out.println(e);   
System.out.println(f);   
}   
}

第一次输出结果为：

Randomly Generated Integer Values:
348534891
-1887936727
Randomly Generated Double Values:
0.15644440033119833
0.5242730752133399
Randomly Generated Boolean Values:
true
true

第二次输出结果为：

Randomly Generated Integer Values:
402755574
295398333
Randomly Generated Double Values:
0.4856461791062565
0.5148677091077654
Randomly Generated Boolean Values:
false
true

5 方式四：使用Random类的ints()方法

在Java 8中，新方法ints() 已添加到Random类。使用该方法之前，我们必须导入java.util.Random。

5.1 ints()方法 ：

伪随机整数值生成与调用nextInt() 方法相同。它返回无限的伪随机整数值流。

5.2 ints(long streamSize)方法 ：

该方法解析long类型的参数streamSize。它指定要生成的值的数量。伪随机整数值生成与调用nextInt（）方法相同。它还返回随机生成的int值的流。如果流大小小于零，则抛出IllegalArgumentException。

5.3 ints(long streamSize, int randomNumberOrigin, int randomNumberBound)方法：

参数：

  • streamSize：要生成的值的数量。
  • randomNumberOrigin：每个随机值的来源
  • randomNumberBound：每个随机值的界限

它返回具有指定起点和界限的伪随机整数值流。如果发生以下情况，则抛出IllegalArgumentException：

  • stramSize < 0
  • origin > = bound

5.4 ints(int  randomNumberOrigin，  int  randomNumberBound)方法：  

参数：

  • randomNumberOrigin：每个随机值的来源
  • randomNumberBound：每个随机值的界限

它以指定的原点和边界返回无限制的伪随机整数值流。如果原点大于或等于bound ，则抛出IllegalArgumentException。

同样，我们也可以分别使用longs() 和doubles() 方法生成long和double类型的流。

让我们创建一个使用Random类的ints() 方法生成整数流的程序。

/**
 * 一点教程网： http://www.yiidian.com
 */
import java.util.Random;   
public class RandomNumberExample5   
{   
public static void main(String[] args)   
{   
randomInts(5);  
randomInts(9, 50, 90);  
//getStreamOfRandomInts(30, 50);  
}   
//method that generates a stream of integers having size 5  
public static void randomInts(int num)   
{  
Random random = new Random();  
random.ints(num).forEach(System.out::println);  
}  
//method that generates a stream of 9 integers between 50 to 90  
public static void randomInts(int num, int origin, int bound)   
{  
Random random1 = new Random();  
random1.ints(num, origin, bound).forEach(System.out::println);  
}  
}

第一次输出：

727900357
-1073118456
306279822
370327182
1366265119
65
75
75
88
76
75
56
86
85

第二次输出：

-1338107947
-1698771421
594232770
-1224937976
-1625069815
56
69
67
87
64
52
72
75
76

 

 Java判断阿姆斯特朗数 Java打印各种图案 

热门文章

优秀文章

全部教程