JAVA随机数生成

合集下载

java生成五位随机数的方法

Java生成五位随机数的方法在Java编程中，生成随机数是一项常见的任务。

随机数在许多应用中都有广泛的用途，例如密码生成、游戏开发、数据随机化等。

本文将介绍如何使用Java生成五位随机数的方法，并提供一些示例代码和解释。

1. 使用Random类生成随机数Java提供了Random类来生成随机数。

Random类的nextInt()方法可以生成一个范围内的随机整数。

我们可以利用这个方法生成五位随机数。

以下是使用Random类生成五位随机数的示例代码：import java.util.Random;public class RandomNumberGenerator {public static void main(String[] args) {Random random = new Random();int randomNumber = random.nextInt(90000) + 10000;System.out.println("随机数：" + randomNumber);}}上述代码中，我们首先创建了一个Random对象random，然后使用nextInt(90000)生成一个0到89999之间的随机整数。

为了确保生成的随机数是五位数，我们再加上10000，使其范围变为10000到99999。

最后，通过System.out.println()方法打印生成的随机数。

2. 使用Math.random()生成随机数除了使用Random类，我们还可以使用Math类的random()方法生成随机数。

Math 类的random()方法返回一个0到1之间的随机浮点数。

我们可以将其乘以一个适当的倍数，并进行类型转换，以生成五位随机数。

以下是使用Math类生成五位随机数的示例代码：public class RandomNumberGenerator {public static void main(String[] args) {int randomNumber = (int) (Math.random() * 90000) + 10000;System.out.println("随机数：" + randomNumber);}}上述代码中，我们使用(int)将浮点数转换为整数，并将Math.random()乘以90000，使其范围变为0到89999。

java获取随机数的方法

java获取随机数的方法在Java中，获取随机数是非常常见的操作，而且是很多应用程序所必需的。

随机数可以用来创建随机数据，制造游戏中的随机事件，以及伪随机数生成器的使用等。

本文将介绍一些在Java中生成随机数的方法，以及如何在代码中使用它们。

Java中的随机数生成器Java中的随机数生成器对于生成均匀分布的随机数是很有用的。

在Java中，我们可以使用Java.util.Random类和Java.security.SecureRandom类来生成随机数。

两者的主要区别在于SecureRandom类可以生成更安全的随机数，而且它可以用来产生加密密钥等。

使用Java.util.Random类Java.util.Random类是Java内置的随机数生成器。

它可以生成均匀分布的随机数，而且是线程安全的，多个线程可以同时访问。

以下是使用Java.util.Random类生成随机数的示例：```javaimport java.util.Random;public class RandomNumberGenerator {public static void main(String[] args) {Random rand = new Random();int randNum1 = rand.nextInt(); // 生成随机整数double randNum2 = rand.nextDouble(); // 生成随机小数float randNum3 = rand.nextFloat(); // 生成随机小数boolean randNum4 = rand.nextBoolean(); // 生成随机布尔值System.out.println("Random number 1: " + randNum1);System.out.println("Random number 2: " + randNum2);System.out.println("Random number 3: " + randNum3);System.out.println("Random number 4: " + randNum4);}}```在上面的代码中，我们使用Random类生成了四种不同类型的随机数，包括整数、小数和布尔值。

java中生成不重复六位随机数的方法

一、介绍在进行Java编程时，经常需要生成随机数以满足各种需求。

而有时候我们需要生成不重复的随机数，比如生成不重复的六位随机数。

本文将介绍几种在Java中生成不重复六位随机数的方法。

二、使用java.util.Random类java.util.Random类是Java中用于生成伪随机数的实用类，利用它可以生成随机数。

下面介绍如何利用java.util.Random类生成不重复的六位随机数：1. 创建一个长度为xxx的boolean类型数组，用来标记已经生成过的随机数；2. 利用java.util.Random类生成随机数，并将对应的数组位置设为true；3. 当生成的随机数对应的数组位置已经为true时，重新生成随机数。

