怎么都到不重复的20个1到1000之间的随机数?

1. import java.util.Random;
   
2. 
   
3. public class help1 {
   
4.         public static void main(String[] args) {
   
5.                 Random r=new Random(System.currentTimeMillis());
   
6.                 int x=0;
   
7.                 for (int i = 0; i < 300; i++) {
   
8.                         x=r.nextInt(1000);
   
9.                         System.out.println(x);
   
10.                 }
    
11.         }
    
12. }
    

复制代码

用list或collect应该可以

Caincxy 发表于 2014-7-22 09:27
用list或collect应该可以

不重复不应该是Set么

1. package tset;
   
2. 
   
3. /*
   
4. * 思路:
   
5. * 1.创建一个HashSet集合用于存放不重复的随机数
   
6. * 2.创建随机数生成器生成1-1000之间的随机数
   
7. * 3.判断HashSet集合的大小,如果小于20则不断生成随机数并添加到集合中
   
8. * 4.如果HashSet集合的大小等于20,则跳出随机数生成的循环
   
9. * 5.打印最终得到的HashSet集合
   
10. */
    
11. 
    
12. import java.util.HashSet;
    
13. import java.util.Random;
    
14. 
    
15. public class Demo {
    
16. 
    
17.         public static void main(String[] args) {
    
18. 
    
19.                 // 创建一个set集合用来接收要存储的数据
    
20.                 HashSet<Integer> hs = new HashSet<Integer>();
    
21. 
    
22.                 // 创建一个随机数生成器
    
23.                 Random r = new Random();
    
24. 
    
25.                 // 循环生成随机数
    
26.                 while (true) {
    
27. 
    
28.                         // 判断当HashSet集合的大小为20时,结束生成随机数的循环
    
29.                         if (hs.size() == 20) {
    
30.                                 break;
    
31.                         }
    
32. 
    
33.                         // 如果HashSet集合的大小不等于20,产生一个随机数并添加到HashSet集合中
    
34.                         int j = r.nextInt(1000) + 1;
    
35.                         hs.add(j);
    
36.                 }
    
37. 
    
38.                 // 打印最终的HashSet集合
    
39.                 System.out.println(hs);
    
40.         }
    
41. 
    
42. }
    

复制代码

package ArrayTest;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Random;
import java.util.Set;
/**
* 该类中写了2个不同的实现方式，并提供了一个遍历生成结果的方式
* 方式1：通过List集合来接收产生的随机数，再调用contains()方法判断，是否有元素与产生的随机数相等，不等直接添加；
* 方式2：通过Set集合来接收产生的随机数，直接向Set集合中添加随机数。
* 遍历方式：用数组接收集合中的值，再通过sort()方法对数组排序后，再遍历输出，查看是否有重复值。
*/
public class RandomNum {

        /**
         * @param args
         */
        public static void main(String[] args) {
                /*
                 * 方式1
                 */
                //定义一个Integer类型的List泛型集合nums
                List<Integer> nums = new ArrayList<Integer>();
                //声明一个随机数对象
                Random ran = new Random();
                //通过循环向泛型集合nums中添加元素
                while (true) {
                        //如果集合nums中的元素个数等于20时，则推出循环，停止添加元素
                        if (nums.size() == 20) {
                                break;
                        }
                        //生成一个1~1000的随机数，泳衣个变量num接收
                        int num = ran.nextInt(1000) + 1;
                        //判断在泛型集合nums中是否存在与num值相等的元素，没有则添加。
                        if (!nums.contains(num)) {
                                nums.add(num);
                          //System.out.println(num + " ");//打印出元素的值
                        }
                }
               
                /*
                 * 方式2
                 */
                //定义一个Integer类型的Set泛型集合nums2。操作同上。
//                Set<Integer> nums2 = new HashSet<Integer>();
//                while (true) {
//                        if (nums2.size() > 20) {
//                                break;
//                        }
//                        int num = ran.nextInt(1000) + 1;
//                        //因为Set集合保存的是无序，但唯一的值，所以不用判断nums2中的元素是否与num值相等，直接添加到集合中。
//                        nums2.add(num);
//                }
               
                /*
                 * 遍历查看是否有重复值
                 */
                //以下的操作，是通过将集合nums中的值保存到数组is中，再通过sort()方法排序之后输出，可以比较直观的看出有没有重复值。
                int[] is = new int[nums.size()];
                for (int i = 0; i < nums.size(); i++) {
                        is[i] = nums.get(i);
                }
                //以下的操作,也是为了方便查看是否有重复值,将集合nums2中的值保存到数组is中。
//                //因为Set泛型集合存储的元素是无序的，所有要用迭代器Iterator来遍历其中的元素。
//                Iterator<Integer> it = nums2.iterator();
//                int j = 0;
//                while (it.hasNext()) {
//                        is[j] = it.next();
//                        j++;
//                }
                Arrays.sort(is);
                for (int i = 0; i < is.length; i++) {
                        if (i == is.length - 1) {
                                System.out.print(is[i]);
                                break;
                        }
                        System.out.print(is[i] + ",");
                }
        }
}