使用Java计算生辰八字五行属性

源码地址：https://github.com/luguangdong/java-base/blob/master/src/com/luxiu/java/base/wuxing/WuXingApp2.java

五行八字基本要素

天干地支表

	甲	乙	丙	丁	戊	己	庚	辛	壬	癸
子鼠	甲子		丙子		戊子		庚子		壬子
丑牛		乙丑		丁丑		己丑		辛丑		癸丑
寅虎	甲寅		丙寅		戊寅		庚寅		壬寅
卯兔		乙卯		丁卯		己卯		辛卯		癸卯
辰龙	甲辰		丙辰		戊辰		庚辰		壬辰
巳蛇		乙巳		丁巳		己巳		辛巳		癸巳
午马	甲午		丙午		戊午		庚午		壬午
未羊		乙未		丁未		己未		辛未		癸未
申猴	甲申		丙申		戊申		庚申		壬申
酉鸡		乙酉		丁酉		己酉		辛酉		癸酉
戌狗	甲戌		丙戌		戊戌		庚戌		壬戌
亥猪		乙亥		丁亥		己亥		辛亥		癸亥

说明： 天干地支简称干支，干支纪年是我国传统的纪年方法即为天干地支纪年法

• 十天干分别为：甲乙 丙丁 戊己 庚辛 壬癸
• 十二地支分别为：子丑 寅卯 辰巳 午未 申酉 戌亥
• 干和支组合后用于纪年，将十天干和十二地支按顺序搭配组合成干支，用于纪年。按此排法，当天干 10 个符号排了六轮与地支 12 个符号排了五轮以后，可构成 60 干支。续排下去又将恢复原状，周而复始，即：“六十年为一个甲子”

天干地支对应编号

• 甲子 00，乙丑 01，丙寅 02，丁卯 03，戊辰 04，己巳 05，庚午 06，辛未 07，壬申 08，癸酉 09
• 甲戌 10，乙亥 11，丙子 12，丁丑 13，戊寅 14，己卯 15，庚辰 16，辛巳 17，壬午 18，癸未 19
• 甲申 20，乙酉 21，丙戌 22，丁亥 23，戊子 24，己丑 25，庚寅 26，辛卯 27，壬辰 28，癸巳 29
• 甲午 30，乙未 31，丙申 32，丁酉 33，戊戌 34，己亥 35，庚子 36，辛丑 37，壬寅 38，癸卯 39
• 甲辰 40，乙巳 41，丙午 42，丁未 43，戊申 44，己酉 45，庚戌 46，辛亥 47，壬子 48，癸丑 49
• 甲寅 50，乙卯 51，丙辰 52，丁巳 53，戊午 54，己未 55，庚申 56，辛酉 57，壬戌 58，癸亥 59

计算公元后某年的干支

假设公元后某年为 X 则先用 X 除以 60 得出余数再减去 4，根据所得结果查表中对应的编号即可算出该年的干支

比如：2020 除以 60 余 40 减去 4 等于 36，对应干支为 庚子年，当 X 除以 60 的余数小于 4 时，需借干支纪年的一个周期 60 再减 4，例如 1983 除以 60 余数为 3，直接减 4 不够减，加上 60 之后再减 4 等于 59，1983 年为 癸亥年

干支纪月法

若遇甲或己的年份 ，正月是丙寅；遇上乙或庚之年，正月为戊寅；遇上丙或辛之年，正月为庚寅；遇上丁或壬之年，正月为壬寅；遇上戊或癸之年，正月为甲寅。依照正月之干支，其余月份按干支推算即可

年份	正月	二月	三月	四月	五月	六月	七月	八月	九月	十月	冬月	腊月
甲、己	丙寅	丁卯	戊辰	己巳	庚午	辛未	壬申	癸酉	甲戌	乙亥	丙子	丁丑
乙、庚	戊寅	己卯	庚辰	辛巳	壬午	癸未	甲申	乙酉	丙戌	丁亥	戊子	己丑
丙、辛	庚寅	辛卯	壬辰	癸巳	甲午	乙未	丙申	丁酉	戊戌	己亥	庚子	辛丑
丁、壬	壬寅	癸卯	甲辰	乙巳	丙午	丁未	戊申	己酉	庚戌	辛亥	壬子	癸丑
戊、癸	甲寅	乙卯	丙辰	丁巳	戊午	己未	庚申	辛酉	壬戌	癸亥	甲子	乙丑

