java产生不重复随机数改进算法

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

本文由我司收集整编，推荐下载，如有疑问，请与我司联系java 生成一组不同的随机数（不重复）2017/03/22 0 import java.util.Random;/*** 生成一组不同的随机数* arr{1,2,3,4,5,6}* 比如随机生成了3 取出arr[3]=3,然后将arr{1,2,6,4,5,3} 数组模拟长度减1* 比如随机生成了3 取出arr[3]=6,然后将arr{1,2,5,4,6,3} 数组模拟长度减1*@author pindu*/public class RamdomNums {public static void main(String[] args) {int num = 4;int min = 1;int max = 10;nums(num, min, max);System.out.println( ------------- for (int i = 0; i num; i ) {System.out.println(Math.random()*(max - min 1));}}public static void nums(int num,int min,int max) {//如果生成树目超出范围直接返回int len = max - min if (num len) {return ;}//生成有序数组int[] arr = new int[len];for (int i = 0; i len; i ) {arr[i] = i min;}//生成随机数int t = 0;while (num 0) {t = (int) (Math.random()*(max - min 1))%len;System.out.println(arr[t]);arr[t] = arr[--len];num--;}}}结果7192-------------6.8698486251811616.2799489504900352.9301117297642018.195864045774911 tips:感谢大家的阅读，本文由我司收集整编。

JAVA16位ID生成工具类含16位不重复的随机数数字+大小写

JAVA16位ID⽣成⼯具类含16位不重复的随机数数字+⼤⼩写本⽂介绍了Java随机数，分享给⼤家，也顺便做个笔记package com.fty.util;import java.security.SecureRandom;import java.util.Random;import java.util.concurrent.ThreadLocalRandom;public class UtilId {/*** ⽣成16位不重复的随机数，含数字+⼤⼩写* @return*/public static String getGUID() {StringBuilder uid = new StringBuilder();//产⽣16位的强随机数Random rd = new SecureRandom();for (int i = 0; i < 16; i++) {//产⽣0-2的3位随机数int type = rd.nextInt(3);switch (type){case 0://0-9的随机数uid.append(rd.nextInt(10));/*int random = ThreadLocalRandom.current().ints(0, 10).distinct().limit(1).findFirst().getAsInt();*/break;case 1://ASCII在65-90之间为⼤写,获取⼤写随机uid.append((char)(rd.nextInt(25)+65));break;case 2://ASCII在97-122之间为⼩写，获取⼩写随机uid.append((char)(rd.nextInt(25)+97));break;default:break;}}return uid.toString();}}以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。

JAVA生成无重复8位随机码（转）

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();}。

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);}}}以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。

java-生成不重复的随机数

