这个是下载的毕老师的课件源代码里的东西，但是视频里没有讲到，求大神给讲解一下
class LuckNumber
{
        public static void main(String[] args)
        {
                int[] arr = {1,2,3,4,5,6,7,8};

                int pos = -1;

                for(int x=0;x<arr.length-1; x++)
                {
                        for(int y=0; y<3;y++)
                        {
                                pos++;

                                if(pos==arr.length)
                                        pos=0;
                                while(arr[pos]==0)
                                {
                                        pos++;
                                        if(pos==arr.length)
                                                pos=0;
                                }
                        }
                        arr[pos] = 0;
                        //System.out.println(arr[pos]);
                }

                for(int x=0; x<arr.length; x++)
                {
                        if(arr[x]!=0)
                        {
                                System.out.println(arr[x]);
                                break;
                        }
                }
        }
}

我说下我的看法：
数组｛1，2，3，4，5，6，7，8｝；
当x=0，数组变成：｛1，2，0，4，5，6，7，8｝；
当x=1，数组变成：｛1，2，0，4，5，0，7，8｝；
当x=2，数组变成：｛0，2，0，4，5，0，7，8｝；
当x=3，数组编程：｛0，2，0，4，0，0，7，8｝；
当x=4，数组编程：｛0，0，0，4，0，0，7，8｝；
当x=5，数组编程：｛0，0，0，4，0，0，7，0｝；
当x=6，数组编程：｛0，0，0，0，0，0，7，0｝；
从上面的这个规律可以看出，每经过2个数字，第三个数字都会变成0，而且如果原数组中有0，则该数字直接跳过，经过6次,最后的得到的是数组中第6个元素的值.

看的头晕

进来水一下，表介意。

1. class Demo//LuckNumber
   
2. {
   
3.          public static void main(String[] args)
   
4.          {
   
5.                 int[] arr = {1,2,3,4,5,6,7,8};
   
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++)//循环3次。
    
12.                          {
    
13.                                  pos++;//指针后移3位
    
14. 
    
15.                                 if(pos==arr.length)//循环完，指针回到第一个数组位置。
    
16.                                          pos=0;
    
17.                                  while(arr[pos]==0)//在数组中找到 0 ，执行循环。
    
18.                                  {
    
19.                                          pos++;//指针下移，指向 0 后面的数字。
    
20.                                          if(pos==arr.length)//循环完，指针回到第一个数组位置。
    
21.                                                  pos=0;
    
22.                                  }
    
23.                          }//每经过3个数查看一次，自动跳过数字 0 。
    
24.                          //System.out.print(arr[pos]);
    
25.                          arr[pos] = 0;//经过三个数字后，后面的数字 置 0 。
    
26.                  }
    
27. 
    
28.                 for(int x=0; x<arr.length; x++)//遍历数组
    
29.                  {
    
30.                          if(arr[x]!=0)//数组中数字不为0时，输出。
    
31.                          {
    
32.                                  System.out.println(arr[x]);
    
33.                                  break;//输出第一个不为 0 的数字。
    
34.                          }
    
35.                  }
    
36.          }
    
37. }

复制代码

当 x = 0 时，结果为 7；
当 x = 1 时，结果为 4；
当 x = 2 时，结果为 4；
当 x = 3 时，结果为 2；
当 x = 4 时，结果为 2；
当 x = 5 时，结果为 1；
当 x = 6 时，结果为 1；
当 x = 7 时，结果为 1；

这就是幸运数字。

李春丽 发表于 2014-9-15 22:59
当 x = 0 时，结果为 7；
当 x = 1 时，结果为 4；
当 x = 2 时，结果为 4；

是啊，你解释的我基本上看明白了，能否给说一下这个题目的思路怎么回事吗？

加一下备注，便于阅读！！