数据库表设计五层分类系统表设计
首先表中有一个15位的编号如下：
| 层级 | 索引 | 示例编号 | 处理后长度 | 计算过程 | 结果 |
|---|---|---|---|---|---|
| 1 | 0 | 100000000000000 | 3 | 3/3-1=0 | 0 |
| 2 | 1 | 100001000000000 | 6 | 6/3-1=1 | 1 |
| 3 | 2 | 100001001000000 | 9 | 9/3-1=2 | 2 |
| 4 | 3 | 100001001001000 | 12 | 12/3-1=3 | 3 |
| 5 | 4 | 100001001001001 | 15 | 15/3-1=4 | 4 |
处理工具类：
/**
* @ClassName NoProcessing.java
* @Description 编号创建类
*/
public class NoProcessing {
public static void main(String[] args) {
// String input = "100001009001001";
// String processedString = createNo(input,true);
// System.out.println(processedString);
String sonNo = "100001001001000";
String parentNo = "100001001000000";
System.out.println(isParent(parentNo,sonNo));
}
/***
* @description 处理补全编号，所有编号都是15位，共5层，每层关系如下：
* 第一层：100000000000000
* 第二层：100001000000000
* 第三层：100001001000000
* 第四层：100001001001000
* 第五层：100001001001001
* 处理后100000000000000后结果为100
* @param input
* @return: java.lang.String
*/
public static String processString(String input) {
int step = input.length() / 3;
for (int i =0;i<step;i++ ){
String targetString = input.substring(input.length()-3,input.length());
if ("000".equals(targetString)){
input = input.substring(0,input.length()-3);
}else {
break;
}
}
return input;
}
/***
* @description 生产层级编号
* @param input 输入编号
* @param peerNode 是否有下属节点
* @return
* @return: java.lang.String
*/
public static String createNo(String input,boolean peerNode) {
int step = input.length() / 3;
int supplement = 0;
for (int i =0;i<step;i++ ){
String targetString = input.substring(input.length()-3,input.length());
if ("000".equals(targetString)){
input = input.substring(0,input.length()-3);
supplement++;
}else {
break;
}
}
if (peerNode){
input = String.valueOf(Long.valueOf(input) + 1L);
for (int i =0;i<supplement;i++ ){
input = input+"000";
}
}else {
input = String.valueOf(Long.valueOf(input+"001"));
for (int i =0;i<supplement-1;i++ ){
input = input+"000";
}
}
return input;
}
/***
* @description 是否是其子类
*
* @param parentNo 父编号
* @param sonNo 子编号
* @return
* @return: java.lang.Boolean
*/
public static Boolean isParent(String parentNo,String sonNo) {
parentNo = processString(parentNo);
return sonNo.startsWith(parentNo);
}
}
代码思路详解
这个类是一个编号处理工具类，主要用于处理15位长度的层级编号系统。下面我将详细解析每个方法和类的整体功能。
类概述
NoProcessing 类提供以下主要功能：
处理层级编号字符串
创建新的层级编号
判断父子编号关系
核心方法详解
1. processString(String input) 方法
功能：去除编号末尾连续的"000"部分，提取有效编号。
处理逻辑：
计算编号的步长（总长度/3）
- 因为编号是15位，每层用3位表示，所以
step=5
- 因为编号是15位，每层用3位表示，所以
从末尾开始检查每3位一组：
如果是"000"则去除
遇到非"000"则停止
返回处理后的字符串
示例：
java
复制
输入 “100001001000000” → 处理过程：
- 检查最后3位"000" → 去除 → “100001001000”
- 检查新的最后3位"000" → 去除 → “100001001”
- 检查"001" → 不是"000" → 停止
返回 “100001001”
使用场景：获取编号的有效部分，去除末尾的占位"000"
2. createNo(String input, boolean peerNode) 方法
功能：根据现有编号创建新的层级编号。
参数：
input：基础编号peerNode：是否创建同级节点(true)还是子级节点(false)
处理逻辑：
先像
processString一样去除末尾的"000"根据
peerNode参数决定如何生成新编号：同级节点(peerNode=true)：当前数字+1，然后补回去除的"000"
子级节点(peerNode=false)：当前数字末尾+“001”，然后补回(去除的"000"数量-1)
示例：
java
复制
// 创建同级节点
createNo(“100001001000000”, true) →
- 处理得到"100001001"
- 100001001 + 1 = 100001002
- 补回2组"000" → “100001002000000”
// 创建子级节点
createNo(“100001001000000”, false) →
- 处理得到"100001001"
- 添加"001" → “100001001001”
- 补回1组"000" → “100001001001000”
3. isParent(String parentNo, String sonNo) 方法
功能：判断一个编号是否是另一个编号的父级。
处理逻辑：
先处理父编号去除末尾"000"
检查子编号是否以处理后的父编号开头
示例：
java
复制
isParent(“100001000000000”, “100001001000000”) →
- 处理父编号 → “100001”
- 检查子编号是否以"100001"开头 → true
编号系统设计
从代码可以看出这是一个5层15位的编号系统：
每层用3位数字表示
层级关系通过数字前缀表示
"000"表示该层级无具体值
编号示例：
复制
第一层：100000000000000 → “100”…
第二层：100001000000000 → “100”+“001”…
第三层：100001001000000 → “100”+“001”+“001”…
第四层：100001001001000 → “100”+“001”+“001”+“001”…
第五层：100001001001001 → “100”+“001”+“001”+“001”+“001”
使用场景推测
这类编号系统常用于：
商品分类体系
组织架构编码
地区编码
任何需要多层级表示的编码系统
代码特点
防御性处理：方法都考虑了字符串操作的安全问题
数值处理：使用Long处理大数字
层级清晰：严格的3位一组表示层级
灵活性：支持同级和子级节点创建
可能的使用示例
java
复制
// 1. 处理现有编号
String processed = NoProcessing.processString(“100001001000000”); // 返回"100001001"
// 2. 创建子分类编号
String newChild = NoProcessing.createNo(“100001000000000”, false); // 返回"100001001000000"
// 3. 检查分类关系
boolean isParent = NoProcessing.isParent(“100000000000000”, “100001000000000”); // 返回true
这个工具类为层级编号系统提供了完整的创建、处理和验证功能。
NoProcessing.processString(n.getCategoryNo()).length()/3-1))
修改
NoProcessing.processString(n.getCategoryNo()).length()/3-1 详细解析
这段代码是用来计算分类编号的层级深度，下面我将详细解释它的每个部分和整体功能。
代码分解
这个类是一个编号处理工具类，主要用于处理15位长度的层级编号系统。下面我将详细解析每个方法和类的整体功能。
类概述
NoProcessing 类提供以下主要功能：
处理层级编号字符串
创建新的层级编号
判断父子编号关系
核心方法详解
1. processString(String input) 方法
功能：去除编号末尾连续的"000"部分，提取有效编号。
处理逻辑：
计算编号的步长（总长度/3）
- 因为编号是15位，每层用3位表示，所以
step=5
- 因为编号是15位，每层用3位表示，所以
从末尾开始检查每3位一组：
如果是"000"则去除
遇到非"000"则停止
返回处理后的字符串
示例：
java
复制
输入 “100001001000000” → 处理过程：
- 检查最后3位"000" → 去除 → “100001001000”
- 检查新的最后3位"000" → 去除 → “100001001”
- 检查"001" → 不是"000" → 停止
返回 “100001001”
使用场景：获取编号的有效部分，去除末尾的占位"000"
2. createNo(String input, boolean peerNode) 方法
功能：根据现有编号创建新的层级编号。
参数：
input：基础编号peerNode：是否创建同级节点(true)还是子级节点(false)
处理逻辑：
先像
processString一样去除末尾的"000"根据
peerNode参数决定如何生成新编号：同级节点(peerNode=true)：当前数字+1，然后补回去除的"000"
子级节点(peerNode=false)：当前数字末尾+“001”，然后补回(去除的"000"数量-1)
示例：
java
复制
// 创建同级节点
createNo(“100001001000000”, true) →
- 处理得到"100001001"
- 100001001 + 1 = 100001002
- 补回2组"000" → “100001002000000”
// 创建子级节点
createNo(“100001001000000”, false) →
- 处理得到"100001001"
- 添加"001" → “100001001001”
- 补回1组"000" → “100001001001000”
3. isParent(String parentNo, String sonNo) 方法
功能：判断一个编号是否是另一个编号的父级。
处理逻辑：
先处理父编号去除末尾"000"
检查子编号是否以处理后的父编号开头
示例：
java
复制
isParent(“100001000000000”, “100001001000000”) →
- 处理父编号 → “100001”
- 检查子编号是否以"100001"开头 → true
编号系统设计
从代码可以看出这是一个5层15位的编号系统：
每层用3位数字表示
层级关系通过数字前缀表示
"000"表示该层级无具体值
编号示例：
复制
第一层：100000000000000 → “100”…
第二层：100001000000000 → “100”+“001”…
第三层：100001001000000 → “100”+“001”+“001”…
第四层：100001001001000 → “100”+“001”+“001”+“001”…
第五层：100001001001001 → “100”+“001”+“001”+“001”+“001”
使用场景推测
这类编号系统常用于：
商品分类体系
组织架构编码
地区编码
任何需要多层级表示的编码系统
代码特点
防御性处理：方法都考虑了字符串操作的安全问题
数值处理：使用Long处理大数字
层级清晰：严格的3位一组表示层级
灵活性：支持同级和子级节点创建