如何从数组中随机选择一个元素

我正在寻找解决方案，从一个整数数组随机挑选数字。

例如，我有一个数组 new int[]{1,2,3}，我如何能随机挑选一个数字？

322814 次浏览
小开
最佳答案 
public static int getRandom(int[] array) {
int rnd = new Random().nextInt(array.length);
return array[rnd];
}
小开

使用 java.util.Random生成一个介于0和数组长度: random_number之间的随机数，然后使用该随机数得到整数: array[random_number]

小开

您可以使用 Random 生成器生成一个随机索引并返回该索引处的元素:

//initialization
Random generator = new Random();
int randomIndex = generator.nextInt(myArray.length);
return myArray[randomIndex];
小开

使用 随机类:

int getRandomNumber(int[] arr)
{
return arr[(new Random()).nextInt(arr.length)];
}
小开

Java 在 Java.util 包中有一个 Random 类:

Random rnd = new Random();
int randomNumberFromArray = array[rnd.nextInt(3)];

希望这个能帮上忙！

小开

看看这个问题:

如何在 Java 中生成特定范围内的随机整数？

您将希望生成一个从0到整数长度 -1的随机数。然后简单地从数组中获取 int 值:

myArray[myRandomNumber];
小开

你也可以用

public static int getRandom(int[] array) {
int rnd = (int)(Math.random()*array.length);
return array[rnd];
}

Math.random()返回从 0.0(包括)到 1.0(独占)之间的 double

将此值与 array.length相乘可以得到 0.0(包含)和 array.length(独占)之间的 double

向 int的转换将四舍五入得到 0(包含)和 array.length-1(包含)之间的整数

小开

因为您有 java8，所以另一种解决方案是使用 StreamAPI。

new Random().ints(1, 500).limit(500).forEach(p -> System.out.println(list[p]));

其中，1是生成的最低整数(包含整数) ，而 500是最高整数(独占整数)。limit意味着流的长度为500。

 int[] list = new int[] {1,2,3,4,5,6};
new Random().ints(0, list.length).limit(10).forEach(p -> System.out.println(list[p]));

随机是从 java.util包。

小开 
package workouts;


import java.util.Random;


/**
*
* @author Muthu
*/
public class RandomGenerator {
public static void main(String[] args) {
for(int i=0;i<5;i++){
rndFunc();
}
}
public static void rndFunc(){
int[]a= new int[]{1,2,3};
Random rnd= new Random();
System.out.println(a[rnd.nextInt(a.length)]);
}
}
小开

如果要多次获取一个随机元素，则需要确保随机数生成器只初始化一次。

import java.util.Random;


public class RandArray {
private int[] items = new int[]{1,2,3};


private Random rand = new Random();


public int getRandArrayElement(){
return items[rand.nextInt(items.length)];
}
}

如果选择需要不可预测的随机数组元素，则应使用 Java.security SecureRandom而不是 Random。这保证了如果有人知道最后几个选择，他们就不会有优势猜测下一个。

如果你想使用泛型从 Object 数组中选择一个随机数，你可以为此定义一个方法(来源 字符串数组中的随机元素中的 阿维纳什 R) :

import java.util.Random;


public class RandArray {
private static Random rand = new Random();


private static <T> T randomFrom(T... items) {
return items[rand.nextInt(items.length)];
}
}
小开

你也可以尝试这种方法. 。

public static <E> E[] pickRandom_(int n,E ...item) {
List<E> copy = Arrays.asList(item);
Collections.shuffle(copy);
if (copy.size() > n) {
return (E[]) copy.subList(0, n).toArray();
} else {
return (E[]) copy.toArray();
}


}
小开 
package io.github.baijifeilong.tmp;


import java.util.concurrent.ThreadLocalRandom;
import java.util.stream.Stream;


/**
* Created by BaiJiFeiLong@gmail.com at 2019/1/3 下午7:34
*/
public class Bar {
public static void main(String[] args) {
Stream.generate(() -> null).limit(10).forEach($ -> {
System.out.println(new String[]{"hello", "world"}[ThreadLocalRandom.current().nextInt(2)]);
});
}
}
小开

在 Java7中，可以使用 ThreadLocalRandom。

与当前线程隔离的随机数生成器。与 Math 类使用的全局 Random 生成器一样，ThreadLocalRandom 是用内部生成的种子初始化的，这些种子可能不会被修改。在适用的情况下，在并发程序中使用 ThreadLocalRandom 而不是共享 Random 对象通常会遇到更少的开销和争用。当多个任务(例如，每个 ForkJoinTask)在线程池中并行使用随机数时，使用 ThreadLocalRandom 尤其合适。

public static int getRandomElement(int[] arr){
return arr[ThreadLocalRandom.current().nextInt(arr.length)];
}


//Example Usage:
int[] nums = {1, 2, 3, 4};
int randNum = getRandomElement(nums);
System.out.println(randNum);

也可以编写泛型版本，但它不适用于基元数组。

public static <T> T getRandomElement(T[] arr){
return arr[ThreadLocalRandom.current().nextInt(arr.length)];
}


//Example Usage:
String[] strs = {"aa", "bb", "cc"};
String randStr = getRandomElement(strs);
System.out.println(randStr);

提交答案