干支纪日法

从已知日期计算干支纪日的公式为：

• 天干 = (4 * C + [C / 4] + 5 * y + [y / 4] + [3 * (M + 1) / 5] + d - 3) % 10

• 地支 = (8 * C + [C / 4] + 5 * y + [y / 4] + [3 * (M + 1) / 5] + d + 7 + i) % 12

    	注意： [] 里的除法取整即可
  

说明如下：

• c 为年份前两位，比如 2019 年则 c 为 20
• y 为年份后两位，比如 2019 年则 y 为 19
• M 为月份，1 月和 2 月按上一年的 13 月和 14 月来算
• d 为日数
• i
  • 奇数月为 0
  • 偶数月为 6

比如计算 2020 年 2 月 9 日的干支日如下：

• 天干 = (4 * 20 + 20 / 4 + 5 * 19 + 19 / 4 + 3 * (14 + 1) / 5 + 9 - 3) % 10 = 9 即 壬
• 地支 = (8 * 20 + 20 / 4 + 5 * 19 + 19 / 4 + 3 * (14 + 1) / 5 + 9 + 7 + 6) % 12 = 7 即 午

十二时辰表

时辰	时间
子时	23 - 01
丑时	01 - 03
寅时	03 - 05
卯时	05 - 07
辰时	07 - 09
巳时	09 - 11
午时	11 - 13
未时	13 - 15
申时	15 - 17
酉时	17 - 19
戌时	19 - 21
亥时	21 - 23

注意： 根据上表可以得出生辰八字的第八个字，比如早上 9 点出生即第八个字为 巳

十二时辰纪日对照表

想要得到第七个字，需要使用以下对照表；比如 2020 年（庚子） 2 月（戊寅） 9 日（壬午）晚上 23 点（子时），找到 壬 和 子 对应的字即下表中的 庚子

时/日	甲、己	乙、庚	丙、辛	丁、壬	戊、癸
子	甲、子	丙 、子	戊、子	庚、子	壬、子
丑	乙、丑	丁、丑	己、丑	辛、丑	癸、丑
寅	丙、寅	戊、寅	庚、寅	壬、寅	甲、寅
卯	丁、卯	己、卯	辛、卯	癸、卯	乙、卯
辰	戊、辰	庚、辰	壬、辰	甲、辰	丙、辰
巳	己、巳	辛、巳	癸、巳	乙、巳	丁、巳
午	庚、午	壬、午	甲、午	丙、午	戊、午
未	辛、未	癸、未	乙、未	丁、未	己、未
申	壬、申	甲、申	丙、申	戊、申	庚、申
酉	癸、酉	乙、酉	丁、酉	己、酉	辛、酉
戌	甲、戌	丙、戌	戊、戌	庚、戌	壬、戌
亥	乙、亥	丁、亥	己、亥	辛、亥	癸、亥

生辰八字 = 年（庚子） + 月（戊寅） + 日（壬午） + 时（庚子）

五行干支对照表

五行	天干	地支
木	甲、乙	寅、卯
火	丙、丁	巳、午
土	戊、己	辰、丑、戌、未
金	庚、辛	申、酉
水	壬、癸	亥、子

按照上面的生辰八字得出五行（2 个金，3 个水，1 个土，1 个木，1 个火；此子五行不缺）

庚子	戊寅	壬午	庚子
金水	土木	水火	金水

五行八字Java实现代码

package com.luxiu.java.base.wuxing;

/**
 * 

 * Description: 测试八字与五行版本1
 * 
 *
 * @author luguangdong
 * @version 1.0
 * @ClassName WuXingApp
 * @date 2020/3/20 9:51
 * @company 
 */
public class WuXingApp {
    private static final String[] TG = {"甲", "乙", "丙", "丁", "戊", "己", "庚", "辛", "壬", "癸"};
    private static final String[] DZ = {"子", "丑", "寅", "卯", "辰", "巳", "午", "未", "申", "酉", "戌", "亥"};

