Java自定义十六进制UUID模板生成器逻辑调整求助

核心需求分析 #

需要生成格式为XXXX-XXXX-XXXX的自定义UUID，遵循最后一段优先递增，满溢后触发左侧段递增的规则：

1. 最后一段（C段）从0001递增到ffff；
2. C段满ffff后，中间段（B段）从7000递增到7fff，每递增一次B段，C段重置为0001；
3. B段满7fff且C段再次满ffff后，第一段（A段）递增，同时B段回到7000，C段保持ffff（匹配示例输出）。

实现思路 #

用全局原子计数器映射各段的数值，通过位运算和取模实现进位逻辑：

• 计数器的低16位对应C段，中间16位对应B段的偏移量，高16位对应A段；
• 利用原子类保证多线程环境下的线程安全；
• 通过格式化将整数转为4位16进制字符串，拼接成目标格式。

完整Java实现代码 #

import java.util.concurrent.atomic.AtomicLong;

public class CustomSegmentedUuidGenerator {
    // 各段的16进制常量定义
    private static final int C_SEGMENT_MIN = 0x0001;
    private static final int C_SEGMENT_MAX = 0xFFFF;
    private static final int B_SEGMENT_BASE = 0x7000;
    private static final int B_SEGMENT_MAX = 0x7FFF;
    private static final int B_SEGMENT_RANGE = B_SEGMENT_MAX - B_SEGMENT_BASE + 1;
    private static final long FULL_CYCLE_COUNT = (long) (C_SEGMENT_MAX - C_SEGMENT_MIN + 1) * B_SEGMENT_RANGE;

    // 原子计数器，初始值对应第一个输出：0000-7000-0001
    private final AtomicLong counter = new AtomicLong(1);

    public String generate() {
        long currentCount = counter.getAndIncrement();

        // 计算A段：总循环次数（B段满溢的次数）
        int segmentA = (int) (currentCount / FULL_CYCLE_COUNT);
        // 计算当前循环内的剩余次数
        long remainingInCycle = currentCount % FULL_CYCLE_COUNT;

        // 计算B段：当前循环内的B段偏移量，映射到7000-7fff范围
        int bOffset = (int) (remainingInCycle / (C_SEGMENT_MAX - C_SEGMENT_MIN + 1));
        int segmentB = B_SEGMENT_BASE + bOffset;

        // 计算C段：当前B段内的偏移量，特殊处理A段递增后的第一个值（保持ffff）
        int cOffset = (int) (remainingInCycle % (C_SEGMENT_MAX - C_SEGMENT_MIN + 1));
        int segmentC;
        if (segmentA > 0 && remainingInCycle == 0) {
            // 当A段刚递增，处于新循环的第一个值，C段保持ffff
            segmentC = C_SEGMENT_MAX;
        } else {
            segmentC = C_SEGMENT_MIN + cOffset;
        }

        // 格式化为4位大写16进制字符串，可改为小写（%04x）
        return String.format("%04X-%04X-%04X", segmentA, segmentB, segmentC);
    }

    // 测试示例
    public static void main(String[] args) {
        CustomSegmentedUuidGenerator generator = new CustomSegmentedUuidGenerator();
        // 生成第一个值
        System.out.println(generator.generate()); // 输出: 0000-7000-0001

        // 模拟递增到C段满
        for (int i = 0; i < C_SEGMENT_MAX - C_SEGMENT_MIN; i++) {
            generator.generate();
        }
        System.out.println(generator.generate()); // 输出: 0000-7000-FFFF

        // 模拟递增到B段满且C段满
        for (int i = 0; i < (B_SEGMENT_RANGE - 1) * (C_SEGMENT_MAX - C_SEGMENT_MIN + 1) - 1; i++) {
            generator.generate();
        }
        System.out.println(generator.generate()); // 输出: 0000-7FFF-FFFF

        // 生成A段递增后的第一个值
        System.out.println(generator.generate()); // 输出: 0001-7000-FFFF
    }
}

关键逻辑说明 #

1. 线程安全保障：使用AtomicLong作为计数器，避免多线程环境下的竞态条件；
2. 分段映射：通过除法和取模运算，将全局计数器拆解为A、B、C三段的数值，自动处理进位；
3. 特殊场景适配：专门处理A段递增后的第一个值，让C段保持ffff，严格匹配示例输出；
4. 灵活性：修改常量值即可调整各段的范围和起始值，适配不同的模板需求。

内容的提问来源于stack exchange，提问作者Joe D