今天看见一个题目，要求创建一个int数组，随机生成20个值，要求20个值不重复，不允许调用系统函数
小弟写的代码如下：

1. class Btshuzu{
   
2.         public static void main(String [] args){
   
3.                 int shuzu[]=new int[20];         
   
4.                 //声明一个int数组来存放生成的20个随机数
   
5.                 int geshu=0;        
   
6.                 //声明一个int变量geshu存放当前数组中合格随机数元素个数
   
7.                 int yuansu;      
   
8.                  //声明一个int变量yuansu临时存放每次生成的随机数
   
9.                 boolean chongfu=false;                        
   
10.                 //声明一个boolean变量chongfu表示当前生成元素是否与数组中已存放元素相同
    
11.                 do{
    
12.                         yuansu=(int)(Math.random()*99+1);   
    
13.                         //随机生成一个1~100的整数
    
14.                         for(int i=0;i<geshu;i++){                        
    
15.                                 if(shuzu[i]==yuansu){      
    
16.                                 //将生成的元素与数组中已存放元素比较，如果相等
    
17.                                         chongfu=true;         
    
18.                                         //则值重复，将chongfu重新复制为true，并退出这个对比循环
    
19.                                         break;
    
20.                                 }
    
21.                         }
    
22.                         if(!chongfu){
    
23.                                 shuzu[geshu]=yuansu;        
    
24.                                 //如果不重复，则将yuansu存放在数组中，同时geshu++
    
25.                                 geshu++;
    
26.                         }
    
27.                 }while(geshu<20);    //当存放的元素个数小于20继续进入循环
    
28.                 for(int i=0;i<geshu;i++){
    
29.                         System.out.println(("第"+(i+1)+"个元素是："+shuzu[i]+""));         
    
30.                         //依次输出存放的二十个元素至
    
31.                 }
    
32.         }
    
33. }
    

复制代码

使用javac编译不提示错误，运行无响应！麻烦大家有空的话帮忙找找原因，我想半天没想出来。
非常谢谢！

没人回答，好吧，不过我自己找到原因了，有空给大家分享一下我逗比的分析过程{:3_63:}

这有什么问题？代码在eclipse跑没事的啊

jie96169 发表于 2015-2-11 23:29
这有什么问题？代码在eclipse跑没事的啊

您再仔细看看，跑的话不会提示错误，但是您看看任务管理器里面的进程，稍后我有空，分享下我的逗比找错过程

问题我自己已经解决了，感觉自己不细心，然后就会做些逗比的事情
今天遇到的这个问题关键还是属于自己不够细心：
1、没有认真思考，写代码时将某个参数的重置放错了位置；
2、没有认真检查，看代码时没严格进行逻辑演算。
最后导致自己浪费大量时间在这个简单的代码上，居然用Eclipse调试了半天
但是，也算是吸取教训，我将自己整个过程写下来。
说起来也算是自己解决问题的逗比思路，可能很不成熟，希望大家指正！
谢谢！也希望大家有更好的思路和方法能共享一下！
开始我直接在记事本中写的代码，在出现问题半天没有找到原因时，我用Eclipse运行了下代码，
没有出错，但是笔记本风扇居然响起来了，打开管理器发现一个java进程在吃着内存，立马关掉。。。
（PS：我太菜，不会用Eclipse，其实当时控制台终止按钮亮着我没看见也不知道）
再次运行发现出结果，然后又运行就又是“没动静”，
尝试在减少数组shuzu[]长度时，发现长度越小出结果的几率越大，“没动静”几率越小
感觉可能是有时候会无限循环着，于是添加了System.out.println("yuansu["+cishu+"]="+yuansu);输出每次获取的元素

1. class Btshuzu{
   
2.         public static void main(String [] args){
   
3.                 int shuzu[]=new int[20];         
   
4.                 int geshu=0;        
   
5.                 int yuansu;
   
6.                 int cishu=0;      
   
7.                 do{
   
8.                         cishu++;
   
9.                         boolean chongfu=false;
   
10.                         yuansu=(int)(Math.random()*99+1);
    
11.                         System.out.println("yuansu["+cishu+"]="+yuansu);输出每次获取的元素
    
12.                         for(int i=0;i<geshu;i++){                        
    
13.                                 if(shuzu[i]==yuansu){      
    
14.                                         chongfu=true;
    
15.                                         break;
    
16.                                 }
    
17.                         }
    
18.                         if(!chongfu){
    
19.                                 shuzu[geshu]=yuansu;  
    
20.                                 geshu++;
    
21.                         }
    
22.                 }while(geshu<20);   
    
23.                 for(int i=0;i<geshu;i++){
    
24.                         System.out.println(("第"+(i+1)+"个元素是："+shuzu[i]+""));  
    
25.                 }
    
26.         }
    
27. }
    

