Java数据库树型层级存储结构特殊的应用场景比parentId更好用

• 数据库存储结构A000B000C000D001E002
• 需要存储当前层级的字母（比如E），所属层级全路径如（A000B000C000D001E002）
• 每个跟节点的最大叶子节点大小取决于字母后的数值大小num
• 满树的最大值：树深度m，最大值= numᵐ+1
• 优点
  • 随时查询每个层级的数据，不需要像以往根据parentId逐层查询

效果如图：

/**
 * 多叉树 的形式记录上下级
 * @param args
 */
public static void main(String[] args) {
    /**
     *  如果是3位数字，每个层级节点最多有1000个叶子节点
     *                                                  A000
     *             AB000                    AB001                          ···      AB999
     * AB000C000  AB000C0001            AB001C000       AB001C001            AB999C000      ···ABC999
     */
    // 获取下一个英文字母
    String hierarchy = getNextUpEn("AAZ");
    System.out.println(hierarchy);
    String result = autoGenericCode(1,3);
    System.out.println(result);
    System.out.println(hierarchy + result);
    List<String> list = new ArrayList<>();

    getHierarchyList(list,"A000B000C000D001E002");
    // 反转list 从顶级开始递增
    Collections.reverse(list);
    System.out.println(JSONObject.toJSONString(list));
}

输出结果

ABA
001
ABA001
["A000","A000B000","A000B000C000","A000B000C000D001"]

/**
 * 获取下一个大写的英文字母 AAA->AAB,AAZ->ABA,ZZZ->AAAA
 * @param en 英文字母
 * @return {@link String}
 */
public static String getNextUpEn(String en){
    if(en == null || en.equals("")){
        return "A";
    }
    if(en.length() == 1) {
        // 如果是Z增位从AA开始
        if(en.equals("Z")) {
            return "AA";
        }
        char lastE = 'Z';
        // char 转 int ASCII码中大写Z十进制是90，而int是十进制
        int lastEnglish = (int)lastE;
        char[] c = en.toCharArray();
        // 只处理单个值
        if(c.length > 1){
            return null;
        }else{
            // 当前值的大小
            int now = (int)c[0];
            // 与Z的ASCII值比较
            if(now >= lastEnglish){
                return null;
            }
            // ASCII中大写A～Z的值是递增的，所以+1转成字符串就是下一个字母的值
            char uppercase = (char)(now+1);
            return String.valueOf(uppercase);
        }
    }else if(en.length() > 1) {
        // 长度大于1 采用递归的方式计算上一位

        // 获取最后一位之前的值
        String first = en.substring(0, en.length()-1);
        // 最后一位的值
        String second = en.substring(en.length()-1, en.length());
        // 如果最后一位是Z则前面的字符串递归计算
        if(second.equals("Z")) {
            // 最后一个值是Z的时候 递归计算前面的值
            first = getNextUpEn(first);
            // 返回结果
            return first + 'A';
        }else {
            // 返回结果
            return first + getNextUpEn(second);
        }
    }else {
        return null;
    }
}
/**
 * 不够位数的在前面补0，保留num的长度位数字
 * @param code
 * @return
 */
private static String autoGenericCode(int code, int num) {
    String result = "";
    // 保留num的位数
    // 0 代表前面补充0
    // num 代表长度为4
    // d 代表参数为正数型
    result = String.format("%0" + num + "d", code);
    return result;
}
/**
 * 获取层级list
 * @param list list
 * @param hierarchyStr 层级字符串
 */
private static void getHierarchyList(List<String> list, String hierarchyStr) {

    Pattern pattern = Pattern.compile("([a-z|A-Z]*)(\\d)*$");
    Matcher matcher = pattern.matcher(hierarchyStr);
    if (matcher.find()) {
        // 最有一个匹配的值
        String last = matcher.group(0);

        // 最后出现的位置
        int lastPosition = hierarchyStr.lastIndexOf(last);
        hierarchyStr = hierarchyStr.substring(0, lastPosition);
        // 不为空 则继续递归
        if(StringUtils.isNotBlank(hierarchyStr)){
            list.add(hierarchyStr);
            getHierarchyList(list,hierarchyStr);
        }
    }
}