代码示例如下：```javaimport java.util.Random;public class UniqueRandomNumberGenerator {public static void m本人n(String[] args) {boolean[] used = new boolean[xxx];Random random = new Random();int count = 0;while (count < xxx) {int num = random.nextInt(xxx);if (!used[num]) {used[num] = true;count++;System.out.println(String.format("06d", num));}}}}```上述代码利用了java.util.Random类生成了不重复的六位随机数。

但是这种方法存在一个问题，当生成的随机数接近xxx时，时间复杂度和空间复杂度都会非常高。

三、使用java.util.Collections.shuffle()方法java.util.Collections类提供了shuffle()方法，可以对列表中的元素进行随机重排。

java 从指定的数组中获取随机数的方法

Java 从指定的数组中获取随机数的方法本文介绍了在 Java 中从指定的数组中获取随机数的几种方法，包括使用Random 类、使用 Math.random() 方法和使用 UniformRandomNumberGenerator 类等。

下面是本店铺为大家精心编写的5篇《Java 从指定的数组中获取随机数的方法》，供大家借鉴与参考，希望对大家有所帮助。

《Java 从指定的数组中获取随机数的方法》篇1在 Java 中，从指定的数组中获取随机数有多种方法。

以下是其中的几种方法:方法一：使用 Random 类Random 类是 Java 中生成随机数的一个常用类。

使用 Random 类，可以通过 nextInt() 方法从指定的数组中获取随机数。

以下是一个示例代码:```javaimport java.util.Arrays;import java.util.Random;public class GetRandomNumber {public static void main(String[] args) {int[] arr = {1, 2, 3, 4, 5};Random random = new Random();int randomNumber = random.nextInt(arr.length);System.out.println("随机数为:" + arr[randomNumber]);}}```方法二：使用 Math.random() 方法Math.random() 方法可以生成一个 0 到 1 之间的随机数。

可以使用这种方法从指定的数组中获取随机数。

以下是一个示例代码: ```javaimport java.util.Arrays;public class GetRandomNumber {public static void main(String[] args) {int[] arr = {1, 2, 3, 4, 5};double randomNumber = Math.random() * arr.length;int index = (int) (randomNumber);System.out.println("随机数为:" + arr[index]);}}```方法三：使用 UniformRandomNumberGenerator 类UniformRandomNumberGenerator 类可以生成指定范围内的随机数。

java中产生随机数的方法

java中产生随机数的方法在Java中，我们可以使用几种方法来生成随机数。

下面介绍了三种常用的方法：1. 使用Math类的random()方法：Math类是Java中的一个内置类，它提供了许多数学运算相关的方法。

其中，random()方法可以用来生成一个0到1之间的随机浮点数。

我们可以通过对生成的浮点数进行适当的运算来获取我们想要的随机数范围。

示例代码：```double randomNum = Math.random();int randomInt = (int) (randomNum * range) + min;```在上面的代码中，range表示生成的随机数的范围（差值），min表示生成的随机数的最小值。

我们将随机浮点数乘以范围，并将结果转换为整型，再加上最小值，即可得到我们想要的随机整数。

2. 使用Random类：Random类是Java中提供的一个专门用于生成随机数的类，它的实例方法可以生成不同类型的随机数。

示例代码：```import java.util.Random;Random random = new Random();int randomInt = random.nextInt(range) + min;```在上面的代码中，range表示生成的随机数的范围（差值），min表示生成的随机数的最小值。

我们调用nextInt()方法来生成一个随机整数，通过设置范围和最小值，即可得到我们想要的随机整数。

3. 使用ThreadLocalRandom类：ThreadLocalRandom类是Java SE 7中引入的一个线程局部的随机数生成器，它提供了更高效和更安全的随机数生成。

示例代码：```import java.util.concurrent.ThreadLocalRandom;int randomInt = ThreadLocalRandom.current().nextInt(min, max);```在上面的代码中，min表示生成的随机数的最小值，max表示生成的随机数的最大值。

java获取十位随机数的方法

