每年年底，朋友圈总会被各种“明年犯太岁生肖”刷屏。评论区里，满是“我属X，明年要完了”“求化解太岁方法”的焦虑留言。

但你是否想过：

太岁到底是什么？
犯太岁就一定倒霉吗？
那些昂贵的“化解仪式”真的有必要吗？

其实，太岁并非凶神，而是传统文化中的“年度值勤神”，理解其规则，便能知其然，更知其所以然。下面我们从文化起源、推算逻辑，再到代码实现，为你完整拆解。

太岁是什么？

很多人一听到“太岁”就害怕，觉得是专门来克自己的凶神，其实大错特错。
本质：是中国传统文化里“掌管一年吉凶祸福的值班神仙”，就像公司里的年度值班经理，负责统筹当年所有人的运势走向。
核心逻辑：你的生肖（地支）如果和当年太岁的“值班经理”关系和谐，则易得助力；如果关系冲撞（即“犯太岁”），则可能面临更多挑战与变动。
简单说：太岁 = 当年运势的“总调度”。配合规则，顺势而为；逆反规则，易生波折。

一、太岁的起源：天文与历法的结合

太岁概念源于古代天文学对木星（岁星）的观测，经历了三个关键演变阶段：

岁星纪年：古人发现木星约 12 年绕天一周，将黄道分为十二等分（十二地支），木星每年位于一个特定宫位，以此纪年
太岁假设：因木星运行方向（自西向东）与十二地支排列方向（自东向西）相反，为方便纪年，古人**虚构一个与木星反向运行的 “假岁星”**，命名为 “太岁”，又称 “岁阴”、”太阴”
神灵化：道教吸收这一概念，将太岁人格化为六十位值年太岁星君，每一年对应一位，轮流掌管人间祸福

简单说：太岁=当年运势的“总负责人”，你的生肖、方位如果和这位“负责人”犯冲，当年运势就容易波动；配合得好，反而能借势提升

二、核心逻辑

太岁的判断核心是干支纪年法，这是中国古代独特的历法系统，也是看太岁的根本依据：

1、干支组合规则

天干：甲、乙、丙、丁、戊、己、庚、辛、壬、癸（10 个）
地支：子、丑、寅、卯、辰、巳、午、未、申、酉、戌、亥（12 个，对应十二生肖）
组合方式：天干在前，地支在后，依次配对，形成六十个唯一组合（如甲子、乙丑… 癸亥），称为 “六十甲子”，六十年一轮回

2、干支与公元年换算

要确定某一年的太岁，首先需将公元年转换为干支年，公式如下：

天干计算：(公元年 - 3) ÷ 10 余数对应天干（0 = 癸，1 = 甲，2 = 乙…9 = 壬）
地支计算：(公元年 - 3) ÷ 12 余数对应地支（0 = 亥，1 = 子，2 = 丑…11 = 戌）
举个例子：2026年
- 天干：（2026-3）÷10=202余3 → 对应“丙”；
- 地支：（2026-3）÷12=168余7 → 对应“午”；
- 组合结果：天干+地支即为流年太岁干支：丙午

补充说明：公式中“减3”的核心逻辑是对齐干支纪年与公元纪年的起始节点，确保换算结果与传统典籍记载一致，适用于公元后所有年份。

小提示：手机日历切换到农历，就能看到当年的干支（比如2026年农历是丙午年，“丙午”就是2026年的太岁干支）

3、六十值年太岁神完整名录

六十值年太岁神与六十甲子一一对应，六十年为一轮回周期，每位太岁神执掌当年吉凶祸福，其名录源于道教经典与历代传承，具体对应关系如下表所示：

