JAVA编程思想学习--JAVA标签语法与任意范围内吸血鬼数字与数值排序算法

类似于Goto
在嵌套循环中,可以在需要跳转的循环外添加标签,
语法提示:标签与循环体之间不得有其他语句,否则编译无法通过
例如

 public static void main(String[] args) {

        int z = 0;

        for (int i = 0; i < 10; i++) {

            label:
            for (int j = 0; j < 10; j++) {

                for (int k = 0; k < 10; k++) {

                    if (k > 6) {
                        continue label;
                    }
                    System.out.println(String.format("%d + %d + %d = %d", i, j, k, i + j + k));
                    z++;
                    if (z > 20) {
                        break label;
                    }
                }
            }
        }
    }

continue label;表示出循环到标签处,然后重头开始循环
break label;表示中断循环到标签处,不在执行循环

吸血鬼数字算法:
首先要解决排列组合问题,如何获得多个数字组成的所有排列:
使用如下方法
例如A, B, C, D四个数字
那么可以分解为:
A + (B, C, D)的全排列
B + (A, C, D)的全排列
C + (A, B, D)的全排列
D + (A, B, C)的全排列

然后(B, C, D)的全排列又可以分解为:
B + (C, D)的全排列
C + (B, D)的全排列
D + (B, C)的全排列

然后(C, D)的全排列又可以分解为:
C + (D)的全排列
D + (C)的全排列

我们知道单个数字的全排列即为其本身
所以这里我们可以看出来使用递归函数解决此问题最为简单
递归的终止条件:
开始进行排列的数字已经到达尾部
一下为实现代码

     /**
     * 对字符数组进行排列组合,打印出所有的组合情况
     * @param list      需要进行排列的字符数组
     * @param i         当前排列到第几位
     * @return
     */
    static void sortNumber(char[] list, int begin) {

        // 如果是已经到达最后一位, 则输出
        if (begin == list.length) {
            System.out.println(String.valueOf(list));
        }

        /*
         * 由当前位开始循环,将从当前为开始的每一个数字与首位互换位置,
         * 得到剩余数字的全排列,直到最后一位为止
         */
        for (int j = begin; j < list.length ; j++) {
            char c = list[begin];
            list[begin] = list[j];
            list[j] = c;
            sortNumber(list, begin + 1);
            c = list[begin];
            list[begin] = list[j];
            list[j] = c;
        }
    }

得到了多个数字所有排序结果之后,吸血鬼数字就比较好算了
1. 先判断某个数字的位数,为偶数向下执行
2. 然后获得该数字的所有排列组合(数字不重复)
3. 将每个排列组合切分为前后两段
4. 分别对两段进行排列组合
5. 将前后两段相乘判断是否与该数字相等,若一致,则输出
6. 重复步骤1至5即可计算任何数字是否为吸血鬼数字.

上述即为一种思路,实现简单,缺点是计算量大.

下面为整体实现
总方法:

    /**
     * 吸血鬼数字,位数为偶数位,将其包含的数字一分为2,然后组合为两个数的乘积等于该数
     * 以两个0结尾的数字不可
     * @param number      该数字是否为吸血鬼数字
     * @return            如果是,返回计算公式
     */
    static String suckBloodNumber(int number) {

        String str = String.valueOf(number);
        // 判断数字是否以两个0结尾
        if (!str.endsWith("00")) {

            // 首先判断数字是否为偶数位
            if (str.length() % 2 == 0) {

                // 然后获取所有的排序情况
                HashSet<String> set = new HashSet<String>(100);
                sortNumber(strToChars(str), 0, set);
                // 遍历排序情况,按需切割为两段
                  for (String numberStr : set) {
                    String result = suckNumberFZ(numberStr, number);
                    if (result == null) {
                        continue;
                    } else {
                        return result;
                    }
                }
            }
        }
        return null;
    }

辅助方法一:

     /**
     *  辅助方法,用于判断该数字是否能够满足吸血鬼数字的要求
     * @param numberStr     进行判断的数字的一种排列组合
     * @param result        进行判断的数字
     * @return  如果满足,返回公式,否则,返回null
     */
    static String suckNumberFZ(String numberStr, int result) {

         // 获得该数字的前后两段
        int strLength = numberStr.length() / 2;
        String firstStr = numberStr.substring(0, strLength);
        String endStr = numberStr.substring(strLength);

        Integer firstInt = Integer.valueOf(firstStr);
        Integer endInt = Integer.valueOf(endStr);

        if (result == endInt * firstInt) {
            return String.format("%d = %d * %d", result, firstInt, endInt);
        }

        return null;
    }

辅助方法二:

    /**
     * 将字符串转换为字符数组
     * @param str
     * @return
     */
    static char[] strToChars(String str) {

        char[] chars = new char[str.length()];
        str.getChars(0, str.length(), chars, 0);
        return chars;

    }