java获取十位随机数的方法摘要：1.引言2.获取十位随机数的方法a.使用java.util.Random类b.使用java.util.concurrent.ThreadLocalRandom类c.使用Math.random()方法3.示例代码4.总结正文：在Java编程中，获取随机数是非常常见的操作。

本文将介绍三种获取十位随机数的方法。

首先，我们可以使用java.util.Random类。

这个类提供了多种方法来生成随机数。

以下是一个使用Random类获取十位随机数的示例代码：```javaimport java.util.Random;public class RandomNumber {public static void main(String[] args) {Random rand = new Random();int randomNumber = rand.nextInt(9000000000) + 1000000000; // 生成一个十位随机数System.out.println("十位随机数: " + randomNumber);}}```其次，我们可以使用java.util.concurrent.ThreadLocalRandom类。

这个类是Java 7引入的，它提供了线程安全的随机数生成器。

以下是一个使用ThreadLocalRandom类获取十位随机数的示例代码：```javaimport java.util.concurrent.ThreadLocalRandom;public class RandomNumber {public static void main(String[] args) {int randomNumber =ThreadLocalRandom.current().nextInt(1000000000, 999999999); // 生成一个十位随机数System.out.println("十位随机数: " + randomNumber);}}```最后，我们还可以使用Math.random()方法。

java中随机生成数字的方法

Java中随机生成数字的方法在Java编程中，经常需要生成随机数字。

随机数字的生成可以用于各种场景，例如游戏开发、密码生成、数据模拟等。

本文将介绍Java中常用的几种随机生成数字的方法，并提供示例代码和解释。

Random类Java提供了Random类来生成伪随机数。

Random类的实例可以通过调用其方法来生成不同类型的随机数。

1. 生成整数使用Random类的nextInt()方法可以生成一个范围内的随机整数。