复制代码

截取一段运行结果如下:

yuansu[223062]=36
yuansu[223063]=28
yuansu[223064]=51
yuansu[223065]=75
yuansu[223066]=22
yuansu[223067]=91
yuansu[223068]=87
yuansu[223069]=64
yuansu[223070]=25
yuansu[223071]=31
yuansu[223072]=30
yuansu[223073]=41
yuansu[223074]=63
yuansu[223075]=60

现任进入了无限循环，测试我还没有意思到循环那里出了问题

接下来，我由添加了添加一个cishu变量记录循环次数， 同时添加System.out.print("数组当前已成功获取元素个数为："+geshu+"个；第"+cishu+"次尝试获取到的元素是：");
并且当循环次数等于100时退出循环，if(cishu==100) break;
再次运行，截取一段运行结果如下：

数组当前已成功获取元素个数为：0个；第1次尝试获取到的元素是：yuansu[1]=17
数组当前已成功获取元素个数为：1个；第2次尝试获取到的元素是：yuansu[2]=4
数组当前已成功获取元素个数为：2个；第3次尝试获取到的元素是：yuansu[3]=82
数组当前已成功获取元素个数为：3个；第4次尝试获取到的元素是：yuansu[4]=80
数组当前已成功获取元素个数为：4个；第5次尝试获取到的元素是：yuansu[5]=82
数组当前已成功获取元素个数为：4个；第6次尝试获取到的元素是：yuansu[6]=31
数组当前已成功获取元素个数为：4个；第7次尝试获取到的元素是：yuansu[7]=51

很明显，当心获取的元素与数组中的存在的某个元素相同时，符合条件的元素也无法存入数组，由此进入了无效循环
此时，我终于意识到可能是到boolean变量chongfu的问题，再看代码，恍然大悟
在新生成的元素等于数组中的元素后，chognfu会被赋值为true，
而此后chongfu没有被重置为false，所以在后面生成的元素即便符合条件也无法存入数组了
所以我们需要在每次生成新随机数钱将chognfu重置为false即可，
或者直接将代码boolean chongfu=false;移动至do{}while循环内首句即可

1. 
   
2. public class Btshuzu{
   
3.         public static void main(String [] args){
   
4.                 int shuzu[]=new int[20];
   
5.                 int geshu=0;
   
6.                 int cishu=0;
   
7.                 //发现是无限循环后，我设置cishu监控循环次数
   
8.                 int yuansu;
   
9.                 boolean chongfu=false;
   
10.                 //将chongfu的重置放在do{}while循环外，当生成的随机数有一个等于数组内的数字时，
    
11.                 //chognfu便会被赋值为true，自此无法重置为false，就算新生成的随机数与数组内的数字不一样也无法储存！
    
12.                 do{
    
13.         //                boolean chongfu=false;
    
14.                         //将chongfu放在do{}while循环内重置，当上一个生成的随机数等于数组内的某个数字时，chognfu=true
    
15.                         //上一个生成随机数不会被存储在数组中，当重再次进入循环，在这里chognfu重置赋值为false，不影响新生成的符合条件的随机数的储存
    
16.                         cishu++;
    
17.                         //do{}while每循环一次cishu++
    
18.                         yuansu=(int)(Math.random()*99+1);
    
19.                         System.out.print("数组当前已成功获取元素个数为："+geshu+"个；第"+cishu+"次尝试获取到的元素是：");
    
20.                         System.out.println("yuansu["+cishu+"]="+yuansu);
    
21.                         //调试输出数组当前已成功获取元素个数和本次次随机获取到的元素值                        
    
22.                         for(int i=0;i<geshu;i++){
    
23.                                 if(shuzu[i]==yuansu){
    
24.                                         chongfu=true;
    
25.                                         break;
    
26.                                 }
    
27.                         }
    
28.                         if(!chongfu){
    
29.                                 shuzu[geshu]=yuansu;
    
30.                                 geshu=geshu+1;
    
31.                         }
    
32.                         if(cishu==100) break;
    
33.                         //当循环次数达到100时推出循环
    
34.                 }while(geshu<20);
    
35.                 System.out.println("\n************以下为截止程序停止时所获取到的数组中的全部元素************");
    
36.                 //调试输出截止程序停止时所获取到的数组中的全部元素
    
37.                 for(int i=0;i<geshu;i++){
    
38.                         System.out.println(("第"+(i+1)+"个元素是："+shuzu[i]+""));
    
39.                 }
    
40.         }
    
41. }
    

