求数字黑洞

import java.util.Stack;

/**
 * 功能描述：任意一个5位数，比如：34256，把它的各位数字打乱，重新排列，可以得到一个最大的数：65432，
 * 一个最小的数23456。求这两个数字的差，得：41976，把这个数字再次重复上述过程（如果不足5位，则前边
 * 补0）。如此往复，数字会落入某个循环圈（称为数字黑洞）。比如，刚才的数字会落入：[82962, 75933,
 * 63954, 61974] 这个循环圈。请编写程序，找到5位数所有可能的循环圈，并输出，每个循环圈占1行。其中
 * 5位数全都相同则循环圈为 [0]，这个可以不考虑。循环圈的输出格式仿照：[82962, 75933, 63954, 61974]
 * 其中数字的先后顺序可以不考虑。此程序兼容任何整数
 * @author Administrator
 *
 */
public class NumBlackHole {
 private int baseNum;
 private int size;
 private Stack<String> hole;
 private Stack<String> relHole;
 /**
  * @param 程序入口处
  */
 public static void main(String[] args) {
  if(args.length<1){System.out.println("请输入要找出数字黑洞的数字");System.exit(0);}
  int number=0;
  try {
   number=Integer.parseInt(args[0]);
  } catch (NumberFormatException e) {
   System.out.println("请输入正确的整数！");
   System.exit(0);
   e.printStackTrace();
  }
  NumBlackHole num=new NumBlackHole(number);
  num.Com();
 }
 /**
  * 构造方法
  * @param baseNum
  */
 public NumBlackHole(int baseNum) {
  this.baseNum = baseNum;
  this.size=(this.baseNum+"").length();
  hole= new Stack<String>();relHole=new Stack<String>();
 }
 /**
  * 开始计算
  */
 public void Com(){
  String base=baseNum+"";
  deal(base,1);
  deal(hole.peek(),2);
  System.out.print("[");
  int length=relHole.size();
  for(int i=0;i<length;i++){
   System.out.print(relHole.pop());
   if(i<length-1)System.out.print(" ");
  }
  System.out.println("]");
 
  
 }
 /**
  * 处理数字校正后的字符串
  * @param s
  * @param flag
  */
 private void deal(String s,int flag){
  switch (flag) {
  case 1:
   if(hole.contains(s))return;
   hole.push(s);
   break;
  case 2:
   if(relHole.contains(s))return;
   relHole.push(s);
   break; 
  default:
   break;
  }
  
  int value=Compare(s);
  String s1=check(value);
  deal(s1,flag);
 }
 /**
  * 校正数字的位数
  * @param value
  * @return
  */
 private String check(int value) {
  String tp=value+"";
  int a=tp.length();
  for(int i=0;i<this.size-tp.length();i++){
   tp="0"+tp;
  }
  return tp;
 }
 /**
  * 重新排列，求差值
  * @param s
  * @return
  */
 private int Compare(String s){
  int max=NumberTool.getNumber(s,1);
  int min=NumberTool.getNumber(s,-1);
  return max-min;
 }
}
class NumberTool{
 /**
  * 获得该字符串各个字符组成的整数
  * @param num_str
  * @param flag -1 最小整数 1最大整数 默认最大整数
  * @return
  */
 public static int getNumber(String num_str,int flag){
  if(!checkStr(num_str)){
   NumberFormatException exc=new NumberFormatException();
   throw exc;
   }else{
   int tmp[]=new int[num_str.length()];
   for(int i=0;i<num_str.length();i++){
    tmp[i]=Integer.parseInt(num_str.charAt(i)+"");
   } 
   for(int i=0;i<tmp.length;i++){
    for(int j=tmp.length-1;j>i;j--){
     switch (flag) {
     case 1:
      if(tmp[i]>tmp[j]){
       int tp=tmp[i];
       tmp[i]=tmp[j];
       tmp[j]=tp;
      }
      break;
     case -1:
      if(tmp[i]<tmp[j]){
       int tp=tmp[i];
       tmp[i]=tmp[j];
       tmp[j]=tp;
      }
      break;
     default:
      if(tmp[i]>tmp[j]){
       int tp=tmp[i];
       tmp[i]=tmp[j];
       tmp[j]=tp;
      };
     }
     
    }
   }
   int rtn=0;
   for(int i=0;i<tmp.length;i++){
    rtn+=tmp[i]*Math.pow(10,i);
   }
   return rtn;
  }
 }
 /**
  * 检查字符串中是否有非数字的字符
  * @param s
  * @return
  */
 private static boolean checkStr(String s){
  try {
   Integer.parseInt(s);
   return true;
  } catch (NumberFormatException e) {
   System.out.println("字符串中含有非法字符");
   return false;
  }
 }
}