    public static void main(String[] args) {
        // 公元后某年
        int year = 2020;
        // 农历某月
        int nMonth = 1;
        // 阳历某月
        int yMonth = 2;
        // 阳历某日
        int day = 10;
        // 时间
        int time = 15;

        // 获取干支年
        String gzYear = getYear(year);
        System.out.println(year + " 年为 \"" + gzYear + "\" 年");

        // 获取干支月
        String gzMonth = getMonth(gzYear, nMonth);
        System.out.println(year + " 年农历 " + nMonth + " 月为 \"" + gzMonth + "\" 月");

        // 获取干支日
        String gzDay = getDay(year, yMonth, day);
        System.out.println(year + " 年阳历 " + yMonth + " 月 " + day + " 日为 \"" + gzDay + "\" 日");

        // 获取干支时
        String gzTime = getTime(gzDay, time);
        System.out.println(year + " 年阳历 " + yMonth + " 月 " + day + " 日 " + time + " 时为 \"" + gzTime + "\" 时");

        // 生辰八字
        System.out.println("您的生辰八字为：" + gzYear + gzMonth + gzDay + gzTime);

        // 生辰八字算五行
        wuxing(gzYear, gzMonth, gzDay, gzTime);
    }

    /**
     * 获取干支年 

     * 根据公元后某年换算出干支年 

     *
     * 

     * 说明：假设公元后某年为 X 则先用 X 除以 60 得出余数再减去 4，根据所得结果查表中对应的编号即可算出该年的干支 

     * 如果减 4 不够减则加上 60 之后再减即可
     * 
     *
     * @param year {@code int} 公元后的某一年
     * @return {@code String} 干支年
     */
    public static String getYear(int year) {
        // 假设公元后某年为 X 则先用 X 除以 60 得出余数
        int gzNum = year % 60;

        // 用余数减 4 不够减则加上 60 之后再减得出编号
        if (gzNum - 4 < 0) {
            gzNum = gzNum + 60 - 4;
        } else {
            gzNum = gzNum - 4;
        }

        // 遍历天干地支
        for (int i = 0; i < 60; i++) {
            int itg = i % TG.length; // 取余数防止数组越界
            int idz = i % DZ.length; // 同上
            if (gzNum == i) {
                // 根据天干地支的索引进行匹配
                return TG[itg] + DZ[idz];
            }
        }

        return null;
    }

    /**
     * 获取干支月 

     * 根据干支年换算出干支月 

     *
     * 

     * 说明：若遇甲或己的年份 ，正月是丙寅；遇上乙或庚之年，正月为戊寅；遇上丙或辛之年，正月为庚寅；遇上丁或壬之年，正月为壬寅；遇上戊或癸之年，正月为甲寅
     * 
     *
     * @param gzYear {@code String} 干支年
     * @param month  {@code int} 农历的月份
     * @return {@code String} 干支月
     */
    public static String getMonth(String gzYear, int month) {
        String stg = gzYear.substring(0, 1);

        int itgFlag = 0;
        // 如果干支年的天干位为 “甲” 或 “己”，则从 TG 数组下标的第 2 位开始
        if ("甲".equals(stg) || "己".equals(stg)) {
            itgFlag = 2;
        } else if ("乙".equals(stg) || "庚".equals(stg)) {
            itgFlag = 4;
        } else if ("丙".equals(stg) || "辛".equals(stg)) {
            itgFlag = 6;
        } else if ("丁".equals(stg) || "壬".equals(stg)) {
            itgFlag = 8;
        }

        for (int i = 0; i < 12; i++) {
            int itg = (i + itgFlag) % TG.length;
            int idz = (i + 2) % DZ.length;

            if (i == month - 1) {
                return TG[itg] + DZ[idz];
            }
        }

        return null;
    }

    /**
     * 获取干支日 

     * 根据阳历年月日换算出干支日 

     * 天干 = (4 * c + c / 4 + 5 * y + y / 4 + 3 * (m + 1) / 5 + d - 3) % 10 

     * 地支 = (8 * c + c / 4 + 5 * y + y / 4 + 3 * (m + 1) / 5 + d + 7 + i) % 12 

     *
     * 

     *     
c 为年份前两位，比如 2019 年则 c 为 20
     *     
y 为年份后两位，比如 2019 年则 y 为 19
     *     
m 为月份，1 月和 2 月按上一年的 13 月和 14 月来算
     *     
d 为日数
     *     
奇数月 i 为 0
     *     
偶数月 i 为 6
     * 
     *
     * @param year  {@code int} 阳历年
     * @param month {@code int} 阳历月
     * @param day   {@code int} 阳历日
     * @return {@code String} 干支日
     */
    public static String getDay(int year, int month, int day) {
        String yearStr = String.valueOf(year);
        int c = Integer.parseInt(yearStr.substring(0, 2));
        int y = Integer.parseInt(yearStr.substring(2));
        // 嵌套的三元表达式，1 月和 2 月按上一年的 13 月和 14 月来算
        int m = month == 1 ? 13 : month == 2 ? 14 : month;
        if (m == 13 || m == 14) {
            y--;
        }
        int d = day;
        // 三元表达式，月份除以 2 余 0 则为偶数否则为奇数
        int i = m % 2 != 0 ? 0 : 6;

        int itg = (4 * c + c / 4 + 5 * y + y / 4 + 3 * m / 5 + d - 3) % 10;
        int idz = (8 * c + c / 4 + 5 * y + y / 4 + 3 * m / 5 + d + 7 + i) % 12;

        return TG[itg] + DZ[idz];
    }