甲子年	太岁名称	历史时期	核心特质
甲子	金辨大将军	明代	公正明辨
乙丑	陈材大将军	宋代	勇武刚毅
丙寅	耿章大将军	明代	刚正守节
丁卯	沈兴大将军	明代	建设守护
戊辰	赵达大将军	三国	智慧预知
己巳	郭灿大将军	明代	清廉果敢
庚午	王济大将军	宋代	博学仁爱
辛未	李素大将军	唐代	执法公正
壬申	刘旺大将军	明代	戍边卫国
癸酉	康志大将军	唐代	英勇善战
甲戌	施广大将军	明代	勤政为民
乙亥	任保大将军	明代	清廉爱民
丙子	郭嘉大将军	元代	抗灾安民
丁丑	汪文大将军	宋代	地理智慧
戊寅	鲁先大将军	明代	文武双全
己卯	龙仲大将军	宋代	惩恶扬善
庚辰	董德大将军	宋代	慈善助学
辛巳	郑但大将军	汉代	文德兼备
壬午	陆明大将军	明代	保家卫国
癸未	魏仁大将军	明代	直言敢谏
甲申	方杰大将军	宋代	兴教重学
乙酉	蒋崇大将军	元代	公平正义
丙戌	白敏大将军	明代	轻徭薄赋
丁亥	封济大将军	汉代	平乱安邦
戊子	邹铛大将军	明代	便民利民
己丑	傅佑大将军	汉代	司法公正
庚寅	邬桓大将军	元代	公益奉献
辛卯	范宁大将军	东晋	儒学教化
壬辰	彭泰大将军	明代	清廉自守
癸巳	徐单大将军	汉代	稳定边疆
甲午	章词大将军	明代	治水安民
乙未	杨仙大将军	宋代	玄学智慧
丙申	管仲大将军	春秋	治国安邦
丁酉	唐杰大将军	唐代	勇武平叛
戊戌	姜武大将军	明代	戍边卫国
己亥	谢太大将军	明代	司法公正
庚子	卢秘大将军	明代	教育兴邦
辛丑	杨信大将军	汉代	忠诚使命
壬寅	贺谔大将军	元代	水利兴农
癸卯	皮时大将军	北魏	忠诚职守
甲辰	李诚大将军	明代	博学多能
乙巳	吴遂大将军	汉代	灭灾保农
丙午	文哲大将军	明代	刚正守节
丁未	缪丙大将军	汉代	孝悌楷模
戊申	徐浩大将军	唐代	才德兼备
己酉	程宝大将军	唐代	平定安民
庚戌	倪秘大将军	明代	兴学惠民
辛亥	叶坚大将军	明代	勇武守城
壬子	丘德大将军	明代	平乱复序
癸丑	朱得大将军	明代	治河防灾
甲寅	张朝大将军	明代	城防建设
乙卯	万清大将军	元代	清廉亲民
丙辰	辛亚大将军	唐代	御外安边
丁巳	杨彦大将军	宋代	军事才能
戊午	黎卿大将军	明代	水利农业
己未	傅党大将军	明代	平乱安民
庚申	毛梓大将军	元代	医者仁心
辛酉	石政大将军	元代	司法公正
壬戌	洪充大将军	明代	义学慈善
癸亥	虞程大将军	明代	勤政尽职

三、太岁关系计算

民俗语境中的“犯太岁”，并非笼统的“倒霉预警”，而是指个人生肖（对应地支）与当年太岁地支形成了五种不利关系之一。与之相对，还有“合太岁”的吉象，可缓解不利影响。具体关系及解读如下：

关系	俗称	核心影响	判断逻辑（以2026丙午年为例）
值太岁	本命年	伏吟叠加，易有内耗、决策反复，本质是自我认知与外界期待的博弈期	生肖属马（午）
冲太岁	六冲	正面冲击，易有变动（如换工作、搬家）、人际冲突，是环境调整的关键期	生肖属鼠（子午冲）
刑太岁	相刑	暗中消耗，易有是非纠纷、健康隐患，是细节管理的重要期	生肖属马（午午自刑）
害太岁	六害	相互干扰，易犯小人、好事多磨，是人际关系的优化期	生肖属牛（丑午害）
破太岁	相破	轻微破损，易有计划落空、小范围损失，是风险规避的提醒期	生肖属兔（卯午破）
合太岁	六合/三合	助力加持，易获贵人相助、机会增多，是借力发展的黄金期	属羊（午未六合）、属虎/狗（寅午戌三合）