复制代码

最后的运行结果终于正确了！

数组当前已成功获取元素个数为：0个；第1次尝试获取到的元素是：yuansu[1]=84
数组当前已成功获取元素个数为：1个；第2次尝试获取到的元素是：yuansu[2]=9
数组当前已成功获取元素个数为：2个；第3次尝试获取到的元素是：yuansu[3]=98
数组当前已成功获取元素个数为：3个；第4次尝试获取到的元素是：yuansu[4]=66
数组当前已成功获取元素个数为：4个；第5次尝试获取到的元素是：yuansu[5]=40
数组当前已成功获取元素个数为：5个；第6次尝试获取到的元素是：yuansu[6]=68
数组当前已成功获取元素个数为：6个；第7次尝试获取到的元素是：yuansu[7]=73
数组当前已成功获取元素个数为：7个；第8次尝试获取到的元素是：yuansu[8]=78
数组当前已成功获取元素个数为：8个；第9次尝试获取到的元素是：yuansu[9]=75
数组当前已成功获取元素个数为：9个；第10次尝试获取到的元素是：yuansu[10]=95
数组当前已成功获取元素个数为：10个；第11次尝试获取到的元素是：yuansu[11]=1
数组当前已成功获取元素个数为：11个；第12次尝试获取到的元素是：yuansu[12]=9
数组当前已成功获取元素个数为：11个；第13次尝试获取到的元素是：yuansu[13]=75
数组当前已成功获取元素个数为：11个；第14次尝试获取到的元素是：yuansu[14]=86
数组当前已成功获取元素个数为：12个；第15次尝试获取到的元素是：yuansu[15]=40
数组当前已成功获取元素个数为：12个；第16次尝试获取到的元素是：yuansu[16]=51
数组当前已成功获取元素个数为：13个；第17次尝试获取到的元素是：yuansu[17]=95
数组当前已成功获取元素个数为：13个；第18次尝试获取到的元素是：yuansu[18]=37
数组当前已成功获取元素个数为：14个；第19次尝试获取到的元素是：yuansu[19]=15
数组当前已成功获取元素个数为：15个；第20次尝试获取到的元素是：yuansu[20]=73
数组当前已成功获取元素个数为：15个；第21次尝试获取到的元素是：yuansu[21]=75
数组当前已成功获取元素个数为：15个；第22次尝试获取到的元素是：yuansu[22]=26
数组当前已成功获取元素个数为：16个；第23次尝试获取到的元素是：yuansu[23]=14
数组当前已成功获取元素个数为：17个；第24次尝试获取到的元素是：yuansu[24]=69
数组当前已成功获取元素个数为：18个；第25次尝试获取到的元素是：yuansu[25]=12
数组当前已成功获取元素个数为：19个；第26次尝试获取到的元素是：yuansu[26]=43

************以下为截止程序停止时所获取到的数组中的全部元素************
第1个元素是：84
第2个元素是：9
第3个元素是：98
第4个元素是：66
第5个元素是：40
第6个元素是：68
第7个元素是：73
第8个元素是：78
第9个元素是：75
第10个元素是：95
第11个元素是：1
第12个元素是：86
第13个元素是：51
第14个元素是：37
第15个元素是：15
第16个元素是：26
第17个元素是：14
第18个元素是：69
第19个元素是：12
第20个元素是：43

就是说如果某个元素重复了chongfu这个变量没被重置然后进入无限循环了

菠菜树 发表于 2015-2-12 11:02
问题我自己已经解决了，感觉自己不细心，然后就会做些逗比的事情
今天遇到的这个问题关键还是属于自己不够 ...

cishu这个变量都没声明，这能跑？

菠菜树 发表于 2015-2-12 11:02
问题我自己已经解决了，感觉自己不细心，然后就会做些逗比的事情
今天遇到的这个问题关键还是属于自己不够 ...

cishu这个变量都没声明，这能跑？

jie96169 发表于 2015-2-14 23:34
cishu这个变量都没声明，这能跑？

那是当时编辑了，处理后可能我回帖编辑混乱了，
可能是我开始就声明了一个cishu参数，当时每一步没将过程代码保存下来， 然后我编辑的时候也没有认真核对代码。。。

这么细节，我是真心服了！

张思语 发表于 2015-2-17 09:00
这么细节，我是真心服了！

自己菜鸟一只，啥都不会，所以注释啥的都很累赘。。。{:3_65:}

，，，，，，，

这名字起的。。