    /**
     * 获取干支时 

     *
     * 

     * 说明：根据十二时辰只能得出支，想要得到干，需要配合干支日换算
     * 
     *
     * @param gzDay {@code String} 干支日
     * @param time  {@code int} 24 小时制的时间
     * @return {@code String} 干支时
     */
    public static String getTime(String gzDay, int time) {
        // 取出干支日的第一个字
        gzDay = gzDay.substring(0, 1);

        // 换算出时间对应地支的下标位置
        int idz = 0;
        if (time >= 23 || time < 1) {
            idz = 0;
        } else if (time >= 1 && time < 3) {
            idz = 1;
        } else if (time >= 3 && time < 5) {
            idz = 2;
        } else if (time >= 5 && time < 7) {
            idz = 3;
        } else if (time >= 7 && time < 9) {
            idz = 4;
        } else if (time >= 9 && time < 11) {
            idz = 5;
        } else if (time >= 11 && time < 13) {
            idz = 6;
        } else if (time >= 13 && time < 15) {
            idz = 7;
        } else if (time >= 15 && time < 17) {
            idz = 8;
        } else if (time >= 17 && time < 19) {
            idz = 9;
        } else if (time >= 19 && time < 21) {
            idz = 10;
        } else if (time >= 21 && time < 23) {
            idz = 11;
        }

        int itgFlag = 8;
        // 如果干支年的天干位为 “甲” 或 “己”，则从 TG 数组下标的第 0 位开始
        if ("甲".equals(gzDay) || "己".equals(gzDay)) {
            itgFlag = 0;
        } else if ("乙".equals(gzDay) || "庚".equals(gzDay)) {
            itgFlag = 2;
        } else if ("丙".equals(gzDay) || "辛".equals(gzDay)) {
            itgFlag = 4;
        } else if ("丁".equals(gzDay) || "壬".equals(gzDay)) {
            itgFlag = 6;
        }

        return TG[(idz + itgFlag) % 10] + DZ[idz];
    }