1、值太岁（本命年）

定义：生肖与当年太岁相同。如同与领导直接同位，压力与关注并存。建议多倾听他人意见，避免冲动决策。
示例：2026年（丙午），所有属马的人为值太岁。

2、冲太岁（六冲）

定义：生肖与太岁相冲。如同与领导正面冲突，变动最大。
六冲组合：子午冲、丑未冲、寅申冲、卯酉冲、辰戌冲、巳亥冲。
示例：2026年太岁为午，冲子，故属鼠的人冲太岁

3、刑太岁（相刑）

定义：生肖与太岁相刑。关系微妙紧张，易有暗中损耗。
主要类型：
- 无恩之刑：寅、巳、申（三者间任意两字相见即刑）。
- 恃势之刑：丑、戌、未。
- 无礼之刑：子、卯。
- 自刑：辰、午、酉、亥（与自己相同也为刑）。
示例：2026年午午自刑，属马者同时也是刑太岁

4、害太岁（六害）

定义：生肖与太岁相害。关系不合，易生误会与阻碍。
六害组合：子未害、丑午害、寅巳害、卯辰害、申亥害、酉戌害。
示例：2026年午害丑，故属牛的人害太岁。

5、破太岁（六破）

定义：生肖与太岁相破。轻微干扰，多为小事不顺。
六破组合：子酉破、寅亥破、卯午破、辰丑破、巳申破、未戌破。
示例：2026年午破卯，故属兔的人破太岁。

6、合太岁（吉象）

定义：生肖与太岁相合，能得助力，可缓解犯太岁的不利。
类型：
- 六合：子丑、寅亥、卯戌、辰酉、巳申、午未。
- 三合：申子辰（水）、亥卯未（木）、寅午戌（火）、巳酉丑（金）。
示例：2026年（午），属羊（未）为六合；属虎（寅）、狗（戌）为三合中的半合，均属合太岁。

四、代码实战

理解规则后，我们可以用程序来自动化计算。以下是一个Java工具类的核心逻辑，用于计算任何年份下，与当年太岁相关的所有生肖关系。

核心功能

计算年干支：输入公元年份，输出如“丙午”的干支。
判断所有关系：自动找出该年的值、冲、刑、害、破、合太岁的生肖。
结构化输出：将结果封装为清晰的数据对象。

代码如下：

/**
 * 天干地支太岁工具类
 */
public class TaiSuiUtils {
    // 冲太岁规则：六冲配对（每组2个地支，双向冲）
    private static final List<List<EarthlyBranches>> CHONG_RULES = Collections.unmodifiableList(Arrays.asList(
            Arrays.asList(EarthlyBranches.ZI, EarthlyBranches.WU),
            Arrays.asList(EarthlyBranches.CHOU, EarthlyBranches.WEI),
            Arrays.asList(EarthlyBranches.YIN, EarthlyBranches.SHEN),
            Arrays.asList(EarthlyBranches.MAO, EarthlyBranches.YOU),
            Arrays.asList(EarthlyBranches.CHEN, EarthlyBranches.XU),
            Arrays.asList(EarthlyBranches.SI, EarthlyBranches.HAI)
    ));

    // 害太岁规则：六害配对（每组2个地支，双向害）
    private static final List<List<EarthlyBranches>> HAI_RULES = Collections.unmodifiableList(Arrays.asList(
            Arrays.asList(EarthlyBranches.ZI, EarthlyBranches.WEI),
            Arrays.asList(EarthlyBranches.CHOU, EarthlyBranches.WU),
            Arrays.asList(EarthlyBranches.YIN, EarthlyBranches.SI),
            Arrays.asList(EarthlyBranches.MAO, EarthlyBranches.CHEN),
            Arrays.asList(EarthlyBranches.SHEN, EarthlyBranches.HAI),
            Arrays.asList(EarthlyBranches.YOU, EarthlyBranches.XU)
    ));

