java 生成一组不同的随机数(不重复)

文章标题：Java中随机生成三位整数的方法及其应用1. 前言作为一名开发者，我们经常需要在程序中生成随机的数字。

本文将主要介绍在Java中如何生成一个三位整数，并探讨其在实际应用中的意义和方法。

2. 随机生成三位整数的方法在Java中，我们可以借助Random类来生成随机数。

具体来说，我们可以使用nextInt()方法来获取一个范围内的随机整数。

以下是生成三位整数的具体方法：```javaimport java.util.Random;public class RandomNumberGenerator {public static void main(String[] args) {Random random = new Random();int min = 100;int max = 999;int randomNumber = random.nextInt(max - min + 1) + min;System.out.println("随机生成的三位整数为：" + randomNumber);}```通过上述方法，我们可以得到一个三位整数，并在控制台打印出来。

这样的方法可以被广泛应用在需要随机数的场景中，比如抽奖、密码生成等。

3. 随机生成三位整数的实际应用生成随机的三位整数在实际开发中有着广泛的应用。

在游戏开发中，我们经常需要随机生成怪物的属性或者道具的数量，这时候随机生成三位整数就可以满足我们的需求。

在网络安全领域，随机生成密码也是一项重要的任务。

我们可以结合随机生成三位整数的方法来生成密码的一部分，增加密码的复杂度。