    /**
     * 通过八字算五行
     *
     * @param gzYear  {@code String} 干支年
     * @param gzMonth {@code String} 干支月
     * @param gzDay   {@code String} 干支日
     * @param gzTime  {@code String} 干支时
     */
    public static void wuxing(String gzYear, String gzMonth, String gzDay, String gzTime) {
        // 天干年
        String gYear = gzYear.substring(0, 1);
        if ("甲".equals(gYear) || "乙".equals(gYear)) {
            gYear = "木";
        }
        if ("丙".equals(gYear) || "丁".equals(gYear)) {
            gYear = "火";
        }
        if ("戊".equals(gYear) || "己".equals(gYear)) {
            gYear = "土";
        }
        if ("庚".equals(gYear) || "辛".equals(gYear)) {
            gYear = "金";
        }
        if ("壬".equals(gYear) || "癸".equals(gYear)) {
            gYear = "水";
        }

        // 天干月
        String gMonth = gzMonth.substring(0, 1);
        if ("甲".equals(gMonth) || "乙".equals(gMonth)) {
            gMonth = "木";
        }
        if ("丙".equals(gMonth) || "丁".equals(gMonth)) {
            gMonth = "火";
        }
        if ("戊".equals(gMonth) || "己".equals(gMonth)) {
            gMonth = "土";
        }
        if ("庚".equals(gMonth) || "辛".equals(gMonth)) {
            gMonth = "金";
        }
        if ("壬".equals(gMonth) || "癸".equals(gMonth)) {
            gMonth = "水";
        }

        // 天干日
        String gDay = gzDay.substring(0, 1);
        if ("甲".equals(gDay) || "乙".equals(gDay)) {
            gDay = "木";
        }
        if ("丙".equals(gDay) || "丁".equals(gDay)) {
            gDay = "火";
        }
        if ("戊".equals(gDay) || "己".equals(gDay)) {
            gDay = "土";
        }
        if ("庚".equals(gDay) || "辛".equals(gDay)) {
            gDay = "金";
        }
        if ("壬".equals(gDay) || "癸".equals(gDay)) {
            gDay = "水";
        }

        // 天干时
        String gTime = gzTime.substring(0, 1);
        if ("甲".equals(gTime) || "乙".equals(gTime)) {
            gTime = "木";
        }
        if ("丙".equals(gTime) || "丁".equals(gTime)) {
            gTime = "火";
        }
        if ("戊".equals(gTime) || "己".equals(gTime)) {
            gTime = "土";
        }
        if ("庚".equals(gTime) || "辛".equals(gTime)) {
            gTime = "金";
        }
        if ("壬".equals(gTime) || "癸".equals(gTime)) {
            gTime = "水";
        }

        // 地支年
        String zYear = gzYear.substring(1);
        if ("寅".equals(zYear) || "卯".equals(zYear)) {
            zYear = "木";
        }
        if ("巳".equals(zYear) || "午".equals(zYear)) {
            zYear = "火";
        }
        if ("辰".equals(zYear) || "丑".equals(zYear) || "戌".equals(zYear) || "未".equals(zYear)) {
            zYear = "土";
        }
        if ("申".equals(zYear) || "酉".equals(zYear)) {
            zYear = "金";
        }
        if ("亥".equals(zYear) || "子".equals(zYear)) {
            zYear = "水";
        }

        // 地支月
        String zMonth = gzMonth.substring(1);
        if ("寅".equals(zMonth) || "卯".equals(zMonth)) {
            zMonth = "木";
        }
        if ("巳".equals(zMonth) || "午".equals(zMonth)) {
            zMonth = "火";
        }
        if ("辰".equals(zMonth) || "丑".equals(zMonth) || "戌".equals(zMonth) || "未".equals(zMonth)) {
            zMonth = "土";
        }
        if ("申".equals(zMonth) || "酉".equals(zMonth)) {
            zMonth = "金";
        }
        if ("亥".equals(zMonth) || "子".equals(zMonth)) {
            zMonth = "水";
        }

        // 地支日
        String zDay = gzDay.substring(1);
        if ("寅".equals(zDay) || "卯".equals(zDay)) {
            zDay = "木";
        }
        if ("巳".equals(zDay) || "午".equals(zDay)) {
            zDay = "火";
        }
        if ("辰".equals(zDay) || "丑".equals(zDay) || "戌".equals(zDay) || "未".equals(zDay)) {
            zDay = "土";
        }
        if ("申".equals(zDay) || "酉".equals(zDay)) {
            zDay = "金";
        }
        if ("亥".equals(zDay) || "子".equals(zDay)) {
            zDay = "水";
        }

        // 地支时
        String zTime = gzTime.substring(1);
        if ("寅".equals(zTime) || "卯".equals(zTime)) {
            zTime = "木";
        }
        if ("巳".equals(zTime) || "午".equals(zTime)) {
            zTime = "火";
        }
        if ("辰".equals(zTime) || "丑".equals(zTime) || "戌".equals(zTime) || "未".equals(zTime)) {
            zTime = "土";
        }
        if ("申".equals(zTime) || "酉".equals(zTime)) {
            zTime = "金";
        }
        if ("亥".equals(zTime) || "子".equals(zTime)) {
            zTime = "水";
        }

        // 输出五行
        String wuxing = gYear + zYear + gMonth + zMonth + gDay + zDay + gTime + zTime;
        System.out.println("您的八字五行为：" + wuxing);

        // 算出五行缺啥
        String que = "您的五行缺：";
        if (!wuxing.contains("金")) {
            que += "金";
        }
        if (!wuxing.contains("木")) {
            que += "木";
        }
        if (!wuxing.contains("水")) {
            que += "水";
        }
        if (!wuxing.contains("火")) {
            que += "火";
        }
        if (!wuxing.contains("土")) {
            que += "土";
        }
        System.out.println(que.equals("您的五行缺：") ? "恭喜，您的五行不缺" : que);
    }
}