java-⽣成不重复的随机数⽅法⼀，* 本⽅法的思路是：* 1、创建⼀个5个元素的数组, ⽤来存放随机数* 2、逐个取随机数，并且第⼀个随机数直接放在a[0]* 3、第⼆个随机数开始，需要与数组中已经存在的元素进⾏逐个⽐较，直到取出不重复的随机数，否则⼀致重复取随机数⽅法⼆：需要结合list集合进⾏处理，后续学习集合时在进⾏处理package number;import java.util.Random;public class RandomTest01{//在[0~100] ，取5个不重复的随机数/*** 本⽅法的思路是：* 1、创建⼀个5个元素的数组, ⽤来存放随机数* 2、逐个取随机数，并且第⼀个随机数直接放在a[0]* 3、第⼆个随机数开始，需要与数组中已经存在的元素进⾏逐个⽐较，直到取出不重复的随机数，否则⼀致重复取随机数 ** @param args*/public static void main(String[] args) {Random r1 = new Random();int b = r1.nextInt(101);//创建⼀个包含5个元素的数组, 存放随机数int[] a = new int[5];//第⼀个随机数,不需要判断是否重复,直接放进数组a[0] = b;//外层,⽤来放剩余的四个元素,下标从1开始for( int i =1; i<a.length; i++){b = r1.nextInt(101);//将取到的随机数,与已经存在的元素进⾏⽐较，从下标=0开始⽐较for(int num = 0; num<i ; num++){//如果和已经存在元素相同,需要重新取随机数,并且新取到的随机数要重新与a[0]开始⽐较,知道取到的随机数不重复while(b==a[num]){b= r1.nextInt(101);num =0;}}a[i]= b;}//遍历数组,进⾏展⽰showArray(a);}//遍历数组的⽅法public static void showArray(int[] a) {for(int i =0; i<a.length; i++) {System.out.println(a[i]);}}}。

JAVA随机数之多种方法从给定范围内随机N个不重复数

JAVA随机数之多种方法从给定范围内随机N个不重复数在Java中生成随机数有多种方法，例如使用Math类的random(方法，使用Random类，以及使用ThreadLocalRandom类。

下面将介绍不同方法从给定范围内随机生成N个不重复数的实现。

方法一：使用Math类的random(方法Math类的random(方法返回一个浮点数，在范围[0.0, 1.0)之间。

我们可以通过将其乘以范围的长度，并强制转换为整数来获得在给定范围内的随机整数。

```javaint min = 1; // 最小值int max = 100; // 最大值int N = 10; // 需要生成的随机数个数Set<Integer> set = new HashSet<>(;while(set.size( < N)int randomNum = min + (int)(Math.random( * (max - min));set.add(randomNum);for (int num : set)System.out.println(num);```方法二：使用Random类Random类是Java提供的一个伪随机数生成器。

我们可以使用nextInt(方法从给定范围内生成一个随机整数。

```javaint min = 1;int max = 100;int N = 10;Random rand = new Random(;Set<Integer> set = new HashSet<>(;while(set.size( < N)int randomNum = rand.nextInt(max - min + 1) + min;set.add(randomNum);for (int num : set)System.out.println(num);```方法三：使用ThreadLocalRandom类ThreadLocalRandom类是Java 7中引入的一个新类，它提供了线程本地的随机数生成器。

java生成数字不重复的方法

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编程中，经常需要生成随机数字。

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

本文将介绍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编写一个不重复的随机数算法。

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

但是由于Random类生成的随机数是伪随机数，在一些特定情况下可能会出现重复的情况。

为了避免这种情况，我们可以采用一种不重复的随机数算法。

一种常见的不重复随机数算法是洗牌算法。

洗牌算法的基本思想是将一个有序的序列打乱，使得每个元素出现在任意的位置上，从而实现不重复的随机数生成。

具体实现该算法的步骤如下：1. 创建一个数组，用于存储要生成随机数的范围。

如要生成1到100之间的不重复随机数，可以创建一个包含1到100的数组。

2. 初始化一个指针，指向数组的最后一个元素。

3. 从数组中随机选择一个元素，并将其与指针指向的元素进行交换。

4. 指针向前移动一位。

5. 重复步骤3和步骤4，直到指针指向数组的第一个元素。

6. 遍历数组，取出前n个元素作为生成的随机数。

n为需要生成的随机数个数。

通过上述步骤，我们可以得到一个不重复的随机数序列。

下面是一个简单的Java代码示例，演示了如何实现不重复随机数算法：```javaimport java.util.Random;public class UniqueRandomNumberGenerator {public static void main(String[] args) {int range = 100; // 随机数范围int count = 10; // 需要生成的随机数个数int[] numbers = new int[range];for (int i = 0; i < range; i++) {numbers[i] = i + 1;}Random random = new Random();for (int i = range - 1; i > 0; i--) {int j = random.nextInt(i + 1);int temp = numbers[i];numbers[i] = numbers[j];numbers[j] = temp;}for (int i = 0; i < count; i++) {System.out.println(numbers[i]);}}}```上述代码中，我们首先创建了一个范围为1到100的数组，并初始化一个指针指向数组的最后一个元素。

java时间戳随机数生成方法

java时间戳随机数生成方法在Java中，我们经常需要生成随机数来用于各种用途，比如生成随机的验证码、密码，或者用于模拟数据等。

而结合时间戳和随机数生成方法可以使得生成的随机数更加随机，避免重复和预测性。

首先，让我们来看看如何使用时间戳来生成随机数。

在Java中，我们可以使用`System.currentTimeMillis()`方法来获取当前的时间戳，它返回的是从1970年1月1日00:00:00到当前时间的毫秒数。

我们可以利用这个时间戳来作为随机数生成的种子，从而生成更加随机的随机数。

java.long seed = System.currentTimeMillis();Random random = new Random(seed);int randomNumber = random.nextInt();System.out.println("随机数为，" + randomNumber);在上面的代码中，我们首先获取当前的时间戳作为种子，然后使用`Random`类来生成随机数。

这样生成的随机数会更加随机，因为种子是基于当前时间的，每次生成的随机数都会不同。

另外，我们还可以结合时间戳和其他的随机数生成方法来生成更加复杂的随机数。

比如，我们可以将时间戳作为种子传递给`SecureRandom`类，这样生成的随机数会更加安全，因为`SecureRandom`是专门用于安全目的的随机数生成器。

java.long seed = System.currentTimeMillis();SecureRandom secureRandom = new SecureRandom();secureRandom.setSeed(seed);byte[] randomBytes = new byte[16];secureRandom.nextBytes(randomBytes);System.out.println("随机字节数组为，" +Arrays.toString(randomBytes));在这个例子中，我们使用`SecureRandom`类生成了一个16字节的随机字节数组，将时间戳作为种子传递给`SecureRandom`，这样生成的随机数会更加安全和随机。

考试随机生成座位表

考试随机生成座位表记得期末考试田小远写了一个随机生成代码座位的小代码（JAVA），并且在全院每场考试中使用,给田小远点赞。

当时我就在想可不可以用C试试，一直没有付诸行动，，就写一篇关于这的用C试试。

两种不同的思路如下。

java我就是个渣渣...........问题转化：班级人数以60为例，座位表—即产生60个不重复的随机数。

（方案1：直接生成随即数且不重复（去重）。

方案2：数按顺序生成，随机对两个数进行交换位置（次数尽可能多））方案一：随机生成1到100的数，逐个保存到长度为60的数组中，每次保存时遍历前面已经保存的数，如果出现重复，则舍弃这个随机数，重新生成，再遍历。

直至把数组填满。

#include<stdio.h>#include<time.h>#include<stdlib.h>//终于意识到这种定义的方便性#define M 60 // 班级总人数#define line 6 //每一排坐几个人//随机数生成函数int randomNumber(){return rand()%M+1;}int main(){srand((unsigned)time(NULL));//生成随机数的种子int a[M]={NULL};//初始化数组int n=0;while(n<M){int m=randomNumber();bool flag=0;for(int j=0;j<n+1;j++){if(a[j]==m){flag=1;//如果之前保存的数中出现了和m相同的数，就把flag标记为1并跳出循环，表示需要重新生成随机数mbreak;}}if(flag==0){a[n]=m;//如果flag是0，表示前n个数中没有和m相同的数，因此可以把第n+1个元素赋值为mn++;}}for(int k=0;k<M;k++){//输出数组printf("%5d ",a[k]);if((k+1)%5==0){printf("\n");}}printf("\n对数组进行排序，检验数组是否正确!\n\n");for(int i=0;i<M;i++){//下面双重循环是一个快速实现的排序代码，用来检验之前生成的数组是否符合要求for(int j=0;j<M;j++){if(a[i]<a[j]){int temp;temp=a[i];a[i]=a[j];a[j]=temp;}}}for(int k=0;k<M;k++){//输出数组printf("%5d ",a[k]);if((k+1)%5==0){printf("\n");}}return 0;}方案2：问题等价于随机排列1到100，可以先把1到100用循环语句写进数组；然后进入一个很大的循环（循环次数越多越好），每次循环随机生成两个0到99的数，将这两个数为下标的元素对调，最后得到的就是随机排列的1到100了。

Java编程实现生成给定范围内不重复随机数的方法小结

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随机数生成算法

Java随机数生成算法随机数在计算机领域中扮演着非常重要的角色，它们被广泛应用于密码学、模拟实验、游戏开发和随机算法等领域。

Java作为一种广泛使用的编程语言，提供了多种方法来生成随机数。

本文将深入探讨Java中随机数生成算法的原理、使用方法和最佳实践。

随机数的定义随机数是指按照某种规律在一定范围内生成的数序列，它们之间不存在明显的联系或规律。

随机数要具备以下特点：1.均匀性（Uniformity）：在理想情况下，随机数生成器应该能够生成均匀分布的随机数，即在给定的范围内，每个数字都有相同的概率被选中。

2.独立性（Independence）：生成的随机数应该相互独立，即前一个生成的随机数不应该影响后一个的生成。

3.复现性（Reproducibility）：为了调试和验证，随机数生成器应该具备可复现性，即相同的种子（seed）生成的随机数序列应该完全一致。

Java中的随机数生成器Java提供了两种不同的随机数生成器：java.util.Random类和java.security.SecureRandom类。

其中，java.util.Random类提供了伪随机数生成器，而java.security.SecureRandom类提供了加密级别的安全随机数生成器。

伪随机数生成器（Pseudo-random Number Generator，PRNG）java.util.Random类基于线性同余算法（Linear Congruential Generator，LCG）实现了随机数生成器。

它的生成规则可以表示为：Xn+1 = (a * Xn + c) mod m其中，Xn+1是下一个生成的随机数，Xn是当前的随机数，a、c、m是固定的常数。

通过不断迭代，可以生成一个伪随机数序列。

使用java.util.Random生成随机数的基本步骤如下：1.创建一个Random对象。

2.可选：设置随机数种子。

如果不设置种子，则使用系统时间作为默认种子。

Java数组实现随机生成N-M之间不重复的随机数

6
System.out.print(arr[i] + "、");
7
}
8
System.out.println(arr[i]);
9}
运行效果如下：
Java数组实现随机生成 N-M之间不重复的随机数
接收一个整形数组，使用Math.Random每次在规定的数字范围内随机产生数字，然后嵌套for循环依次判断是否有重复值，如果有既外循环变量减一，直到把数组装满为止。
1 /**
2 * 随机生成 N--M的不重复随机数
3*
4 * @param arr
接收一个数组
}
17
}
18 }
主方法中可定义一个整形数组，然后调用此方法吧数组名传来即可
1 public static void main(String[] args) {
2
int[] arr = new int[10];
3
Test03.getRandom(arr, 1, 10);
4
int i;
5
for (i = 0; i < arr.length - 1; i++) {
10
arr[i] = (int) (Math.random() * (endRange - startRange + 1) + startRange);
11
for (int j = 0; j < i; j++) {
12
if (arr[i] == arr[j]) {
13
i--;Βιβλιοθήκη 14break;15
}
16
5 * @param startRange 起始数字

Java生成不重复的随机数

do { randint = rand.nextInt(number) + 1; 生成给定的随机数
} while (bool[randint]); #是否已经生成数字， bool[randint] 默认是false，如果状态已经设置为了true，不进入状态，有执行do bool[randint] = true; //状态设置为true nu[i] = randint; } return nu;
9亿少年de梦你好jpushprotocolpb2是通过jpushprotocolproto文件使用工具生成的可能我转换时截图是其他的一个proto文件会让人不理解我已经更换jp
Java生成不重复的随机数
public class test {
public static int[] Rad = new Random(); //创建一个新随机数生成器 int nu[] = new int[7]; //创建一个7位的数组,主要是保存结果，我需要7个不重复的随机值 boolean[] bool = new boolean[number + 1]; #+1是因为在下面随机数中我为了避开传入的数，不从0开始，所以+1，如果现在这里不加1，会提示越界 int randint = 0; for (int i = 0; i < 7; i++) {
}
public static void main(String[] args) { int str[] = Randoms(11); for (int i : str) { System.out.println(i); }
} }

java随机抽取指定范围不重复的数字

java随机抽取指定范围不重复的数字本⽂给⼤家介绍如何在JAVA中实现随机⽆重复数字的功能。

如果您是初学者的话，有必要看⼀看这篇⽂章，因为这个功能⼀般会在⾯试中遇到。

包括我本⼈在招聘⼈员的时候也喜欢拿这个问题去问别⼈，主要看⼀看考虑问题的模式和基础知识如何。

希望这篇⽂章能给初次接触的朋友⼀些帮助，因为我曾接触过⼀些朋友要么写不出来，要么使⽤很平铺的思维⽅式去实现它。

⼀般有点开发经验的朋友都能实现这样的功能，只不过是效率上的问题。

我们⼀般在⾯对这样的问题时，总会平铺直序的联想到，先⽣成⼀个数组，然后在⼀个循环中向数组中添加随机数字，在添加数字的过程中先查找⼀下数组中是否存在这个数字，如果不存在这个数字就直接添加到数组中；如果存在这个数字就不添加。

我们⼀般都是这样考虑问题的，这样考虑也能实现功能，我刚才也说了，只不过是效率上的问题。

为了更好地理解这个题意，我们先来看下具体内容：⽣成⼀个1-100的随机数组，但数组中的数字不能重复，即位置是随机的，但数组元素不能重复。

在这⾥呢，没有给我们规定数组的长度，我们可以让它是1-100之间的任意长度。

接下来让我们看⼀下⼏种实现⽅法并对这⼏种⽅法作个对⽐。

通常我们会使⽤ArrayList或数组来实现，先来看下ArrayList实现过程，如下⾯代码所⽰：import java.util.ArrayList;import java.util.Random;/*** 使⽤ArrayList实现* @Description:* @File: Demo.java* @Package None* @Author Hanyonglu* @Date 2012-10-18 下午06:16:55* @Version V1.0*/public class Demo {public static void main(String[] args) {Object[] values = new Object[20];Random random = new Random();ArrayList<Integer> list = new ArrayList<Integer>();for(int i = 0; i < values.length;i++){int number = random.nextInt(100) + 1;if(!list.contains(number)){list.add(number);}}values = list.toArray();// 遍历数组并打印数据for(int i = 0;i < values.length;i++){System.out.print(values[i] + "\t");if(( i + 1 ) % 10 == 0){System.out.println("\n");}}}}使⽤数组实现的过程如下所⽰代码：import java.util.Random;/*** 使⽤数组实现* @Description:* @File: Demo4.java* @Package None* @Author Hanyonglu* @Date 2012-10-18 下午06:27:38* @Version V1.0*/public class Demo4 {public static void main(String[] args) {int[] values = new int[20];Random random = new Random();for(int i = 0;i < values.length;i++){int number = random.nextInt(100) + 1;for(int j = 0;j <= i;j++){if(number != values[j]){values[i]=number;}}}// 遍历数组并打印数据for(int i = 0;i < values.length;i++){System.out.print(values[i] + "\t");if(( i + 1 ) % 10 == 0){System.out.println("\n");}}}}上⾯这两个实现过程效率⽐较低的。

Java生成随机数

Java⽣成随机数Java中常⽤的两种产⽣随机数的⽅法⼀、ng.Math类中的random()⽅法;调⽤这个Math.random()函数能够返回带正号的double值，该值⼤于等于0.0且⼩于1.0，即取值范围是[0.0,1.0)的左闭右开区间，返回值是⼀个伪随机选择的数，在该范围内（近似）均匀分布。

第⼀次调⽤该⽅法时，它将创建⼀个新的伪随机数⽣成器，与以下表达式完全相同new java.util.Random之后，新的伪随机数⽣成器可⽤于此⽅法的所有调⽤，但不能⽤于其他地⽅。

此⽅法是完全同步的，可允许多个线程使⽤⽽不出现错误。

但是，如果许多线程需要以极⾼的速率⽣成伪随机数，那么这可能会减少每个线程对拥有⾃⼰伪随机数⽣成器的争⽤。

⼆、java.util.Random类;1、java.util.Random类中实现的随机算法是伪随机，也就是有规则的随机，所谓有规则的就是在给定种(seed)的区间内随机⽣成数字；2、相同种⼦数的Random对象，相同次数⽣成的随机数字是完全相同的；3、Random类中各⽅法⽣成的随机数字都是均匀分布的，也就是说区间内部的数字⽣成的⼏率均等；下⾯Random()的两种构造⽅法1.Random()：创建⼀个新的随机数⽣成器。

2.Random(long seed)：使⽤单个 long 种⼦创建⼀个新的随机数⽣成器。

//获取当前时间的毫秒数作为随机数种⼦long t = System.currentTimeMillis();1.protected int next(int bits)：//⽣成下⼀个伪随机数。

2.boolean nextBoolean()：//返回下⼀个伪随机数，它是取⾃此随机数⽣成器序列的均匀分布的boolean值。

3.void nextBytes(byte[] bytes)：//⽣成随机字节并将其置于⽤户提供的 byte 数组中。

4.double nextDouble()：//返回下⼀个伪随机数，它是取⾃此随机数⽣成器序列的、在0.0和1.0之间均匀分布的 double值。

Java随机生成前N个不重复的整数

Java随机生成前N个不重复的整数import java.io.BufferedOutputStream;import java.io.File;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.IOException;import java.io.OutputStream;import java.util.Random;/**•测试随机生成前N个不重复的整数•@author Administrator•*/•public class TestRandom {• public static void main(String[] args) {•••randomNumber2File("e:/random.txt");}/**o根据提供的路径生成相应的随机数o@param patho*/o public static void randomNumber2File(String path){o File file = new File(path);o OutputStream os = null;o try {ooo os = new BufferedOutputStream(newFileOutputStream(file));o byte[] buf = new byte[20];o for(int j = 0; j < 100; j++){o int[] arr = ranInt(9);o StringBuffer sb = new StringBuffer();o for(int i = 0; i < arr.length; i++){o sb.append(arr[i]);o }o sb.append("\r\n");o buf = sb.toString().getBytes(); o os.write(buf);o }} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}finally{if(null != os){try {os.close();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}}/**o利用随机生成数组的索引实现随机，并通过交换实现不重复o@param no@returno*/o public static int[] ranInt(int n) {o int[] arr = new int[n];o int i,randomIndex,temp;o for(i = 0; i < n; i++){ooo arr[i] = i+1;}for(i = 1; i < n; i++){randomIndex = ranIndex(0, i);//交换当前元素和生成的随机元素temp = arr[i];arr[i] = arr[randomIndex];arr[randomIndex] = temp;}return arr;}public static int ranIndex(int start, int end){ Random r = new Random();int result;result = r.nextInt(end);return result;}} </pre>。