int[] intRet = new int[20];
                int intRd = 0; // 存放随机数
                int count = 0; // 记录生成的随机数个数
                boolean flag = true; // 是否已经生成过标志
                while (count < 20) {
                        //创建
                        Random rdm = new Random();
                        //将随机数强转成int
                        intRd = (int) (rdm.nextDouble()*20+1);
                        for (int i = 0; i < count; i++) {
                                //如何数组内的数和刚刚生成的随机一样的话 就跳出for循环 继续执行 while循环生成随机数进行比较
                                if (intRet[i] == intRd) {
                                        flag = false;
                                        break;
                                } else {
                                        flag = true;
                                }
                        }
                        //如果为true 则表示,数组中无此数 就执行保存操作
                        if (flag == true) {
                                intRet[count] = intRd;
                                count++;
                        }
                }
                //打印不重复的随机数
                System.out.println("打印随机数：");
                for (int i = 0; i < 20; i++) {
                        System.out.print(intRet[i]+"   ");
                }
        }


求更有效率的办法！

//将随机数强转成int
intRd = (int) (rdm.nextDouble()*20+1);

为啥要用double类型的不直接用Int类型的
inRd = rdm.netInt(20)+1;(左闭右开)

1. public class SuiJiShu
   
2. {
   
3.         public static void main(String[] args)
   
4.                {
   
5.                 SuiJiShu t = new SuiJiShu();
   
6.                 System.out.println(t.getInt(20, 0));
   
7.         }
   
8.         static int getInt(int max,int min)
   
9.                 {
   
10.                 if(min>max)
    
11.                                 {
    
12.                         return -1;        //异常判断
    
13.                 }
    
14.                 Random random = new Random();
    
15.                 int result = random.nextInt(max+1);//取小于或等于max的一个随机数
    
16.                 if(result < min)
    
17.                                 {       
    
18.                         result = getInt(max,min);//如果随机数小于min，则递归
    
19.                 }
    
20.                 return result;
    
21.         }
    
22. }

复制代码

这样子就可以了

呜　跟老大达成协议　我就写一个吧　不敢说高效率,不过比你这个初级的要稍微高级一点　请稍等我码代码

搞定了...到现在饭都没吃　其实就是利用了hashmap这个类的方便而已　代码如下

1. import java.util.*;
   
2. 
   
3. public class test4
   
4. {       
   
5.                 static HashMap<Integer,Integer> hm =new HashMap<Integer,Integer>();
   
6.         public static void main(String[] args)
   
7.         {
   
8.                 int itemp = 0;
   
9.                 Scanner input = new Scanner(System.in);
   
10.                 System.out.println("请输入需要产生不重复随即数的个数为：");
    
11.                 itemp = input.nextInt();
    
12.                 if(itemp==0){
    
13.                         System.out.println("不要搞笑 请认真输入！！(程序因为过多的愤怒而自己停止运行了的说..)");
    
14.                 }else{
    
15.                         randomNumber(0,itemp);
    
16.                         System.out.println("打印随机数：");
    
17.                         for(int i=0;i<itemp;i++){
    
18.                                 System.out.print("\t"+hm.get(i));
    
19.                         }
    
20.                 }
    
21.         }
    
22.         
    
23.         public static void randomNumber(int min, int max) {
    
24.                 if (min < max) {
    
25.                         int key = min;
    
26.                         Random random = new Random();
    
27.                         int itemp = random.nextInt(max) + 1;
    
28.                         if (hm.containsValue(itemp)) {
    
29.                                 randomNumber(key,max);
    
30.                         } else {
    
31.                                 hm.put(key, itemp);
    
32.                                 randomNumber(key+1,max);
    
33.                         }
    
34.                 }
    
35.         }
    
36. }

复制代码

具体要产生几个看你自己定,顺便再把楼上悲剧的归递给补全了吧....

哪不懂楼下问我　我先去搞中饭了　真心饿死!

朱宏青 发表于 2012-11-7 13:26
呜　跟老大达成协议　我就写一个吧　不敢说高效率,不过比你这个初级的要稍微高级一点　请稍等我码代码 ...

:)期待......

朱宏青 发表于 2012-11-7 13:26
呜　跟老大达成协议　我就写一个吧　不敢说高效率,不过比你这个初级的要稍微高级一点　请稍等我码代码

搞 ...

兄弟你这效率一点都不高，你使用的是递归，你可知道，每递归一次都要往方法栈里压入当前递归的代码运行信息，假如你要输出的随机数多的话，肯定会内存溢出的StackOverflowError，不信，你测试1000个随机数就有可能StackOverflowError。乱用递归并不是什么好事，这要求用一个循环就能搞定，代码又简单速度又快

贴一下我的解决方案:四行代码搞定问题：

1. Random r = new Random();
   
2.                 // 定义一个Set集合，存放10个随机数，因为Set不允许存在重复值
   
3.                 Set<Integer> set = new HashSet<Integer>();
   
4.                 while (set.size() < 10) {// 判断是否存够10个不同的随机数
   
5.                         set.add(r.nextInt(20) + 1);// 往集合中 ，添加1至20的随机数
   
6.                 }

复制代码

付维翔 发表于 2012-11-7 14:48
贴一下我的解决方案:四行代码搞定问题：

首先我声明了过了“不敢说效率”　第二　用归递是因为楼上朋友的归递挂掉了　我帮他补全而已　我也可以用while（min<max）来达到自我循环 因为每次使用randomNumber方法都会吃掉内存　多了自然没有效率可言。

另外　你确定你测试过你这个程序了么？假如设定为２０个随即数，你确定产生的功能是需要的？

另外让我膜拜一下这段代码　简洁明了！我得去研究下set,hashmap我用的太多了　所以思考的时候老上头

付维翔 发表于 2012-11-7 14:48
贴一下我的解决方案:四行代码搞定问题：

漂亮！
代码写的多了，这样的代码就水到渠成了。
简洁明了！

个人不喜欢使用Random类。Math.random()方法也非常好使。
不需要创建Random类的对象。

技术分  技术分