题目：

有任意一个5位数，如：34256，
把它的各位数字打乱，重新排列，就可得到一个最大的数：65432，还有一个最小的数23456。
求这两个数字的差，得：41976，
然后把这个数字再次重复上述过程（如果不足5位，则前边补0）。
如此往复，数字会落入某个循环圈（称为数字黑洞）。
比如，刚才的数字会落入：[82962, 75933, 63954, 61974] 这个循环圈。


请编写程序，找到5位数所有可能的循环圈，并输出，每个循环圈占1行。
其中5位数全都相同则循环圈为 [0]，这个可以不考虑。循环圈的输出格式仿照：
[82962, 75933, 63954, 61974]
其中数字的先后顺序可以不考虑。

我不是要这道题的答案，因为已经通过其他方法解决了，但是在做这道题时，遇到了以下小小的问题，希望大神们认真看完，帮我解决我的疑惑！

以下只是对82962这个循环圈做测试：

1. [size=3]package ClassPackage;
   
2. 
   
3. 
   
4. import java.util.Iterator;
   
5. import java.util.TreeSet;
   
6. 
   
7. 
   
8. public class Test37 {
   
9.         public static void main(String args[])
   
10.         {
    
11.                 TreeSet<Integer> circle=null;;
    
12.                 int num=82962;
    
13. 
    
14.        
    
15.                         circle=new TreeSet<Integer>(new PrimaryOrder());       
    
16. 
    
17.                         //调用递归方法
    
18.                         circle=FoundCircle(num,circle);
    
19.                        
    
20.                          //输出循环圈
    
21.                         if(circle!=null){
    
22.                                 Iterator<Integer> iter=circle.iterator();
    
23.                                 System.out.print("[");
    
24.                                 while(iter.hasNext()){
    
25.                                         System.out.print(iter.next()+"  ");
    
26.                                 }
    
27.                                 System.out.print("]");
    
28.                         }
    
29. 
    
30.         }
    
31. 
    
32.        
    
33.         public static TreeSet<Integer> FoundCircle(int temp,TreeSet<Integer> circle){
    
34.        
    
35.                 System.out.print("添加::"+temp);
    
36.                 if(circle.add(temp)){        //诺传入的值还可添加到TreeSet集合，表示此时还未到循环尾
    
37.                         System.out.println("：：成功");
    
38.                        
    
39.                         //获得排序最大值
    
40.                         int max=0;
    
41.                         if(( max=sortNumMax(temp))==0) return null;
    
42.                         System.out.println("max::"+max);               
    
43.                        
    
44.                         //反转获得最小值，并计算差值
    
45.                         temp=max-Integer.parseInt(new StringBuffer(max+"").reverse().toString());//反转，即最大值减最小值
    
46.                        
    
47.                         //将差值继续递归
    
48.                         return circle=FoundCircle(temp,circle);
    
49.                 }else{
    
50.                         System.out.println("：：失败");
    
51.                         return circle;
    
52.                         }
    
53.         }
    
54.        
    
55.         //此方法只是将传入的数字组成最大值返回
    
56.         public static int sortNumMax(int n){
    
57.                 int num[] ={0,0,0,0,0};
    
58.                 int i=0;
    
59.                 //拆分
    
60.                 while(n%10!=0){               
    
61.                         num[i]=n%10;
    
62.                         i++;
    
63.                         n/=10;
    
64.                 }
    
65.                
    
66.                 if(num[0]-num[1]-num[2]-num[3]-num[4]==0) //如果5位数都相同 不考虑
    
67.                 {
    
68.                         return 0;
    
69.                 }
    
70.                
    
71.                 //排序
    
72.                 int temp=0;
    
73.                 for(int j=0;j<4;j++){
    
74.                         for(int k=j+1;k<5;k++){
    
75.                                 if(num[j]>num[k]){
    
76.                                         temp=num[j];
    
77.                                         num[j]=num[k];
    
78.                                         num[k]=temp;
    
79.                                 }
    
80.                         }
    
81.                 }
    
82.                        
    
83.                 return num[4]*10000+num[3]*1000+num[2]*100+num[1]*10+num[0];
    
84.         }
    
85. }
    
86. 
    
87. class PrimaryOrder implements Comparator<Object>   //排序种子文件，改变[/size][size=3]TreeSet[/size]的排序数序，[size=3]保持原来的顺序
    
88. {
    
89.         public int compare(Object o1,Object o2)
    
90.         {
    
91.                
    
92.                 Integer i1=(Integer)o1;
    
93.                 Integer i2=(Integer)o2;
    
94.                 if(i2.equals(i1))return 0;
    
95.                
    
96.                 return 1;
    
97.         }
    
98. }[/size]

复制代码

上面这组测试数据，运行后却在最后添加了一个重复数值，这里就纳闷了，为何这个值添加到集合当中去了：




究竟是哪里出了问题？

代码太多没看，改了下这个，好像没问题了,至于为什么我也不知道
Integer i1=(Integer)o1;
Integer i2=(Integer)o2;               
return i1.compareTo(i2);

谭荣强 发表于 2014-6-9 01:32
代码太多没看，改了下这个，好像没问题了,至于为什么我也不知道
Integer i1=(Integer)o1;
Integer i2=(Inte ...

的确何事了...

小歪 发表于 2014-6-9 16:31
的确何事了...

我写的比较方法为什么会出现这种情况呢？:Q