一个小程序，结果为1 ，求解释啊

1. public class LuckNumber
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 int[] arr = {1,2,3,4};
   
6. 
   
7.                 int pos = -1;
   
8. 
   
9.                 for(int x=0;x<arr.length-1; x++)
   
10.                 {
    
11.                         for(int y=0; y<3;y++)
    
12.                         {
    
13.                                 pos++;
    
14. 
    
15.                                 if(pos==arr.length)
    
16.                                         pos=0;
    
17.                                 while(arr[pos]==0)
    
18.                                 {
    
19.                                         pos++;
    
20.                                         if(pos==arr.length)
    
21.                                                 pos=0;
    
22.                                 }
    
23.                         }
    
24.                         arr[pos] = 0;
    
25.                         //System.out.println(arr[pos]);
    
26.                 }
    
27. 
    
28.                 for(int x=0; x<arr.length; x++)
    
29.                 {
    
30.                         if(arr[x]!=0)
    
31.                         {
    
32.                                 System.out.println(arr[x]);
    
33.                                 break;
    
34.                         }
    
35.                 }
    
36.         }
    
37. }
    
38. //结果为1

复制代码

这几天刚才完毕老师的 Day3 ，在此文中看到了 for的循环，即 (初始化，条件化，循环后的操作)，虽然不能解读全部，能模糊的看出一些。赶紧看视频自学吧，  慢慢你就都看懂了。

不知道你写这段程序的目的，想得到什么结果，就你的程序看，
前面的嵌套循环，没有任何输出结果，不知道写它的意义在哪，
你的结果之所以为1，是因为在最后的for循环中，判断arr[x]!=0,则输出arr[x]，并且用了break语句结束循环，
所以最终结果只输出了数组中的第一个元素arr[0]=1；

那个1应该是指的角标吧

yangruijing 发表于 2015-3-8 19:22
不知道你写这段程序的目的，想得到什么结果，就你的程序看，
前面的嵌套循环，没有任何输出结果，不知道写 ...

如果在数组后面再加个5，结果为4；再加个6，结果为1；再加个7，结果4；再加个8，结果7；求解释..你可以运行看看，这个是视频里的一个程序，以前没注意，今天怎么看都看不懂了

你可以通过eclipse里面的debug模式，看一下执行流程啊。

明白了，在for的嵌套循环里面，在内循环中pos的值不断的进行着变化，没内循环结束一次，都将数组中下标为pos所对应的元素的值改为0，而外训话控制着内循环的次数，为数组长度减1，所以所有循环结束后，数组中只有一个不为0的元素，只是所剩不为0元素的下标随着数组长度的变化而不同

yangruijing 发表于 2015-3-8 20:15
明白了，在for的嵌套循环里面，在内循环中pos的值不断的进行着变化，没内循环结束一次，都将数组中下标为po ...

我也是这么认为的，既然是这样，那么每次运行时，结果应该是数组中最后一个元素的值吧，可是结果一点规律没有，看不懂了

㏒假™面具 发表于 2015-3-8 20:11
你可以通过eclipse里面的debug模式，看一下执行流程啊。

谢了啊，我试试，这个dubug还不是很会用...:sleepy:

zfgrinm 发表于 2015-3-8 21:11
我也是这么认为的，既然是这样，那么每次运行时，结果应该是数组中最后一个元素的值吧，可是结果一点规律 ...

不一定，因为当内循环结束的时候，pos的值有可能等于arr.length()-1

这给绕晕了

yangruijing 发表于 2015-3-8 21:29
不一定，因为当内循环结束的时候，pos的值有可能等于arr.length()-1

一直都是最后一个元素的值吧，你说说还有什么可能，真没看出来啊..

pos是索引，搞清楚判断语句的条件，不难啊

/*
pos:2--->1...2...0...4
pos:1--->1...0...0...4
pos:3--->1...0...0...0       
用下面的代码打印得到上面的结果，虽然不知道程序想实现什么功能，但通过上面的打印结果便知道答案！！
*/
System.out.println("pos:"+pos+"--->"+arr[0]+"..."+arr[1]+"..."+arr[2]+"..."+arr[3]);

1. public class LuckNumber
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 int[] arr = {1,2,3,4};
   
6. 
   
7.                 int pos = -1;
   
8. 
   
9.                                 for(int x=0;x<arr.length-1; x++)
   
10.                 {
    
11.                         for(int y=0; y<3;y++)
    
12.                         {
    
13.                                 pos++;
    
14. 
    
15.                                 if(pos==arr.length)//当下标为越界指针归零
    
16.                                         pos=0;
    
17.                                 while(arr[pos]==0) //读取的元素是0时指针向右移动到不为零的元素处
    
18.                                 {
    
19.                                         pos++;
    
20.                                         if(pos==arr.length)
    
21.                                                 pos=0;
    
22.                                 }
    
23.                         }
    
24.                         arr[pos] = 0;
    
25.                                                
    
26.                                                 /*
    
27.                                                 pos:2--->1...2...0...4
    
28.                                                 pos:1--->1...0...0...4
    
29.                                                 pos:3--->1...0...0...0       
    
30.                                                 用下面的代码打印得到上面的结果，虽然不知道程序想实现什么功能，但通过上面的打印结果便知道答案！！
    
31.                                                 */
    
32.                         System.out.println("pos:"+pos+"--->"+arr[0]+"..."+arr[1]+"..."+arr[2]+"..."+arr[3]);
    
33.                 }
    
34. 
    
35.                 for(int x=0; x<arr.length; x++)
    
36.                 {
    
37.                         if(arr[x]!=0) //打印不为0的元素
    
38.                         {
    
39.                                 System.out.println(arr[x]);
    
40.                                 break;
    
41.                         }
    
42.                 }
    
43.         }
    
44. }
    
45. //结果为1

复制代码

ankje 发表于 2015-3-8 23:19
/*
pos:2--->1...2...0...4
pos:1--->1...0...0...4

看懂了，感谢啊，之前是内循环没循环完就跳出来了，我也是醉了..

public class LuckNumber {
          public static void main(String[] args)
      {
              int[] arr = {1,2,3,4};

              int pos = -1;

              for(int x=0;x<arr.length-1; x++)//0,1,2这是x3次循环的值
              {
                      for(int y=0; y<3;y++)//0,1,2这是y3次循环的 值
                      {
                              pos++;//pos=0,1,2;3,4/0,1;2/3,4/0,1/2/3    这里表示pos在循环中值的变化
                                                      //4/0表示pos值在下面的条件判断中发生变化，从4变成0
                              if(pos==arr.length)//避免pos越界
                                      pos=0;
                              while(arr[pos]==0)//判断pos位元素是否为0,为0则pos顺延一位
                              {
                                      pos++;
                                      if(pos==arr.length)
                                              pos=0;
                              }
                      }
                      arr[pos] = 0;//2,1,3这里是每次内层y循环3次之后POS出来的值
                      //System.out.println(arr[pos]);
              }

              for(int x=0; x<arr.length; x++)//0,1,2,3
              {
                      if(arr[x]!=0)
                      {
                              System.out.println(arr[x]);
                              break;//有没有这句话结果都一样，数组最后是[1,0,0,0]
                      }
              }
      }
}
以上注释就是我对这个程序的理解

加油！！！