以下是一个示例代码：import java.util.Random;public class RandomExample {public static void main(String[] args) {Random random = new Random();int randomNumber = random.nextInt(100); // 生成0到99之间的随机整数System.out.println(randomNumber);}}上述代码创建了一个Random对象，然后调用nextInt(100)方法来生成0到99之间的随机整数。

运行程序会输出一个不同的整数。

2. 生成浮点数使用Random类的nextDouble()方法可以生成0到1之间（包括0但不包括1）的伪随机浮点数。

以下是一个示例代码：import java.util.Random;public class RandomExample {public static void main(String[] args) {Random random = new Random();double randomNumber = random.nextDouble(); // 生成0到1之间（包括0但不包括1）的随机浮点数System.out.println(randomNumber);}}上述代码创建了一个Random对象，然后调用nextDouble()方法来生成0到1之间的随机浮点数。

java 随机数生成方法

java 随机数生成方法
在Java中，生成随机数有多种方法。

其中最常用的是使用 Java 自带的 Math 类和 Random 类。

1. Math.random() 方法
Math 类中的 random() 方法可以生成一个 [0,1) 之间的double 类型的随机数。

如果需要生成整数类型的随机数，可以将结果进行强制类型转换。

示例代码：
```
int num = (int) (Math.random() * 10);
System.out.println(num); // 生成一个 [0,9] 之间的整数
```
2. Random 类
Random 类提供了更多的随机数生成方法。

可以使用 nextInt() 方法生成整数类型的随机数，也可以使用 nextDouble() 生成double 类型的随机数。

示例代码：
```
Random random = new Random();
int num = random.nextInt(10); // 生成一个 [0,9] 之间的整数
double d = random.nextDouble(); // 生成一个 [0.0,1.0) 之
间的 double 类型随机数
```
需要注意的是，使用 Random 类生成的随机数需要先创建一个Random 对象，否则每次生成的随机数都相同。

以上就是 Java 中生成随机数的两种常用方法。

需要根据实际需求选择合适的方法来生成随机数。

java中随机数语句的规则

java中随机数语句的规则在Java中，生成随机数是经常用到的一种操作。

随机数是一组按照无序和无规律排列的数，不受限制，范围可以是无穷大。

而如何在Java中生成随机数呢？下面就为大家介绍一下Java中随机数语句的规则。

1. 使用Math.random()函数Java中可以使用Math类的random()方法生成随机数。

该方法返回一个带有小数的double类型的随机数，其范围是0.0到1.0（左闭右开区间，即包括0.0，但不包括1.0）。

为了得到在一定范围内的整数随机数，可以使用强制类型转换的方法。

例如，要产生一个10以内的整数随机数，代码如下：```int rand = (int)(Math.random() * 10);```生成的rand的值为0到9之间的整数。

2. 使用Random类Java中还有一个Random类可以用于生成随机数。

首先需要创建一个Random对象，然后调用其nextInt()或nextDouble()方法，从而生成随机数。

例如，要产生一个10以内的整数随机数，代码如下：```Random random = new Random();int rand = random.nextInt(10);```生成的rand的值为0到9之间的整数。

3. 设置随机数种子如果使用Math.random()方法生成随机数，程序默认的随机数种子是当前时间的毫秒数。

因此，每次程序运行调用Math.random()方法生成的随机数是不同的。

不过，如果需要生成一段固定顺序的随机数序列，可以通过设置随机数种子来实现。

例如：```Random random = new Random(1000);int rand = random.nextInt(10);```以上代码中，设置随机数种子为1000，每次调用random.nextInt(10)方法得到的整数随机数都是一样的。

总结本文主要介绍了Java中随机数语句的规则，其中介绍了Math.random()函数和Random类的使用方法，以及如何设置随机数种子。

在Java中产生随机数的两个方法

在Java中产生随机数的两个方法一、利用random方法来生成随机数。

在Java语言中生成随机数相对来说比较简单，因为有一个现成的方法可以使用。

在Math类中，Java语言提供了一个叫做random的方法。

通过这个方法可以让系统产生随机数。

不过默认情况下，其产生的随机数范围比较小，为大于等于0到小于1的double 型随机数。

虽然其随机数产生的范围比较小，不能够满足日常的需求。

如日常工作中可能需要产生整数的随机数。

其实，只要对这个方法进行一些灵活的处理，就可以获取任意范围的随机数。

如我们可以先通过random方法生成一个随机数，然后将结果乘以10。

此时产生的随机数字即为大于等于0小于10的数字。

然后再利用Int方法进行转换(它会去掉小数掉后面的数字，即只获取整数部分，不是四舍五入)。

最后即可获取一个0到9的整数型随机数字。

其实现方法很简单，就是对原有的random方法按照如下的格式进行变型：(int)(Math.Random()*10)即可。

其实我们还可以对这个方法进行扩展，让其产生任意范围内的随机数。

至需要将这个10换成n即可，如改为(int)(Math.Random()*n)。

此时应用程序就会产生一个大于等于0小与n之间的随机数。

如将n设置为5，那么其就会产生一个0到5之间的整数型的随机数。

如果将这个写成一个带参数的方法，那么只要用户输入需要生成随机数的最大值，就可以让这个方法来生成制定范围的随机数。

在Java中定义自己的工具库有时候程序员可能需要生成一个指定范围内的随机偶数或者奇数。

此时是否可以通过这个方法来实现呢?答案是肯定的。

如现在程序要需要生成一个1-100范围内的偶数。

此时该如何实现?首先，需要生成一个0到99之内的随机数(至于这里为什么是99，大家耐心看下去就知道原因了)。

要实现这个需求，很简单吧，只要通过如下语句就可以实现：i=1+(int)(Math.Random()*100)。

java指定范围生成随机数的方法

java指定范围生成随机数的方法Java是一种常用的编程语言，在编写程序时，随机数生成是重要的一环，因为它可以用来模拟一些场景，比如游戏中的随机事件、抽奖等等。

本文将介绍如何在Java中指定范围生成随机数。

一、使用Java Random类Java中提供了Random类，这个类可以用来生成随机数。

生成一个指定范围内的随机数，可以通过控制生成的随机数范围和基准值实现。

代码实例如下：```javaimport java.util.Random;public class RandomDemo {public static void main(String[] args) {Random random = new Random();int range = 100; // 生成随机数的范围，0-99int base = 1; // 生成随机数的基准值，1int num = random.nextInt(range) + base;System.out.println(num);}}```上述代码中，使用了Random类的nextInt方法生成一个指定范围内的随机数，通过设置基准值为1，控制生成的随机数的最小值为1，即使取到0，加上基准值后也是1。

二、使用Math.random方法Math.random()方法可以生成一个范围在0-1之间的double类型的随机数，其实我们可以通过计算，使得这个数范围变为我们需要的范围，然后将其强制类型转换为整数。

代码实例如下：```javapublic class RandomDemo {public static void main(String[] args) {int range = 100; // 生成随机数的范围，0-99int base = 1; // 生成随机数的基准值，1int num = (int) (Math.random() * range + base);System.out.println(num);}}```以上代码中，同样设置生成随机数的范围和基准值，并使用Math.random()方法生成随机数，然后通过计算和强转数据类型实现生成指定范围内的随机数。

java中的random函数用法

java中的random函数用法在Java中，使用Random类可以生成随机数。

Random类提供了多种生成随机数的方法。

以下是Random类的一些常用方法和用法：1.生成随机整数：```javaRandom random = new Random();int randomNumber = random.nextInt();```生成的随机整数范围是整个int类型范围（即-2147483648到2147483647）。

2.生成指定范围的随机整数：```javaRandom random = new Random();int min = 0;int max = 100;int randomNumberInRange = random.nextInt(max - min + 1) + min;```以上代码生成一个0到100之间（包括0和100）的随机整数。

3.生成随机浮点数：```javaRandom random = new Random();double randomDouble = random.nextDouble();```生成的随机浮点数范围是0.0（含）到1.0（不含）。

4.生成随机布尔值：```javaRandom random = new Random();boolean randomBoolean = random.nextBoolean();```生成true或false。

5.指定种子生成确定性随机数：```javalong seed = 123456; //种子可以是任意长整数Random random = new Random(seed);int randomNumber = random.nextInt();```使用相同的种子，每次运行程序都会得到相同的随机数。

6.生成随机字节数组：```javaRandom random = new Random();byte[] byteArray = new byte[10];random.nextBytes(byteArray);```生成一个长度为10的字节数组，并将其填充为随机值。

java中生成随机数的方法

Java中生成随机数的N种方法Java是一种广泛使用的编程语言，随机数是Java开发中常用的功能。

本文将介绍Java中生成随机数的N种方法，供开发者参考。

1. Math.random()方法Math.random()方法是Java中生成随机数最简单的方法，其返回值为一个double类型的数值，范围为0.0到1.0之间。

通过对其进行乘法、取整等操作可以得到任意区间内的随机数。

示例代码如下：double randomNum = Math.random(); // 生成0.0到1.0之间的随机数2. Random类Java中提供了Random类，可以更方便地生成随机数。

Random类中有多个方法可用于生成不同类型的随机数，如nextInt()、nextDouble()等。

示例代码如下：Random random = new Random();int randomInt = random.nextInt(100); // 生成0到99之间的随机整数double randomDouble = random.nextDouble(); // 生成0.0到1.0之间的随机小数3. ThreadLocalRandom类Java 7中新增的ThreadLocalRandom类可用于生成高效且线程安全的随机数。

其生成方式与Random类类似，但在多线程环境下更加可靠。

示例代码如下：ThreadLocalRandom random = ThreadLocalRandom.current();int randomInt = random.nextInt(100); // 生成0到99之间的随机整数4. SecureRandom类SecureRandom类提供更安全的随机数生成方式，可用于生成密码、密钥等敏感信息。

其生成方式基于环境（如CPU、内存）噪声，可有效地避免预测和攻击。

示例代码如下：SecureRandom random = new SecureRandom();byte[] randomBytes = new byte[16];random.nextBytes(randomBytes); // 生成16位字节数组的随机数总结以上是Java中生成随机数的N种方法，每种方法均可根据实际场景选择使用。

java时间戳随机数生成方法

java时间戳随机数生成方法在Java编程中，时间戳和随机数生成是常见的需求。

时间戳通常用于记录事件发生的时间，而随机数生成则用于生成随机的数值。

在本文中，我们将讨论如何使用Java来生成时间戳和随机数。

首先，让我们来看看如何生成时间戳。

在Java中，可以使用System.currentTimeMillis()方法来获取当前时间的时间戳。

这个方法返回的是从1970年1月1日00:00:00到当前时间的毫秒数。

下面是一个简单的示例：java.long timestamp = System.currentTimeMillis();System.out.println("当前时间戳，" + timestamp);接下来，让我们来看看如何生成随机数。

在Java中，可以使用java.util.Random类来生成随机数。

下面是一个简单的示例：java.Random random = new Random();int randomNumber = random.nextInt(100); // 生成一个0到99的随机整数。

System.out.println("随机数，" + randomNumber);除了使用java.util.Random类，还可以使用Math.random()方法来生成0到1之间的随机数。

下面是一个示例：java.double randomDouble = Math.random();System.out.println("随机数，" + randomDouble);当然，如果需要更复杂的随机数生成，可以使用java.security.SecureRandom类来生成安全的随机数。

综上所述，通过使用System.currentTimeMillis()方法和java.util.Random类，我们可以在Java中轻松地生成时间戳和随机数。

Java获取随机数的3种方法

Java获取随机数的3种⽅法⽅法1(数据类型)(最⼩值+Math.random()*(最⼤值-最⼩值+1))例:(int)(1+Math.random()*(10-1+1))从1到10的int型随数⽅法2获得随机数for (int i=0;i<30;i++){System.out.println((int)(1+Math.random()*10));}(int)(1+Math.random()*10)通过java.Math包的random⽅法得到1-10的int随机数公式是:最⼩值---最⼤值（整数）的随机数（类型）最⼩值+Math.random()*最⼤值⽅法3Random ra =new Random();for (int i=0;i<30;i++){System.out.println(ra.nextInt(10)+1);}通过java.util包中的Random类的nextInt⽅法来得到1-10的int随机数⽣成0到1之间的任意随机⼩数：⽣成[0,d)区间的随机⼩数，d为任意正的⼩数，则只需要将nextDouble⽅法的返回值乘以d即可。

[n1，n2]也就是 ra.nextDouble() * (n2-n1)+n1java产⽣随机数的⼏种⽅式⼀.在j2se⾥我们可以使⽤Math.random()⽅法来产⽣⼀个随机数，这个产⽣的随机数是0-1之间的⼀个double，我们可以把他乘以⼀定的数，⽐如说乘以100，他就是个100以内的随机，这个在j2me中没有。

⼆.在java.util这个包⾥⾯提供了⼀个Random的类，我们可以新建⼀个Random的对象来产⽣随机数，他可以产⽣随机整数、随机float、随机double，随机long，这个也是我们在j2me的程序⾥经常⽤的⼀个取随机数的⽅法。

三.在我们的System类中有⼀个currentTimeMillis()⽅法，这个⽅法返回⼀个从1970年1⽉1号0点0分0秒到⽬前的⼀个毫秒数，返回类型是long，我们可以拿他作为⼀个随机数，我们可以拿他对⼀些数取模，就可以把他限制在⼀个范围之内啦其实在Random的默认构造⽅法⾥也是使⽤上⾯第三种⽅法进⾏随机数的产⽣的对于⽅法⼆中的Random类有以下说明：java.util.Random类有两种⽅式构建⽅式：带种⼦和不带种⼦不带种⼦：此种⽅式将会返回随机的数字，每次运⾏结果不⼀样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());}}带种⼦：此种⽅式，⽆论程序运⾏多少次，返回结果都是⼀样的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());}}两种⽅式的差别在于(1) ⾸先请打开Java Doc，我们会看到Random类的说明：此类的实例⽤于⽣成伪随机数流，此类使⽤ 48 位的种⼦，该种⼦可以使⽤线性同余公式对其进⾏修改（请参阅 Donald Knuth 的《The Art of Computer Programming, Volume 2》，第 3.2.1 节）。

