java 方法实现数学黑洞

昨天老师留了一个作业，用java实现一个数学黑洞

main方法，实现数学黑洞验证。
* 提供任意一个非全部数位相同的4位数字，排列组合4位数字，用最大值-最小值，结果继续排列，并计算。最多7次，结果停止在6174。
* 如： 9875
* 9875 - 5789 = 4086
* 8640 - 0468 = 8172
* 8721 - 1278 = 7443
* 7443 - 3447 = 3996
* 9963 - 3699 = 6264
* 6642 - 2466 = 4176
* 7641 - 1467 = 6174

发现网上几篇文章都是一个一个计算每位数值

int g = (num / 1) % 10;　　　  //个位
*
* 　　int s = (num / 10) % 10;　　　//十位
*
* 　　int b = (num / 100) % 10;      //百位
*
* 　　int b = (num / 1000) % 10;    //千位   

于是

public class TestBlackHole {
    public static void main(String[] args) {
        /*返回的数值是一个四位不重复的数值*/
        int number = putNumber();
            /*使用arrayList存储每一位数据 因为可以使用 Arrays 工具类升序排序 */

        /*最小值*/
        int minNumber = MinNumber(number);
        /*最大值*/
        int maxNumber = MaxNumber(number);
        /*相减值*/
        int nextNumber = maxNumber-minNumber;
        /*计算次数*/
        int total=1;
        while (nextNumber!=6174){
            minNumber= MinNumber(nextNumber);
            maxNumber=MaxNumber(nextNumber);
            nextNumber=maxNumber-minNumber;
            System.out.println(maxNumber+"-"+minNumber+"=="+nextNumber);
            total+=1;
        }
        System.out.println("计算次数为"+total);
    }




        /*获取用户输入值*/
    /*
    *1 首先判断用户输入是否为四位数
    *2 其次把四个数依次赋值到map 集合中，由于map的特性 key值必须唯一，所有可以判断出该数是否有相同值
    *3  把符合要求的值返回给主方法
    *4 主方法调用 maxNumber 和 minNumber方法 计算出这个四位数的最大值和最小值
    *                        底层方法  最大值 Arrays 工具类升序排序
    *                                  最小值 Arrays 降序排序 必须使用Collections.reversOrder 不支持int double char 支持包装类
    * 5 返回结果相减得到下一次的值 遍历上述方法直到得到6174 结束循环，判断循环次数
    * */
    public static int putNumber(){

        /*获取系统输入值*/
        System.out.println("请输入四位不可重复的数");
        int num =new Scanner(System.in).nextInt();
        /*如果不是四位数就重新输入*/
        while (num/1000>=10){
            num=putNumber();
        }
        /*每位存储到hashMap 中和arrayList<>集合中*/
        HashMap<Integer,Integer> map = new HashMap<>();
        /*把个十百千分别存储在每个map */
        for (int i = 1; i <=4 ; i++) {
            int pow = (int) Math.pow(10, i );
        
            map.put(num/(pow/10)%10,num/(pow/10)%10);

        }
        /*
        * hashMap中key的值是唯一的，key 和 value 可以相同
        *  所以用key来判断是否有数值相同
        * */
        System.out.println("map长度"+map.size());
        if(map.size()<4){
            map.clear();
            num=putNumber();
        }
        return num;
    }




    /*得到最大值*/
    public static  int MaxNumber(int number){
        Integer[] num = new  Integer[4];

        for (int i = 1; i <=4 ; i++) {
            int pow = (int) Math.pow(10, i );
            num[i-1]=number/(pow/10)%10;
        }
       /*
       *  1 降序排序 Collections 不支持基本类型（int,double,char） 降序Arrays.sort(num, Collections.reverseOrder());
       *  2 然后循环四个数包装成最大值
       *  3 返回最大值
       *
       * */
        Arrays.sort(num, Collections.reverseOrder());
        int maxNumber=0;
        for (int i = 0; i <4 ; i++) {
            int pow = (int) Math.pow(10, i+1 );
            maxNumber += num[i]*1000/(pow/10);
        }
        return maxNumber;
    }






    /*得到最小值*/
    public static  int MinNumber(int number){
        int[] num = new  int[4];
        for (int i = 1; i <=4 ; i++) {
            int pow = (int) Math.pow(10, i );
            num[i-1]=number/(pow/10)%10;
        }

        /*
         *  1 升序排序 arrays.sort 默认升序
         *  2 然后循环四个数包装成最大值
         *  3 返回最大值
         *
         * */
        Arrays.sort(num);
        int minNumber=0;
        for (int i = 0; i <4 ; i++) {
            int pow = (int) Math.pow(10, i+1 );
            minNumber += num[i]*(1000/(pow/10));
        }
        return minNumber;
    }
}