4. 个人观点和理解作为一名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⽣成随机数⼯具类RandomStringUtils详解=================================================================public static String random(int count, boolean letters, boolean numbers)/*** count 创建⼀个随机字符串，其长度是指定的字符数,字符将从参数的字母数字字符集中选择，如参数所⽰。

* letters true,⽣成的字符串可以包括字母字符* numbers true,⽣成的字符串可以包含数字字符*/String random = RandomStringUtils.random(15, true, false);System.out.println(random);public static String random(int count) --- 中⽂下会是乱码，所有字符集/*** 创建⼀个随机字符串，其长度是指定的字符数。

* 将从所有字符集中选择字符*/random = RandomStringUtils.random(22);System.out.println(random);public static String random(int count, String chars)/*** 创建⼀个随机字符串，其长度是指定的字符数。

* 字符将从字符串指定的字符集中选择，不能为空。

如果NULL，则使⽤所有字符集。

*/random = RandomStringUtils.random(15, "abcdefgABCDEFG123456789");System.out.println(random);这⾥写代码⽚public static String random(int count, int start,int end,boolean letters, boolean numbers)/*** 创建⼀个随机字符串，其长度是指定的字符数,字符将从参数的字母数字字符集中选择，如参数所⽰。

一、介绍在进行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中，我们可以使用几种方法来生成随机数。

下面介绍了三种常用的方法：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生成随机不重复字符串的方法Randomly generating non-repeating strings in Java can be achieved using various methods. One common approach is to use the`Random` class in Java to generate a random index within the range of the string length, and then use this index to extract characters from the string. Another approach is to use the `()` method to randomize the order of characters in the string. Both methods have their own advantages and can be implemented based on specific requirements.在Java中可以通过多种方法实现生成不重复的随机字符串。

一个常见的方法是使用Java中的`Random`类来生成在字符串长度范围内的随机索引，然后使用该索引从字符串中提取字符。

另一种方法是使用`()`方法来随机排列字符串中字符的顺序。

这两种方法各有优势，可以根据具体需求进行实现。

When using the `Random` class, the `nextInt()` method can generate a random integer within a specified range, such as the length of the string. By repeatedly generating random indices and checking for duplicates, a non-repeating random string can be constructed. Thisapproach is suitable for cases where the characters in the string need to be used in a specific order, but without repetition.当使用`Random`类时，`nextInt()`方法可以生成指定范围内的随机整数，比如字符串的长度。

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 自带的 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 中生成随机数的两种常用方法。

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

一、利用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)。

其中(int)(Math.Random()*99)产生0到99的整数型随机数。

JAVA随机数之多种方法从给定范围内随机N个不重复数在Java中，我们可以使用多种方法从给定范围内随机生成N个不重复的数。

下面将详细介绍三种常用的方法：使用集合、Fisher-Yates洗牌算法和递归。

1.使用集合：使用集合可以保证生成的数不重复。

我们可以使用Java中的HashSet类来完成这个任务。

算法如下：（1）创建一个HashSet对象来存储生成的数。

（2）生成一个随机数，并检查是否在HashSet中已经存在。

（3）如果不存在，将随机数添加到HashSet中，并继续生成下一个随机数，直到HashSet中的元素个数达到N。

（4）返回HashSet中的元素作为结果。

代码示例：```javaimport java.util.HashSet;import java.util.Random;public class RandomNumberGeneratorpublic static HashSet<Integer> generateRandomNumbers(int min, int max, int count)HashSet<Integer> numbers = new HashSet<>(;Random random = new Random(;while (numbers.size( < count)int randomNumber = random.nextInt(max - min + 1) + min;numbers.add(randomNumber);}return numbers;}public static void main(String[] args)HashSet<Integer> randomNumbers = generateRandomNumbers(1, 10, 5);System.out.println(randomNumbers);}}```该代码可以生成1到10之间的5个不重复的随机数。

java中随机数random的用法Java中随机数（Random）是一个非常有用的工具，它可以用来生成随机数，从而实现一些随机化的操作。

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

下面是一些关于Java中随机数的用法。

1. 生成随机整数我们可以使用nextInt()方法来生成随机整数。

例如，下面的代码将生成一个0到99之间的随机整数：```Random random = new Random();int num = random.nextInt(100);```2. 生成随机浮点数我们可以使用nextDouble()方法来生成随机浮点数。

例如，下面的代码将生成一个0到1之间的随机浮点数：Random random = new Random();double num = random.nextDouble();```如果我们想要生成一个指定范围内的随机浮点数，可以使用下面的代码：```Random random = new Random();double num = min + (max - min) * random.nextDouble();```其中，min和max分别是指定范围的最小值和最大值。

3. 生成随机布尔值我们可以使用nextBoolean()方法来生成随机布尔值。

例如，下面的代码将生成一个随机布尔值：```Random random = new Random();boolean bool = random.nextBoolean();4. 生成随机字节数组我们可以使用nextBytes()方法来生成随机字节数组。

例如，下面的代码将生成一个长度为10的随机字节数组：```Random random = new Random();byte[] bytes = new byte[10];random.nextBytes(bytes);```5. 设置随机数种子我们可以使用setSeed()方法来设置随机数种子。

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种方法，每种方法均可根据实际场景选择使用。

⽣成不重复的随机数的三种⽅法下⾯我以⽣成1-10之间的10个不重复的随机数为例介绍⽣成不重复的随机数的三种⽅法:1,通过while循环来实现通过while循环不停的⽣成随机数，直到⽣成⼀个不重复的为⽌，这种⽅法⽐较容易想到，但是效率也⽐较低下，实例代码如下：static void Main(string[] args){int[] result = new int[10];int tmp = -1;Random random = new Random();bool repeat = false;for (int i = 0; i < 10; i++){repeat = true;while (repeat){repeat = false;tmp = random.Next(1, 11);for (int j = 0; j < i; j++){if (tmp == result[j]){repeat = true;break;}}}result[i] = tmp;}for (int i = 0; i < 10; i++)Console.WriteLine(result[i].ToString());}2，通过for循环来实现⽅法1使⽤了多处循环嵌套，效率⼗分低下，所以我应⽤⼀定的技巧来减少循环嵌套，来达到提⾼程序效率的⽬的。

主要思路是如果检测到重复，就把循环变量减1，这样来重新进⾏⼀次循环，重新⽣成⼀个随机数，直到⽣成⼀个不重复的随机数为⽌，实例代码如下：static void Main(string[] args){int[] result = new int[10];int tmp = -1;Random random = new Random();bool repeat = false;for (int i = 0; i < 10; i++){repeat = false;tmp = random.Next(1, 11);for (int j = 0; j < i; j++){if (tmp == result[j]){repeat = true;break;}}if (!repeat){result[i] = tmp;}else{i = i - 1;//循环变量-1}}for (int i = 0; i < 10; i++)Console.WriteLine(result[i].ToString());}这个⽅法减少了⼀层循环嵌套，效率上有⼀定的改善！3，通过随机排序来实现这种⽅法彻底的颠覆了⽅法1和2的基本思路，先初始化⼀个包含数字1-10的数组，然后每次循环取⼀个随机位置，将这个位置的元素和最后⼀个位置的元素交换！实例代码如下：static void Main(string[] args){int[] result = new int[10];for (int i = 0; i < 10; i++)result[i] = i + 1;for (int j = 9; j > 0; j--){Random r = new Random();int index = r.Next(0, j);int temp = result[index];result[index] = result[j];result[j] = temp;}for (int i = 0; i < 10; i++)Console.WriteLine(result[i].ToString());}这种⽅法消除了循环嵌套，效率上获得了进⼀步的改善，但是也有⼀定的限制，如果要⽣成5个1-10之间的随机数，那这种打乱顺序的⽅法就⽆法使⽤了！总结：⽅法1效率⽐较低下，⼀般不推荐使⽤！⽅法2⽐较通⽤，效率⾼于⽅法1，但是效率低于⽅法3⽅法3虽然效率⽐较⾼，但是只能应⽤与特定的情况下！请⼤家多多指教啊！。

java的random函数用法Java中的Random类是一个伪随机数生成器，它可以用来生成各种类型的随机数。

Random类的用法非常简单，以下是一些常见用法的说明：1. 创建Random对象：要使用Random类中的方法，首先需要创建一个Random对象。

可以使用无参构造方法创建一个新的Random对象，也可以使用指定种子的构造方法创建对象。

例如，使用无参构造方法创建对象：Random rand = new Random(;。

2. 生成随机整数：Random类中的ne某tInt(方法可以用来生成一个指定范围内的随机整数。

例如，生成一个0到10之间的随机整数：int randomNumber = rand.ne某tInt(10);。

3. 生成随机浮点数：使用Random类中的ne某tDouble(方法可以生成一个0到1之间的随机浮点数。

例如，生成一个0到1之间的随机浮点数：double randomFloat = rand.ne某tDouble(;。

4. 生成随机字符：使用Random类中的ne某tInt(方法可以生成一个ASCII码范围内的随机整数，然后将其强制转换为字符类型。

例如，生成一个随机的大写字母：char randomChar = (char)(rand.ne某tInt(26) + 'A');。

5. 生成随机布尔值：可以使用Random类中的ne某tBoolean(方法生成一个随机的布尔值，该方法返回一个true或false。

例如，生成一个随机的布尔值：boolean randomBoolean = rand.ne某tBoolean(;。

6. 生成随机数组：使用Random类可以生成随机数组，例如随机排序一个数组，可以通过生成随机索引调换数组中的元素位置来实现。

例如，随机打乱一个数组：int[] array = {1, 2, 3, 4, 5};。

for(int i=0; i<array.length; i++)int randomInde某 = rand.ne某tInt(array.length);int temp = array[i];array[i] = array[randomInde某];array[randomInde某] = temp;}7. 生成指定范围内的随机数：使用Random类中的ne某tInt(方法可以生成指定范围内的随机数。

java生成不重复的10位数字方法下载提示：该文档是本店铺精心编制而成的，希望大家下载后，能够帮助大家解决实际问题。

文档下载后可定制修改，请根据实际需要进行调整和使用，谢谢！本店铺为大家提供各种类型的实用资料，如教育随笔、日记赏析、句子摘抄、古诗大全、经典美文、话题作文、工作总结、词语解析、文案摘录、其他资料等等，想了解不同资料格式和写法，敬请关注！Download tips: This document is carefully compiled by this editor. I hope that after you download it, it can help you solve practical problems. The document can be customized and modified after downloading, please adjust and use it according to actual needs, thank you! In addition, this shop provides you with various types of practical materials, such as educational essays, diary appreciation, sentence excerpts, ancient poems, classic articles, topic composition, work summary, word parsing, copy excerpts, other materials and so on, want to know different data formats and writing methods, please pay attention!Java生成不重复的10位数字方法在Java编程中，有时我们需要生成一串不重复的10位数字，可以用于生成唯一的标识符或者其他需求。

java生成数字不重复的方法有多种方法可以生成不重复的数字，下面列举几种常见的方法：1. 使用Set集合：将生成的数字添加到Set集合中，Set集合会自动去重。

继续生成数字直到Set集合中的数字个数达到要求。

```javaSet<Integer> set = new HashSet<>(;Random rand = new Random(;while (set.size( < numCount)int num = rand.nextInt(maxNum - minNum + 1) + minNum;set.add(num);int[] nums = new int[numCount];int index = 0;for (int num : set)nums[index++] = num;```2. 使用洗牌算法（Fisher–Yates算法）：生成一个包含所有可能数字的数组，然后对数组进行洗牌，截取前n个数字作为结果。

```javaint[] nums = new int[maxNum - minNum + 1];for (int i = minNum; i <= maxNum; i++)nums[i - minNum] = i;Random rand = new Random(;for (int i = nums.length - 1; i >= 1; i--)int j = rand.nextInt(i + 1);int temp = nums[i];nums[i] = nums[j];nums[j] = temp;int[] result = Arrays.copyOf(nums, numCount);```3.使用递增的方式生成不重复的数字：初始数字为最小值，每次递增一个步长，直到生成足够的数字。

```javaint[] nums = new int[numCount];int num = minNum;for (int i = 0; i < numCount; i++)nums[i] = num;num += step;if (nums[numCount - 1] > maxNum)//数字超过了范围，需要适当调整int diff = nums[numCount - 1] - maxNum; for (int i = 0; i < numCount; i++) nums[i] -= diff;}。

Java编程实现⽣成给定范围内不重复随机数的⽅法⼩结本⽂实例总结了Java编程实现⽣成给定范围内不重复随机数的⽅法。

分享给⼤家供⼤家参考，具体如下：在Java中的Math类中存在⼀个random()⽅法，该⽅法默认⽣成0.0到1.0之间的double型随机数；经过稍微处理，就可以产⽣我们需要的随机数以及随机字符。

除了Math类中的random()⽅法之外，java.util.Random类也可以⽤来⽣成随机数；下⾯分别举例（⽤不同的⽅法⽣成双⾊球号码）说明：1. Math.random()⽅法⽣成随机数：package test;import java.util.SortedSet;import java.util.TreeSet;public class MathRandom {static SortedSet set = new TreeSet();public static int randomSet(double m, double n) {int num = (int) m + (int) (Math.random() * (n - m));return num;}public static void shuangSe(int num1, int num2) {for (int i = 0; i < num1; i++) {set.add(randomSet(1, 33));}if (set.size() < num2) {shuangSe(num2 - set.size(), num2);}}public static void main(String[] args) {shuangSe(6, 6);System.out.print(set);System.out.println(" "+randomSet(1,16));}}运⾏结果（随机）：[3, 13, 17, 21, 23, 25] 2⽣成随机字符：package test;public class MathRandomChar {public static char getRandomChar(char c1,char c2){return (char)(c1+Math.random()*(c2-c1+1));}public static void main(String[] args) {System.out.println("a-z之间的任意字符: "+getRandomChar('a','z'));}}运⾏结果（随机）：a-z之间的任意字符: g2. java.util.Random⽅法⽅法⼀：for循环加递归：package test;import java.util.Random;import java.util.SortedSet;import java.util.TreeSet;public class Test {static Random ran = new Random();static SortedSet set = new TreeSet();public static void randomSet(int n, int m) {for (int i = 0; i < n; i++) {set.add(ran.nextInt(33) + 1);}if (set.size() < m) {randomSet(m - set.size(), m);}}public static void main(String[] args) {randomSet(6, 6);System.out.print(set);System.out.println(" "+(ran.nextInt(16)+1));}}运⾏结果（随机）：[1, 15, 18, 29, 30, 31] 13⽅法⼆：while循环package test;import java.util.Random;import java.util.Set;import java.util.TreeSet;public class ShuangSeQiu {public static void main(String[] args) {Random ran = new Random();Set<Integer> set = new TreeSet<>();while (true) {int a = ran.nextInt(33) + 1;set.add(a);if (set.size() > 5) {System.out.print(set);break;}}System.out.println(" "+(ran.nextInt(16)+1));}}运⾏结果（随机）：[2, 11, 12, 16, 23, 26] 7PS：这⾥再为⼤家提供两款功能类似的在线⼯具供⼤家参考：更多关于java算法相关内容感兴趣的读者可查看本站专题：《》、《》、《》、《》和《》希望本⽂所述对⼤家java程序设计有所帮助。

JAVA⽣成⽆重复8位随机码（转）短8位UUID思想其实借鉴微博短域名的⽣成⽅式，但是其重复概率过⾼，⽽且每次⽣成4个，需要随即选取⼀个。

本算法利⽤62个可打印字符，通过随机⽣成32位UUID，由于UUID都为⼗六进制，所以将UUID分成8组，每4个为⼀组，然后通过模62操作，结果作为索引取出字符，这样重复率⼤⼤降低。

经测试，在⽣成⼀千万个数据也没有出现重复，完全满⾜⼤部分需求。

代码贴出来供⼤家参考。

public static String[] chars = new String[] { "a", "b", "c", "d", "e", "f","g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s","t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5","6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H", "I","J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V","W", "X", "Y", "Z" };public static String generateShortUuid() {StringBuffer shortBuffer = new StringBuffer();String uuid = UUID.randomUUID().toString().replace("-", "");for (int i = 0; i < 8; i++) {String str = uuid.substring(i * 4, i * 4 + 4);int x = Integer.parseInt(str, 16);shortBuffer.append(chars[x % 0x3E]);}return shortBuffer.toString();}。