用Java生成唯一随机数_Java_Random

用Java生成唯一随机数

java random

用Java生成唯一随机数,java,random,Java,Random,我试图得到0到100之间的随机数。但我希望它们是独一无二的，而不是按顺序重复。例如，如果我有5个数字，它们应该是82,12,53,64,32，而不是82,12,53,12,32 我用过这个，但它在一个序列中生成相同的数字 Random rand = new Random(); selected = rand.nextInt(100); 在结构中按顺序添加范围中的每个数字它以第一个“n”为例下面是一个简单的实现。这将打印范围为1-10的3个唯一随机数 import java.util.

我试图得到0到100之间的随机数。但我希望它们是独一无二的，而不是按顺序重复。例如，如果我有5个数字，它们应该是82,12,53,64,32，而不是82,12,53,12,32 我用过这个，但它在一个序列中生成相同的数字

Random rand = new Random();
selected = rand.nextInt(100);

在结构中按顺序添加范围中的每个数字
它
以第一个“n”为例

下面是一个简单的实现。这将打印范围为1-10的3个唯一随机数

import java.util.ArrayList;
import java.util.Collections;

public class UniqueRandomNumbers {

    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        for (int i=1; i<11; i++) {
            list.add(new Integer(i));
        }
        Collections.shuffle(list);
        for (int i=0; i<3; i++) {
            System.out.println(list.get(i));
        }
    }
}

对所有100个数字使用

Collections.shuffle（）

，然后选择前五个，如图所示

创建一个包含100个数字的数组，然后随机化它们的顺序

设计一个范围为100的伪随机数发生器

创建一个包含100个元素的布尔数组，然后在拾取该数字时将元素设置为true。选择下一个数字时，请检查数组，如果设置了数组元素，请重试。（您可以使用

long

数组创建一个易于清除的布尔数组，在该数组中，您可以移动和屏蔽以访问单个位。）

这将产生唯一的随机数

import java.util.HashSet;
import java.util.Random;

public class RandomExample {

    public static void main(String[] args) {
        Random rand = new Random();
        int e;
        int i;
        int g = 10;
        HashSet<Integer> randomNumbers = new HashSet<Integer>();

        for (i = 0; i < g; i++) {
            e = rand.nextInt(20);
            randomNumbers.add(e);
            if (randomNumbers.size() <= 10) {
                if (randomNumbers.size() == 10) {
                    g = 10;
                }
                g++;
                randomNumbers.add(e);
            }
        }
        System.out.println("Ten Unique random numbers from 1 to 20 are  : " + randomNumbers);
    }
}