    // 破太岁规则：六破配对（每组2个地支，双向破）
    private static final List<List<EarthlyBranches>> PO_RULES = Collections.unmodifiableList(Arrays.asList(
            Arrays.asList(EarthlyBranches.ZI, EarthlyBranches.YOU),
            Arrays.asList(EarthlyBranches.CHOU, EarthlyBranches.CHEN),
            Arrays.asList(EarthlyBranches.YIN, EarthlyBranches.HAI),
            Arrays.asList(EarthlyBranches.MAO, EarthlyBranches.WU),
            Arrays.asList(EarthlyBranches.SI, EarthlyBranches.SHEN),
            Arrays.asList(EarthlyBranches.WEI, EarthlyBranches.XU)
    ));

    // 六合太岁规则：六合配对（每组2个地支，双向合）
    private static final List<List<EarthlyBranches>> HE_LIU_RULES = Collections.unmodifiableList(Arrays.asList(
            Arrays.asList(EarthlyBranches.ZI, EarthlyBranches.CHOU),
            Arrays.asList(EarthlyBranches.YIN, EarthlyBranches.HAI),
            Arrays.asList(EarthlyBranches.MAO, EarthlyBranches.XU),
            Arrays.asList(EarthlyBranches.CHEN, EarthlyBranches.YOU),
            Arrays.asList(EarthlyBranches.SI, EarthlyBranches.SHEN),
            Arrays.asList(EarthlyBranches.WU, EarthlyBranches.WEI)
    ));

    // 三合太岁规则：四组三合局（每组3个地支）
    private static final List<List<EarthlyBranches>> HE_SAN_RULES = Collections.unmodifiableList(Arrays.asList(
            Arrays.asList(EarthlyBranches.ZI, EarthlyBranches.SHEN, EarthlyBranches.CHEN), // 水局
            Arrays.asList(EarthlyBranches.HAI, EarthlyBranches.MAO, EarthlyBranches.WEI), // 木局
            Arrays.asList(EarthlyBranches.YIN, EarthlyBranches.WU, EarthlyBranches.XU),   // 火局
            Arrays.asList(EarthlyBranches.SI, EarthlyBranches.YOU, EarthlyBranches.CHOU)  // 金局
    ));

    // 刑太岁规则：分三类（双向刑、循环三刑、自刑）
    private static final List<List<EarthlyBranches>> XING_DOUBLE_RULES = Collections.unmodifiableList(Arrays.asList(
            // 无礼之刑：子、卯。
            Arrays.asList(EarthlyBranches.ZI, EarthlyBranches.MAO),
            // 无恩之刑
            Arrays.asList(EarthlyBranches.YIN, EarthlyBranches.SI, EarthlyBranches.SHEN),
            //恃势之刑
            Arrays.asList(EarthlyBranches.CHOU, EarthlyBranches.XU, EarthlyBranches.WEI)
    ));

    // 自刑（辰、午、酉、亥）
    private static final List<EarthlyBranches> XING_SELF_RULES = Collections.unmodifiableList(Arrays.asList(
            EarthlyBranches.CHEN, EarthlyBranches.WU, EarthlyBranches.YOU, EarthlyBranches.HAI
    ));

    // ===================== 通用查找工具方法（核心：包含判断） =====================
    /**
     * 从双向配对规则中查找对应地支（冲/害/破/六合通用）
     * @param rules 配对规则List（每组2个地支）
     * @param branch 目标地支
     * @return 配对的另一个地支（无则返回null）
     */
    private static EarthlyBranches findPairBranch(List<List<EarthlyBranches>> rules, EarthlyBranches branch) {
        // 遍历所有配对，找到包含目标地支的组
        Optional<List<EarthlyBranches>> matchPair = rules.stream()
                .filter(pair -> pair.contains(branch))
                .findFirst();

        // 找到后返回组内另一个地支
        return matchPair.map(pair -> pair.get(0) == branch ? pair.get(1) : pair.get(0))
                .orElse(null);
    }

