1. //需求：从50个元素中取出6个数，且不重复
   
2. import java.util.*;
   
3. public class LotterDrawing {
   
4.         
   
5.         public static void main(String[] args) {
   
6.         
   
7.                 int n = 50;
   
8.                 int [] number = new int[n];
   
9.                
   
10.                 for(int i=0;i<number.length;i++)
    
11.                 {
    
12.                         number[i] = i+1;
    
13.                 }
    
14.                 int[] result = new int[6];   //用来存放抽取的数组
    
15.                 for(int i=0;i<result.length;i++)
    
16.                 {
    
17.                         int r = (int)(Math.random()*50); //得到0到49这之间的一个随机数
    
18.                         
    
19.                         result[i] = number[r];
    
20.                         
    
21.                         number[r] = number[n-1]; //疑问？？？？
    
22.                         n--;                     //疑问？？？
    
23.                 }
    
24.                 Arrays.sort(result);
    
25.                 for(int r :result){
    
26.                         System.out.println(r);
    
27.                 }
    
28.                         
    
29.         }
    
30.          
    
31. 
    
32. }

复制代码

问题：答案说因为所有抽取的数值必须不相同，因此这里用数组中的最后一个数值改写number[r]，并将减1.
我的疑问：为什么使用数组中最后一个数值来改写number[r]？若在n=50，那么number[r] = 50；那也并未改写number[r]的值。只是将最后一个值赋给了number[r]。求解答？

1. public class RandomNumber {
   
2.         public static void main(String[] args) {
   
3.                 System.out.println("How many numbers do you need to draw?");
   
4.                 int k = 6;
   
5. 
   
6.                 System.out.println("What is the highest number you can draw?");
   
7. 
   
8.                 int n = 50;
   
9.                 // fill an array with numbers 1 2 3. . . n
   
10.                 int[] numbers = new int[n];
    
11.                 for (int i = 0; i < numbers.length; i++) {
    
12.                         numbers[i] = i + 1;
    
13.                 }
    
14. 
    
15.                 // draw k numbers and put them into a second array
    
16. 
    
17.                 int[] result = new int[k];
    
18.                 for (int i = 0; i < result.length; i++) {
    
19.                         // make a random index between 0 and n - 1
    
20.                         int r = (int) (Math.random() * n); // 关键在这里，*n表示每次会产生随机数的范围，每次产生的随机数范围是0~n
    
21. 
    
22.                         // pick the element at the random location
    
23.                         result[i] = numbers[r];
    
24. 
    
25.                         // move the last element into the random location
    
26.                         numbers[r] = numbers[n - 1];
    
27.                         // 之所以这里把最后的元素和之前选择元素做替换，因为要把每次都会缩小随机数产生的范围，而范围缩小是通过最后一个数减小来实现的。
    
28.                         n--;
    
29.                 }
    
30. 
    
31.                 // print the sorted array
    
32.                 Arrays.sort(result);
    
33.                 System.out
    
34.                                 .println("Bet the following combination,It'll make you rich!");
    
35.                 for (int i = 0; i < result.length; i++) {
    
36.                         System.out.println(result[i]);
    
37.                 }
    
38.         }
    
39. }

复制代码

在网上找了下，发现楼主你的代码没贴全呀。

我把源码贴过来了，你那个之所以不行，就是在于，你把源码中的变量n（控制随机数范围的变量）弄成了常量，如果这样做的话，每次随机数产生的范围都是一样大的，交换最后一个元素位置根本没意义。
如果像是源码那样，通过n的每次减小来缩小随机数产生的范围，通过交换最后一个数，可以把之前选择过的数剔除出随机数的范围，从而实现不重复。

PANZERLEADER 发表于 2013-4-16 00:19
在网上找了下，发现楼主你的代码没贴全呀。

我把源码贴过来了，你那个之所以不行，就是在于，你把源码中的 ...

源码不是贴过来的，在一本书上看到的，看了半天没弄明白，所以就来请教了，代码经过了一些简化，在书上只是提供了数组排序的例子，并未仔细说清楚n的值，导致在在产生随机数的时候就用n表示，也就一直在想n到底是常量还是变量呢，也导致了后面想不清楚，经过你的提醒才清楚n的值了一以及后面代码的意思。