我想使用 Math.random 生成 6 个不同的随机数并将它们存储到一个数组中。 我怎样才能确保它们是不同的？我知道我需要使用 for 循环来检查数组，但是如何...
这是范围。我只需要 1 到 49 之间的数字。 ( 1 + (int) (Math.random() * 49) )
【问题讨论】：
生成任意 6 个数字（不一定不同）。订购它们。
a1
现在取这 6 个数字
a1
这 6 个是不同且随机的。
这个结构的想法来自一些组合证明。
它的优点是简单、快速且具有确定性。
我认为时间复杂度是O(count*log(count))。
我想知道它是否可以改进。
import java.util.TreeMap;
public class Test005 {
public static void main(String[] args) {
int count = 6;
int min = 1;
int max = 49;
// random number mapped to the count of its occurrences
TreeMap<Integer, Integer> mp = new TreeMap<Integer, Integer>();
for (int i=0; i<count; i++){
int d = ( min + (int) (Math.random() * (max-count+1)) );
if (!mp.containsKey(d)){
mp.put(d, 0);
}
mp.put(d, mp.get(d) + 1);
}
// now ensure the output numbers are different
int j = 0;
for (int num : mp.keySet()){
int cnt = mp.get(num);
for (int i=0; i<cnt; i++){
System.out.println(num + j);
j++;
}
}
}
}
【讨论】：
int max = 44;然后增加的不能超过49。
在 Java 8 中：
final int[] ints = new Random().ints(1, 50).distinct().limit(6).toArray();
在 Java 7 中：
public static void main(final String[] args) throws Exception {
final Random random = new Random();
final Set<Integer> intSet = new HashSet<>();
while (intSet.size() < 6) {
intSet.add(random.nextInt(49) + 1);
}
final int[] ints = new int[intSet.size()];
final Iterator<Integer> iter = intSet.iterator();
for (int i = 0; iter.hasNext(); ++i) {
ints[i] = iter.next();
}
System.out.println(Arrays.toString(ints));
}
只是有点混乱。将Set<Integer> 拆箱成int[] 非常乏味这一事实无济于事。
需要注意的是，这个解决方案应该很好，所需值的数量明显小于范围。因为1..49 比6 大很多，所以你很好。否则性能会迅速下降。
【讨论】：
Set 中的项目的自然顺序——这是一个很好的观点。我想LinkedHashSet 会在第二种情况下工作。在第一种情况下，我不确定如何解决...
您可以使用Set。
Set<Integer> s = new HashSet<>();
while(s.size() != 6){
s.add(1 + (int) (Math.random() * 49));
}
Integer[] arr = s.toArray(new Integer[s.size()]);
这足以在您的情况下执行此操作，因为与您生成它们的范围大小相比，不同随机数的数量相对较小。
否则我会使用@JBNizet 方法。
【讨论】：
创建一个包含数字 1 到 49 的列表。
创建一个介于 0 和列表大小之间的随机数 x，取列表中索引 x 处的数字，并将其从列表中删除。
重复上一步 5 次。你完成了。请注意，java.util.Random 有一个 nextInt(int max) 方法，您应该使用它来代替 Math.random()。
关于性能的注意事项：与“尝试直到获得 6 个不同的数字”各种解决方案相比，此解决方案具有优势：它在 O(n) 时间内运行。 50 个中的 6 个唯一数字无关紧要，但是如果您想从 50 个中获得 48 或 49 个唯一随机数，您将开始看到差异，因为您可能必须先生成许多随机数才能获得一个不在集合中。
编辑：
为了减少删除列表中的元素所带来的成本，您可以简单地将索引x 处的元素替换为列表的最后一个元素（在第二次迭代中，使用大小为 - 2等）
【讨论】：
subList 轻松做到这一点。
只要它们是唯一的，就继续生成数字并将它们添加到数组中；伪代码：
num = genNextRand()
For (array length)
If (num not in array)
addToArray()
Repeat while length not equal 6
【讨论】：
您可以在生成数字时使用更多的智能，而不是检查数组是否有重复项，这样一开始就强制执行唯一性。
boolean[]，只要您的范围（49 个条目）；boolean[]中对应的索引；boolean[]，计算所有未交叉的条目。当您达到等于步骤 5 中生成的随机数的计数时停止。与该条目对应的数字就是您的输出数；【讨论】：
创建一个变量last;将其初始化为0。
接下来，在从 0 到 5 的循环 x 中，创建一个介于 <em>last</em>+1 和 49-6+<em>x</em> 之间的随机数。将此号码存储在列表中，并将<em>last</em> 设置为以这种方式生成的号码。
您最终会得到一个 1..49 范围内的 6 个随机数的有序列表，没有重复。
【讨论】：
在你的情况下 n=6
public static int[] chooseAny(int n){
int[] lottery = new int[n];
int[] chooseFrom = new int[49];
for(int i=1 ; i <= 49 ; i++)
chooseFrom[i-1] = i;
Random rand = new Random();
int N = 49;
int index;
for(int i=0 ; i < n ; i++){
//pick random index
index = rand.nextInt(N);
lottery[i] = chooseFrom[index];
chooseFrom[index] = chooseFrom[N-1];
N--;
}
return lottery;
}
【讨论】：
我刚刚想出了一个关于 Java 8 的小想法。
Set<Integer> set = new LinkedHashSet<>();
while(set.size() != 6)
set.add(rnd.nextInt(49) + 1);
【讨论】：
该代码生成从 6 到 0 的数字并保存在 ArrayList 中。
如果生成的号码重复，程序会再次生成号码。
如果生成的数字不同，则添加该数字。
代码：
private ArrayList<Integer> arraylist = new ArrayList<Integer>();
private Random rand = new Random();
public void insertNumber() {
while (true) {
int i = generateNumber();
if(!isGenerateNumberExists(i)){
addNumber(i);
break;
}
}
}
//Generate numbers
private int generateNumber() {
return rand.nextInt(6);
}
//Confirm if that number exists
private boolean isGenerateNumberExists(int y) {
for (int num : arraylist) {
if (num == y) {
return true;
}
}
return false;
}
//Add number to arrayList
private void addNumber(int x) {
arraylist.add(x);
}
【讨论】：