    /**
     * 从三合局规则中查找当前地支的三合列表（排除自身）
     * @param branch 目标地支
     * @return 三合地支列表（无则返回空列表）
     */
    private static List<EarthlyBranches> findSanHeBranches(EarthlyBranches branch) {
        // 找到包含当前地支的三合局
        Optional<List<EarthlyBranches>> matchGroup = HE_SAN_RULES.stream()
                .filter(group -> group.contains(branch))
                .findFirst();

        // 排除自身，返回另外两个地支
        return matchGroup.map(group -> {
            List<EarthlyBranches> sanHeList = new ArrayList<>(group);
            sanHeList.remove(branch);
            return Collections.unmodifiableList(sanHeList);
        }).orElse(Collections.emptyList());
    }

    /**
     * 查找当前地支的刑太岁列表
     * @param branch 目标地支
     * @return 刑太岁地支列表（无则返回空列表）
     */
    private static List<EarthlyBranches> findXingBranches(EarthlyBranches branch) {
        List<EarthlyBranches> xingList = new ArrayList<>();

        // 处理双向刑
        for (List<EarthlyBranches> xingDoubleRule : XING_DOUBLE_RULES) {
            if (xingDoubleRule.contains(branch)) {
                xingList.addAll(xingDoubleRule.stream().filter(pair -> pair != branch).toList());
            }
        }

        // 处理自刑
        if (XING_SELF_RULES.contains(branch)) {
            xingList.add(branch);
        }

        return Collections.unmodifiableList(xingList);
    }

    /**
     * 根据公历年获取年干支
     */
    public static String getYearGanZhi(int year) {
        if (year < 1) {
            throw new IllegalArgumentException("暂不支持公元前年份计算，当前年份：" + year);
        }

        HeavenlyStems[] stems = HeavenlyStems.values();
        EarthlyBranches[] branches = EarthlyBranches.values();

        // 基准值：公元4年为甲子年，偏移量=year-4
        int stemOffset = year - 4;
        int stemIndex = (stemOffset % 10 + 10) % 10; // 处理负数取模
        int branchOffset = year - 4;
        int branchIndex = (branchOffset % 12 + 12) % 12; // 处理负数取模

        return stems[stemIndex].getName() + branches[branchIndex].getName();
    }

    /**
     * 解析年干支字符串获取地支（如"甲辰"→辰）
     */
    public static EarthlyBranches parseBranchFromGanZhi(String ganZhi) {
        validateGanZhiFormat(ganZhi);
        String branchName = ganZhi.substring(1);
        return EarthlyBranches.fromJson(branchName);
    }

    /**
     * 解析年干支字符串获取天干（如"甲辰"→甲）
     */
    public static HeavenlyStems parseStemFromGanZhi(String ganZhi) {
        validateGanZhiFormat(ganZhi);
        String stemName = ganZhi.substring(0, 1);
        return HeavenlyStems.fromJson(stemName);
    }

    /**
     * 校验年干支格式（必须是2个字符）
     */
    private static void validateGanZhiFormat(String ganZhi) {
        if (ganZhi == null || ganZhi.length() != 2) {
            throw new IllegalArgumentException("年干支格式错误，必须为2个字符（如甲辰），当前值：" + ganZhi);
        }
    }

    /**
     * 根据公历年获取太岁信息列表
     */
    public static List<TaiSuiVo> getTaiSuiInfoByYear(int year) {
        String ganZhi = getYearGanZhi(year);
        return getTaiSuiInfoByGanZhi(ganZhi);
    }

    /**
     * 根据年干支获取太岁信息列表
     */
    public static List<TaiSuiVo> getTaiSuiInfoByGanZhi(String ganZhi) {
        EarthlyBranches yearBranch = parseBranchFromGanZhi(ganZhi);
        return getTaiSuiInfoByBranch(yearBranch);
    }