import java.util.HashSet；
导入java.util.Random；
公共类随机化示例{
公共静态void main（字符串[]args）{
Random rand=新的Random（）；
INTE；
int i；
int g=10；
HashSet randomNumbers=新HashSet（）；
对于（i=0；iif（randomNumbers.size（）我重新计算了Anand的答案，以便不仅利用集合的唯一属性，而且在向集合添加失败时，还使用由集合.add（）返回的布尔false
import java.util.HashSet;
import java.util.Random;
import java.util.Set;

public class randomUniqueNumberGenerator {

    public static final int SET_SIZE_REQUIRED = 10;
    public static final int NUMBER_RANGE = 100;

    public static void main(String[] args) {
        Random random = new Random();

        Set set = new HashSet<Integer>(SET_SIZE_REQUIRED);

        while(set.size()< SET_SIZE_REQUIRED) {
            while (set.add(random.nextInt(NUMBER_RANGE)) != true)
                ;
        }
        assert set.size() == SET_SIZE_REQUIRED;
        System.out.println(set);
    }
}

import java.util.HashSet；
导入java.util.Random；
导入java.util.Set；
公共类随机数生成器{
公共静态最终整数集\u所需大小\u=10；
公共静态最终整数范围=100；
公共静态void main（字符串[]args）{
随机=新随机（）；
Set Set=新哈希集（需要设置大小）；
while（set.size（）
我觉得这个方法值得一提
   private static final Random RANDOM = new Random();    
   /**
     * Pick n numbers between 0 (inclusive) and k (inclusive)
     * While there are very deterministic ways to do this,
     * for large k and small n, this could be easier than creating
     * an large array and sorting, i.e. k = 10,000
     */
    public Set<Integer> pickRandom(int n, int k) {
        final Set<Integer> picked = new HashSet<>();
        while (picked.size() < n) {
            picked.add(RANDOM.nextInt(k + 1));
        }
        return picked;
    }

private static final Random Random=new Random（）；
/**
*选择0（含）和k（含）之间的n个数字
*虽然有非常确定的方法可以做到这一点，
*对于大k和小n，这可能比创建
*大数组和排序，即k=10000
*/
公共集随机选取（整数n，整数k）{
最终选择的集合=新的HashSet（）；
while（picked.size（）
一个聪明的方法是在模中使用基本元素的指数
例如，2是一个基本的根mod 101，这意味着2 mod 101的幂为您提供了一个非重复序列，可以看到从1到100（含）的每个数字：
2^0 mod 101 = 1
2^1 mod 101 = 2
2^2 mod 101 = 4
...
2^50 mod 101 = 100
2^51 mod 101 = 99
2^52 mod 101 = 97
...
2^100 mod 101 = 1

在Java代码中，您可以编写：
void randInts（）{
int num=1；
对于（int ii=0；ii检查此项
public class RandomNumbers {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int n = 5;
        int A[] = uniqueRandomArray(n);
        for(int i = 0; i<n; i++){
            System.out.println(A[i]);
        }
    }
    public static int[] uniqueRandomArray(int n){
        int [] A = new int[n];
        for(int i = 0; i< A.length; ){
            if(i == A.length){
                break;
            }
            int b = (int)(Math.random() *n) + 1;
            if(f(A,b) == false){
                A[i++] = b;
            } 
        }
        return A;
    }
    public static boolean f(int[] A, int n){
        for(int i=0; i<A.length; i++){
            if(A[i] == n){
                return true;
            }
        }
        return false;
    }
}

公共类随机数{
公共静态void main（字符串[]args）{
//TODO自动生成的方法存根
int n=5；
int A[]=uniqueRandomArray（n）；
对于（int i=0；i使用Java 8+，您可以使用Random
的方法来获取一组随机值，然后将流减少为一些唯一的随机值
ThreadLocalRandom.current().ints(0, 100).distinct().limit(5).forEach(System.out::println);

Random
还有一些方法可以创建LongStream
s和DoubleStream
s，如果您需要的话
如果您希望一个范围内的所有（或大量）数字以随机顺序排列，则将所有数字添加到一个列表中，将其洗牌，然后取第一个n可能更有效，因为上面的示例当前是通过在请求的范围内生成随机数并将其传递给一个集合来实现的（类似于），这可能需要生成比传递到限制的数量多得多的数量，因为生成新的唯一编号的概率会随着每次发现而降低。下面是另一种方法的示例：
List<Integer> range = IntStream.range(0, 100).boxed()
        .collect(Collectors.toCollection(ArrayList::new));
Collections.shuffle(range);
range.subList(0, 99).forEach(System.out::println);

List range=IntStream.range（01100）.boxed（）
.collect（收集器.toCollection（ArrayList:：new））；
集合。洗牌（范围）；
range.subList（0,99）.forEach（System.out:：println）；
试试这个
public class RandomValueGenerator {
    /**
     * 
     */
    private volatile List<Double> previousGenValues = new ArrayList<Double>();

    public void init() {
        previousGenValues.add(Double.valueOf(0));
    }

    public String getNextValue() {
        Random random = new Random();
        double nextValue=0;
        while(previousGenValues.contains(Double.valueOf(nextValue))) {
            nextValue = random.nextDouble();
        }
        previousGenValues.add(Double.valueOf(nextValue));
        return String.valueOf(nextValue);
    }
}

公共类随机值生成器{
/**
* 
*/
private volatile List previousGenValues=new ArrayList（）；
公共void init（）{
previousGenValues.add（Double.valueOf（0））；
}
公共字符串getNextValue（）{
随机=新随机（）；
双nextValue=0；
while（previousGenValues.contains（Double.valueOf（nextValue）））{
nextValue=random.nextDouble（）；
}
previousGenValues.add（Double.valueOf（nextValue））；
返回字符串.valueOf（nextValue）；
}
}
我是从另一个问题来到这里的，这个问题与这个问题（）
在一个数组中存储1到100个数字
生成1到100之间的随机数作为位置，并返回数组[position-1]以获取值
在数组中使用数字后，将该值标记为-1（无需维护另一个数组来检查是否已使用该数字）
若数组中的值为-1，则再次获取随机数以获取数组中的新位置
从0到m-1中选择n个唯一的随机数
int[] uniqueRand(int n, int m){
    Random rand = new Random();
    int[] r = new int[n];
    int[] result = new int[n];
    for(int i = 0; i < n; i++){
        r[i] = rand.nextInt(m-i);
        result[i] = r[i];
        for(int j = i-1; j >= 0; j--){
            if(result[i] >= r[j])
                result[i]++;
        }
    }
    return result;
}

int[]uniqueRand（int n，int m）{
Random rand=新的Random（）；
int[]r=新的int[n]；
int[]结果=新的int[n]；
对于（int i=0；i=0；j--）{
如果（结果[i]>=r[j]）
结果[i]
int[] uniqueRand(int n, int m){
    Random rand = new Random();
    int[] r = new int[n];
    int[] result = new int[n];
    for(int i = 0; i < n; i++){
        r[i] = rand.nextInt(m-i);
        result[i] = r[i];
        for(int j = i-1; j >= 0; j--){
            if(result[i] >= r[j])
                result[i]++;
        }
    }
    return result;
}

    Integer[] indices = new Integer[n];
    Arrays.setAll(indices, i -> i);
    Collections.shuffle(Arrays.asList(indices));
    return Arrays.stream(indices).mapToInt(Integer::intValue).toArray();

public int GenerateRandomNo()
{
    int _min = 0000;
    int _max = 9999;
    Random _rdm = new Random();
    return _rdm.Next(_min, _max);
}
public int rand_num()
{
    randnum = GenerateRandomNo();
    string createText = randnum.ToString() + Environment.NewLine;
    string file_path = System.IO.Path.GetDirectoryName(System.Windows.Forms.Application.ExecutablePath) + @"\Invoices\numbers.txt";
    File.AppendAllText(file_path, createText);
    int number = File.ReadLines(file_path).Count(); //count number of lines in file
    System.IO.StreamReader file = new System.IO.StreamReader(file_path);
    do
    {
        randnum = GenerateRandomNo();
    }
    while ((file.ReadLine()) == randnum.ToString());
    file.Close();
    return randnum;

}

    Random random = new Random();
    ArrayList<Integer> arrayList = new ArrayList<Integer>();

    while (arrayList.size() < 6) { // how many numbers u need - it will 6
        int a = random.nextInt(49)+1; // this will give numbers between 1 and 50.

        if (!arrayList.contains(a)) {
            arrayList.add(a);
        }
    }

package study;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/*
Created By Sachin  Rane on Jul 18, 2018
*/
public class UniqueRandomNumber {
    static Boolean[] boolArray;
    public static void main(String s[]){
        List<Integer> integers = new ArrayList<>();


        for (int i = 0; i < 10; i++) {
            integers.add(i);
        }


        //get unique random numbers
        boolArray = new Boolean[integers.size()+1];
        Arrays.fill(boolArray, false);
        for (int i = 0; i < 10; i++) {
            System.out.print(getUniqueRandomNumber(integers) + " ");

        }

    }

    private static int  getUniqueRandomNumber(List<Integer> integers) {
        int randNum =(int) (Math.random()*integers.size());
        if(boolArray[randNum]){
            while(boolArray[randNum]){
                randNum++;
                if(randNum>boolArray.length){
                    randNum=0;
                }
            }
            boolArray[randNum]=true;
            return randNum;
        }else {
            boolArray[randNum]=true;
            return randNum;
        }

    }

}

for(int i=0;i<4;i++)
        {
            rn[i]= GenerateRandomNumber();
            for (int j=0;j<i;j++)
            {
                if (rn[i] == rn[j])
                {
                    i--;
                }
            }
        }

import java.util.Collections;
import java.util.ArrayList;
public class Lottery {
public static void main(String[] args) {
//define ArrayList to hold Integer objects
ArrayList numbers = new ArrayList();
for(int i = 0; i < 100; i++)
{
numbers.add(i+1);
}
Collections.shuffle(numbers);
System.out.println(numbers);
}
}

public static void RandomGenerate(int n)
{
     Set<Integer> st=new HashSet<Integer>();
     Random r=new Random();
     while(st.size()<n)
     {
        st.add(r.nextInt(n));
     }

ArrayList<Integer> sampleList = new ArrayList<>();
sampleList.add(1);
sampleList.add(2);
sampleList.add(3);
sampleList.add(4);
sampleList.add(5);
sampleList.add(6);
sampleList.add(7);
sampleList.add(8);

int n;
randomList = new ArrayList<>();
for(int  i=0;i<5;i++){
    Random random = new Random();
    n=random.nextInt(8);     //Generate a random index between 0-7

    if(!randomList.contains(sampleList.get(n)))
    randomList.add(sampleList.get(n));
    else
        i--;    //reiterating the step
}
        

/**
 * Provided an unsequenced / sequenced list of integers, the function returns unique random IDs as defined by the parameter
 * @param numberToGenerate
 * @param idList
 * @return List of unique random integer values from the provided list
 */
private List<Integer> getUniqueRandomInts(List<Integer> idList, Integer numberToGenerate) {

    List<Integer> generatedUniqueIds = new ArrayList<>();

    Integer minId = idList.stream().mapToInt (v->v).min().orElseThrow(NoSuchElementException::new);
    Integer maxId = idList.stream().mapToInt (v->v).max().orElseThrow(NoSuchElementException::new);

            ThreadLocalRandom.current().ints(minId,maxId)
            .filter(e->idList.contains(e))
            .distinct()
            .limit(numberToGenerate)
            .forEach(generatedUniqueIds:: add);

    return generatedUniqueIds;

}

    List<Integer> ids = getUniqueRandomInts(allIntegers,11);