java生成随机数保留数点后两位

java⽣成随机数保留数点后两位
1.⽣成随机数的⽅法有Math.random和new Random.nextXXX();
double a=Math.random()*10;
double b=new Random().nextDouble()*10;
System.out.println(a+"------"+b);//输出结果：4.554615644299059------9.0498563174394
2.保留两位⼩数的⽅法有DecimalFormat或者String.format（）两种⽅法：
1.先实例化DecimalFormat在构造器中传⼊需要格式化的格式
0（代表⼀个数字，如果不存在显⽰0）
符号#（代表⼀个或多个数字，如果不存在则显⽰为空）
double a=Math.random()*10;
DecimalFormat df = new DecimalFormat( "0.00" );
String str=df.format( a )；
System.out.println(str);//输出结果：4.55
该⽅法会保留两位⼩数并且如果随机数中有0会⽤0来填充
注意：返回的是String类型的数据，如果⽤Double.parseDouble（）⽅法再将str转为double类型，如果⼩数最后⼀位为0会⾃动舍弃。

⽐如：str=6.30,Double.parseDouble（str）的值会变为6.3
楼主懒得打了。

2.使⽤String.format(String.format("%.2f", a) )，a是double类型的数据，也可以保留两位⼩数。

Java实现生成n个不重复的随机数