    /**
     * 根据地支获取太岁信息列表（核心方法）
     */
    public static List<TaiSuiVo> getTaiSuiInfoByBranch(EarthlyBranches yearBranch) {
        List<TaiSuiVo> taiSuiList = new ArrayList<>();

        // 1. 值太岁（本命年）
        taiSuiList.add(new TaiSuiVo(TaiSuiType.ZHI_TAI_SUI, yearBranch));

        // 2. 冲太岁
        EarthlyBranches chongBranch = findPairBranch(CHONG_RULES, yearBranch);
        addTaiSuiIfPresent(taiSuiList, TaiSuiType.CHONG_TAI_SUI, chongBranch);

        // 3. 害太岁
        EarthlyBranches haiBranch = findPairBranch(HAI_RULES, yearBranch);
        addTaiSuiIfPresent(taiSuiList, TaiSuiType.HAI_TAI_SUI, haiBranch);

        // 4. 刑太岁
        List<EarthlyBranches> xingBranches = findXingBranches(yearBranch);
        if (!xingBranches.isEmpty()) {
            taiSuiList.add(new TaiSuiVo(TaiSuiType.XING_TAI_SUI, yearBranch, xingBranches,false));
        }

        // 5. 破太岁
        EarthlyBranches poBranch = findPairBranch(PO_RULES, yearBranch);
        addTaiSuiIfPresent(taiSuiList, TaiSuiType.PO_TAI_SUI, poBranch);

        // 6. 六合太岁
        EarthlyBranches heLiuBranch = findPairBranch(HE_LIU_RULES, yearBranch);
        addTaiSuiIfPresent(taiSuiList, TaiSuiType.HE_LIU_TAI_SUI, heLiuBranch);

        // 7. 三合太岁
        List<EarthlyBranches> sanHeBranches = findSanHeBranches(yearBranch);
        if (!sanHeBranches.isEmpty()) {
            taiSuiList.add(new TaiSuiVo(TaiSuiType.HE_SAN_TAI_SUI, yearBranch, sanHeBranches,true));
        }

        return Collections.unmodifiableList(taiSuiList);
    }

    /**
     * 工具方法：存在地支时添加太岁信息
     */
    private static void addTaiSuiIfPresent(List<TaiSuiVo> taiSuiList, TaiSuiType type, EarthlyBranches branch) {
        if (branch != null) {
            taiSuiList.add(new TaiSuiVo(type, branch));
        }
    }

    // ===================== 测试验证 =====================
    public static void main(String[] args) {
        System.out.println("=========太岁验证==========");
        for (int i = 2024; i < 2030; i++) {
            List<TaiSuiVo> taiSuiInfos = getTaiSuiInfoByYear(i);
            System.out.printf("\n=== %s年太岁信息 ===%n", i);
            taiSuiInfos.forEach(System.out::println);
        }
    }
}

代码依赖了几个清晰的枚举类来定义核心概念：


// 天干
enum HeavenlyStems {
    JIA("甲"), YI("乙"), BING("丙"), DING("丁"), WU("戊"), JI("己"), GENG("庚"), XIN("辛"), REN("壬"), GUI("癸");
    private final String name;
    HeavenlyStems(String name) { this.name = name; }
    public String getName() { return name; }
    public static HeavenlyStems fromJson(String name) {
        for (HeavenlyStems stem : values()) {
            if (stem.name.equals(name)) return stem;
        }
        throw new IllegalArgumentException("无匹配的天干：" + name);
    }
}

// 地支
enum EarthlyBranches {
    ZI("子"),
    CHOU("丑"),
    YIN("寅"),
    MAO("卯"),
    CHEN("辰"),
    SI("巳"),
    WU("午"),
    WEI("未"),
    SHEN("申"),
    YOU("酉"),
    XU("戌"),
    HAI("亥");

    private final String name;

    EarthlyBranches(String name) {
        this.name = name;
    }
    
    public static EarthlyBranches fromJson(String name) {
        for (EarthlyBranches branch : values()) {
            if (branch.name.equals(name)) {
                return branch;
            }
        }
        throw new IllegalArgumentException("无匹配的地支：" + name);
    }
}

// 生肖
@Getter
public enum ChineseZodiac {

