com.yixan.tools.common.util.CodeUtil Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of yixan-tools-common Show documentation
There is a newer version: 3.7.1
package com.yixan.tools.common.util;

import java.util.ArrayList;
import java.util.List;

/**
 * 编号处理工具类

 * 用于维护每段固定长度,下级前缀等于上级的上下级编号, 便于like查询
 *
 * @author zhaohuihua
 * @version V1.0 2017年8月2日
 */
public class CodeUtil {

    /** start 开始位置(前缀长度) */
    private int start;
    /** 每一段的长度 **/
    private int length;

    public CodeUtil(int start, int length) {
        this.start = start;
        this.length = length;
    }

    /** 拆分编号 **/
    public List split(String code, boolean self) {
        return split(code, start, length, self);
    }

    /** 获取编号的级数 **/
    public int level(String code) {
        return level(code, start, length);
    }

    /** 获取顶级编号 **/
    public String top(String code) {
        return top(code, start, length);
    }

    /** 获取上级编号 **/
    public String parent(String code) {
        return parent(code, length);
    }

    /** 获取前缀编号 **/
    public String prefix(String code) {
        return prefix(code, start, length);
    }

    /**
     * 拆分编号

     * 如split("500100220033", 4, true) --> [5001, 50010022, 500100220033]

     * 如果长度不能整除, 多余的部分都给第一级

     * 如split("8500100220033", 4, true) --> [85001, 850010022, 8500100220033]

     * 
     * @param code 编号
     * @param length 每一段的长度
     * @param self 结果集是否包含编号本身
     * @return
     */
    public static List split(String code, int length, boolean self) {
        return split(code, 0, length, self);
    }

    /**
     * 拆分编号

     * 如split("500100220033", 4, true) --> [5001, 50010022, 500100220033]

     * 如split("500100220033", 4, 4, true) --> [50010022, 500100220033]

     * 如果长度不能整除, 多余的部分都给第一级

     * 如split("8500100220033", 4, true) --> [85001, 850010022, 8500100220033]

     * 如split("8500100220033", 4, 4, true) --> [850010022, 8500100220033]

     * 
     * @param code 编号
     * @param start 开始位置
     * @param length 每一段的长度
     * @param self 结果集是否包含编号本身
     * @return
     */
    public static List split(String code, int start, int length, boolean self) {
        List list = new ArrayList<>();
        if (code.length() <= start) {
            return list;
        }

        int m = code.length() % length; // 除不尽的都分给第一级
        for (int i = start + m + length; i < code.length(); i += length) {
            list.add(code.substring(0, i));
        }
        if (self) {
            list.add(code);
        }
        return list;
    }

    /** 获取编号的级数 **/
    public static int level(String code, int length) {
        return split(code, 0, length, true).size();
    }

    /** 获取编号的级数 **/
    public static int level(String code, int start, int length) {
        return split(code, start, length, true).size();
    }

    /**
     * 获取顶级编号

     * 如top("500100220033", 4) --> 5001

     * 如果长度不能整除, 多余的部分都给第一级

     * 如top("8500100220033", 4) --> 85001

     * 
     * @param code 编号
     * @param length 每一段的长度
     * @return 顶级编号
     */
    public static String top(String code, int length) {
        return top(code, 0, length);
    }

    /**
     * 获取上级编号

     * 如parent("500100220033", 4) --> 50010022

     * 如果长度不能整除, 多余的部分都给第一级

     * 如parent("8500100220033", 4) --> 850010022

     * 
     * @param code 编号
     * @param length 每一段的长度
     * @return 上级编号
     */
    public static String parent(String code, int length) {
        if (code.length() < length * 2) { // 只有一级
            return null;
        }
        return code.substring(0, code.length() - length);
    }

    /**
     * 获取顶级编号

     * 如top("500100220033", 4) --> 5001

     * 如top("500100220033", 4, 4) --> 50010022

     * 如果长度不能整除, 多余的部分都给第一级

     * 如top("8500100220033", 4) --> 85001

     * 如top("8500100220033", 4, 4) --> 850010022

     * 
     * @param code 编号
     * @param start 开始位置(前缀长度)
     * @param length 每一段的长度
     * @return 顶级编号
     */
    public static String top(String code, int start, int length) {
        if (code.length() < length * 2) { // 只有一级
            return code;
        }
        int m = code.length() % length; // 除不尽的都分给第一级
        return code.substring(0, start + m + length);
    }

    /**
     * 获取前缀编号

     * 如prefix("500100220033", 4, 4) --> 5001

     * 如果长度不能整除, 多余的部分都给第一级

     * 如prefix("8500100220033", 4, 4) --> 85001

     * 如果start=0, 返回null
     * 
     * @param code 编号
     * @param start 开始位置(前缀长度)
     * @param length 每一段的长度
     * @return 前缀编号
     */
    public static String prefix(String code, int start, int length) {
        if (start == 0) {
            return null;
        } else if (code.length() <= start) {
            return code;
        }
        int m = code.length() % length; // 除不尽的都分给第一级
        return code.substring(0, m + start);
    }
}