Java实现⽣成n个不重复的随机数本⽂实例为⼤家分享了Java实现⽣成n个不重复的随机数的具体代码，供⼤家参考，具体内容如下需求：根据min和max，⽣成n个不重复的随机数。

（注：范围[min,max]，n <= (max - min +1)）思路：0）、把从min到max的可能出现的数字全部放进⼀个候选List；1）、随机⽣成索引index（0 <= index <= (list.size()-1)）；2）、根据index从List中取出⼀个数,list.get(index)，并移除这个元素；代码如下：import java.util.ArrayList;import java.util.List;import java.util.Random;public class MyRandom {/*** 根据min和max随机⽣成⼀个范围在[min,max]的随机数，包括min和max* @param min* @param max* @return int*/public int getRandom(int min, int max){Random random = new Random();return random.nextInt( max - min + 1 ) + min;}/*** 根据min和max随机⽣成count个不重复的随机数组* @param min* @param max* @param count* @return int[]*/public int[] getRandoms(int min, int max, int count){int[] randoms = new int[count];List<Integer> listRandom = new ArrayList<Integer>();if( count > ( max - min + 1 )){return null;}// 将所有的可能出现的数字放进候选listfor(int i = min; i <= max; i++){listRandom.add(i);}// 从候选list中取出放⼊数组，已经被选中的就从这个list中移除for(int i = 0; i < count; i++){int index = getRandom(0, listRandom.size()-1);randoms[i] = listRandom.get(index);listRandom.remove(index);}return randoms;}}⼩编再为⼤家分享⼀段：java产⽣10个不同随机数的代码：package exercise03_jdknews;import java.util.Random;import java.util.Vector;/*** 获取10个1-20之间的随机数，要求不能重复** @author lgt**/public class RandomNumberNoRepeat {public static void main(String[] args) {//创建⼀个产⽣随机数的对象Random r = new Random();//创建⼀个存储随机数的集合Vector<Integer> v = new Vector<Integer>();//定义⼀个统计变量int count = 0;while(count < 10){int number = r.nextInt(20) + 1;//判断number是否在集合中存在if(!v.contains(number)){//不在集合中，就添加v.add(number);count++;}}//遍历输出for(int i : v){System.out.println(i);}}}以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。