    RAT("鼠", EarthlyBranches.ZI),
    OX("牛", EarthlyBranches.CHOU),
    TIGER("虎", EarthlyBranches.YIN),
    RABBIT("兔", EarthlyBranches.MAO),
    DRAGON("龙", EarthlyBranches.CHEN),
    SNAKE("蛇", EarthlyBranches.SI),
    HORSE("马", EarthlyBranches.WU),
    GOAT("羊", EarthlyBranches.WEI),
    MONKEY("猴", EarthlyBranches.SHEN),
    ROOSTER("鸡", EarthlyBranches.YOU),
    DOG("狗", EarthlyBranches.XU),
    PIG("猪", EarthlyBranches.HAI);

    private final String name;
    private final EarthlyBranches earthlyBranch;

    ChineseZodiac(String name, EarthlyBranches earthlyBranch) {
        this.name = name;
        this.earthlyBranch = earthlyBranch;
    }

    /**
     * 根据地支获取对应生肖
     */
    public static ChineseZodiac fromEarthlyBranch(EarthlyBranches branch) {
        for (ChineseZodiac zodiac : values()) {
            if (zodiac.earthlyBranch == branch) {
                return zodiac;
            }
        }
        throw new IllegalArgumentException("无匹配的生肖：" + branch.getName());
    }
}

// 太岁
@Getter
public enum TaiSuiType {
    ZHI_TAI_SUI("值太岁（本命年）"),
    CHONG_TAI_SUI("冲太岁"),
    HAI_TAI_SUI("害太岁"),
    XING_TAI_SUI("刑太岁"),
    PO_TAI_SUI("破太岁"),
    HE_LIU_TAI_SUI("六合太岁"),
    HE_SAN_TAI_SUI("三合太岁"),
    ;

    private final String desc;

    TaiSuiType(String desc) {
        this.desc = desc;
    }
}

// 太岁信息
@Data
public class TaiSuiVo {
    /** 太岁类型 */
    private TaiSuiType type;
    /** 对应地支 */
    private EarthlyBranches earthlyBranch;
    /** 对应生肖（强类型枚举） */
    private ChineseZodiac zodiac;
    /** 描述信息（标准化格式） */
    private String desc;

    // 通用构造器（适用于值/冲/害/破/六合太岁）
    public TaiSuiVo(TaiSuiType type, EarthlyBranches earthlyBranch) {
        this.type = type;
        this.earthlyBranch = earthlyBranch;
        this.zodiac = ChineseZodiac.fromEarthlyBranch(earthlyBranch);
        this.desc = String.format("%s：%s(%s)", type.getDesc(), earthlyBranch.getName(), this.zodiac.getName());
    }

    public TaiSuiVo(TaiSuiType type, EarthlyBranches earthlyBranch, List<EarthlyBranches> earthlyBranchesList, boolean sanHe) {
        this.type = type;
        this.earthlyBranch = earthlyBranch;
        this.zodiac = ChineseZodiac.fromEarthlyBranch(earthlyBranch);
        String zodiacInfo = earthlyBranchesList.stream().map(i -> {
            ChineseZodiac chineseZodiac = ChineseZodiac.fromEarthlyBranch(i);
            return String.format("%s(%s)", chineseZodiac.getName(), i.getName());
        }).collect(Collectors.joining("、"));
        if(sanHe) {
            this.desc = String.format("%s：%s(%s) 合局: [%s]", type.getDesc(), earthlyBranch.getName(), this.zodiac.getName(), zodiacInfo);
        }else {
            this.desc = String.format("%s：%s", type.getDesc(),zodiacInfo);
        }
    }
}

五、总结

了解太岁文化，不是为了制造焦虑，而是：在理解传统智慧的基础上，更清醒地规划生活。

太岁不是凶神，而是年度 “值班经理”，掌管一年秩序
犯太岁≠倒霉，而是能量重组期，有挑战也有机遇
化解无需花钱，调整心态、优化习惯、行善积德，才是根本之道

最后，送你一句古人的智慧共勉：“命由己造，福自我求”。与其纠结 “犯太岁”，不如行动起来，用积极的心态和科学的方法，创造属于自己的好运！

胖不了小陆

2026丙午年犯太岁？先搞懂这3个逻辑，焦虑直接退散