java实现八字的计算

牛十二

已于 2025-02-12 11:18:03 修改

阅读量1.1k

点赞数

文章标签：算法实现天干地支万年历

于 2023-06-30 17:14:47 首次发布

本文链接：https://blog.youkuaiyun.com/s_ongfei/article/details/131480058

版权

获取年月日的天干地支可参考

Java-获取年月日对应的天干地支_ddn49357的博客-优快云博客

天干地支纪年：

1864年是甲子年

(年 - 4) % 10 对应的余数就是对应天干
(年 - 4) % 12 对应的余数就是对应的地支

天干地支纪月：
干支纪月歌诀

干支纪月的推算较为容易，每年的各月地支已经固定，只要推算月的天干配固定每月地支就行。有歌诀为证（寅月为正月，寅为虎，又称“五虎遁元”）：

甲己之年丙作首，——逢年干是甲或己的年份，正月的月干从丙上起。

乙庚之岁戊为头，——逢年干是乙或庚的年份，正月的月干从戊上起。

丙辛必定寻庚起，——逢年干是丙或辛的年份，正月的月干从庚上起。

丁壬壬位顺行流，——逢年干是丁或壬的年份，正月的月干从壬上起。

更有戊癸何方觅，甲寅之上好追求。——逢年干是戊或癸的年份，正月的月干从甲上起。

夜半——子时（23：00—0：59）

鸡鸣——丑时（1：00—2：59）

平旦——寅时（3：00－4：59）

日出——卯时（5：00—6：59）

食时——辰时（7：00—8：59）

隅中——巳时（9：00－10：59）

日中——午时（11：00—12：59）

日昳——未时（13：00—14：59）

哺时——申时（15：00－16：59）

日入——酉时（17：00－18：59）

黄昏——戌时（19：00－20：59）

人定——亥时（21：00－22：59）

夜半者子也，鸡鸣者丑也，平旦者寅也，日出者卯也，

食时者辰也，隅中者巳也，日中者午也，日昳者未也，

哺时者申也，日入者酉也，黄昏者戌也，人定者亥也。

时柱的地支是固定不变的，而天干却不同，可查日上起时表。

时的天干可参考日干推算出时的天干

如果日干为甲或己，当日子时的干支为甲子；如果日干为乙或庚，当日子时的干支为丙子；如果日干为丙或辛，当日子时的干支为戊子；如果日干为丁或壬，当日子时的干支为庚子；如果日干为戊或癸，当日子时的干支为壬子。

时辰干支查算表

时间	时辰	五行	纪日干支
时间	时辰	五行	甲己	乙庚	丙辛	丁壬	戊癸
23－01	子	水	甲子	丙子	戊子	庚子	壬子
01－03	丑	土	乙丑	丁丑	己丑	辛丑	癸丑
03－05	寅	木	丙寅	戊寅	庚寅	壬寅	甲寅
05－07	卯	木	丁卯	己卯	辛卯	癸卯	乙卯
07－09	辰	土	戊辰	庚辰	壬辰	甲辰	丙辰
09－11	巳	火	己巳	辛巳	癸巳	乙巳	丁巳
11－13	午	火	庚午	壬午	甲午	丙午	戊午
13－15	未	土	辛未	癸未	乙未	丁未	己未
15－17	申	金	壬申	甲申	丙申	戊申	庚申
17－19	酉	金	癸酉	乙酉	丁酉	己酉	辛酉
19－21	戌	土	甲戌	丙戌	戊戌	庚戌	壬戌
21－23	亥	水	乙亥	丁亥	己亥	辛亥	癸亥

出生日期的天干对应的五行就是属于何命，排出来的五行没有哪一个就是缺哪个。

有空再用java实现，谁写出来，欢迎跟贴，把中国的古代文明传承和发扬光大。

为防止丢失和删除，拷一份过来

一、概述

本次是以java语言开发为例，计算出年月日对应的天干地支。

二、代码

  1 public class MyDate {
  2     /**
  3      * 对于年月日的天干地支
  4      */
  5     private int year_ganZhi;
  6     private int month_ganZhi;
  7     private int day_ganZhi;
  8     /**
  9      * 关于阴历的相关信息
 10      */
 11     private static int[] lunar_info = {0x04bd8, 0x04ae0, 0x0a570, 0x054d5,
 12             0x0d260, 0x0d950, 0x16554, 0x056a0, 0x09ad0, 0x055d2, 0x04ae0,
 13             0x0a5b6, 0x0a4d0, 0x0d250, 0x1d255, 0x0b540, 0x0d6a0, 0x0ada2,
 14             0x095b0, 0x14977, 0x04970, 0x0a4b0, 0x0b4b5, 0x06a50, 0x06d40,
 15             0x1ab54, 0x02b60, 0x09570, 0x052f2, 0x04970, 0x06566, 0x0d4a0,
 16             0x0ea50, 0x06e95, 0x05ad0, 0x02b60, 0x186e3, 0x092e0, 0x1c8d7,
 17             0x0c950, 0x0d4a0, 0x1d8a6, 0x0b550, 0x056a0, 0x1a5b4, 0x025d0,
 18             0x092d0, 0x0d2b2, 0x0a950, 0x0b557, 0x06ca0, 0x0b550, 0x15355,
 19             0x04da0, 0x0a5d0, 0x14573, 0x052d0, 0x0a9a8, 0x0e950, 0x06aa0,
 20             0x0aea6, 0x0ab50, 0x04b60, 0x0aae4, 0x0a570, 0x05260, 0x0f263,
 21             0x0d950, 0x05b57, 0x056a0, 0x096d0, 0x04dd5, 0x04ad0, 0x0a4d0,
 22             0x0d4d4, 0x0d250, 0x0d558, 0x0b540, 0x0b5a0, 0x195a6, 0x095b0,
 23             0x049b0, 0x0a974, 0x0a4b0, 0x0b27a, 0x06a50, 0x06d40, 0x0af46,
 24             0x0ab60, 0x09570, 0x04af5, 0x04970, 0x064b0, 0x074a3, 0x0ea50,
 25             0x06b58, 0x055c0, 0x0ab60, 0x096d5, 0x092e0, 0x0c960, 0x0d954,
 26             0x0d4a0, 0x0da50, 0x07552, 0x056a0, 0x0abb7, 0x025d0, 0x092d0,
 27             0x0cab5, 0x0a950, 0x0b4a0, 0x0baa4, 0x0ad50, 0x055d9, 0x04ba0,
 28             0x0a5b0, 0x15176, 0x052b0, 0x0a930, 0x07954, 0x06aa0, 0x0ad50,
 29             0x05b52, 0x04b60, 0x0a6e6, 0x0a4e0, 0x0d260, 0x0ea65, 0x0d530,
 30             0x05aa0, 0x076a3, 0x096d0, 0x04bd7, 0x04ad0, 0x0a4d0, 0x1d0b6,
 31             0x0d250, 0x0d520, 0x0dd45, 0x0b5a0, 0x056d0, 0x055b2, 0x049b0,
 32             0x0a577, 0x0a4b0, 0x0aa50, 0x1b255, 0x06d20, 0x0ada0};
 33     /**
 34      * 记录天干的信息
 35      */
 36     private String[] gan_info = {"甲", "乙", "丙", "丁", "戊", "己", "庚", "辛",
 37             "壬", "癸"};
 38     private String[] zhi_info = {"子", "丑", "寅", "卯", "辰", "巳", "午", "未",
 39             "申", "酉", "戌", "亥"};
 40     /**
 41      * 单例模式
 42      */
 43     private static volatile MyDate instance = null;
 44     private MyDate() {
 45     }
 46 
 47     public static MyDate getInstance() {
 48         if (instance == null) {
 49             synchronized (MyDate.class) {
 50                 if (instance == null) {
 51                     instance = new MyDate();
 52                 }
 53             }
 54         }
 55         return instance;
 56     }
 57 
 58     /**
 59      * 获取农历某年的总天数
 60      *
 61      * @param year
 62      * @return
 63      */
 64     private int daysOfYear(int year) {
 65         int sum = 348;
 66         for (int i = 0x8000; i > 0x8; i >>= 1) {
 67             sum += (lunar_info[year - 1900] & i) == 0 ? 0 : 1;
 68         }
 69         //获取闰月的天数
 70         int daysOfLeapMonth;
 71         if ((lunar_info[year - 1900] & 0xf) != 0) {
 72             daysOfLeapMonth = (lunar_info[year - 1900] & 0x10000) == 0 ? 29 : 30;
 73         } else {
 74             daysOfLeapMonth = 0;
 75         }
 76         return sum + daysOfLeapMonth;
 77     }
 78 
 79     /**
 80      * 初始化年月日对应的天干地支
 81      * @param year
 82      * @param month
 83      * @param day
 84      */
 85     public void initGanZhi(int year, int month, int day) {
 86         //获取现在的时间
 87         Calendar calendar_now = Calendar.getInstance();
 88         calendar_now.set(year, month - 1, day);
 89         long date_now = calendar_now.getTime().getTime();
 90         //获取1900-01-31的时间
 91         Calendar calendar_ago = Calendar.getInstance();
 92         calendar_ago.set(1900, 0 ,31);
 93         long date_ago = calendar_ago.getTime().getTime();
 94         //86400000 = 24 * 60 * 60 * 1000
 95         long days_distance = (date_now - date_ago) / 86400000L;
 96         float remainder = (date_now - date_ago) % 86400000L;
 97         //余数大于0算一天
 98         if (remainder > 0) {
 99             days_distance += 1;
100         }
101         //都是从甲子开始算起以1900-01-31为起点
102         //1899-12-21是农历1899年腊月甲子日  40：相差1900-01-31有40天
103         day_ganZhi = (int)days_distance + 40;
104         //1898-10-01是农历甲子月  14：相差1900-01-31有14个月
105         month_ganZhi = 14;
106         int daysOfYear = 0;
107         int i;
108         for (i = 1900; i < 2050 && days_distance > 0; i++) {
109             daysOfYear = daysOfYear(i);
110             days_distance -= daysOfYear;
111             month_ganZhi += 12;
112         }
113         if (days_distance < 0) {
114             days_distance += daysOfYear;
115             i--;
116             month_ganZhi -= 12;
117         }
118         //农历年份
119         int myYear = i;
120         //1864年是甲子年
121         year_ganZhi = myYear - 1864;
122         //哪个月是闰月
123         int leap = lunar_info[myYear - 1900] & 0xf;
124         boolean isLeap = false;
125         int daysOfLeapMonth = 0;
126         for (i = 1; i < 13 && days_distance > 0; i++) {
127             //闰月
128             if (leap > 0 && i == (leap + 1) && !isLeap) {
129                 isLeap = true;
130                 if ((lunar_info[myYear - 1900] & 0xf) != 0) {
131                     daysOfLeapMonth = (lunar_info[myYear - 1900] & 0x10000) == 0 ? 29 : 30;
132                 } else {
133                     daysOfLeapMonth = 0;
134                 }
135                 --i;
136             } else {
137                 daysOfLeapMonth = (lunar_info[myYear - 1900] & (0x10000 >> i)) == 0 ? 29 : 30;
138             }
139             //设置非闰月
140             if (isLeap && i == (leap + 1)) {
141                 isLeap = false;
142             }
143             days_distance -= daysOfLeapMonth;
144             if (!isLeap) {
145                 month_ganZhi++;
146             }
147         }
148         if (days_distance == 0 && leap > 0 && i == leap + 1 && !isLeap) {
149             --month_ganZhi;
150         }
151         if (days_distance < 0) {
152             --month_ganZhi;
153         }
154     }
155 
156     /**
157      * 将年月日转化为天干地支的显示方法
158      * @param index
159      * @return
160      */
161     private String ganZhi(int index) {
162         return gan_info[index % 10] + zhi_info[index % 12];
163     }
164 
165     /**
166      * 获取天干地支
167      * @return
168      */
169     public String getGanZhi() {
170         return "农历" + ganZhi(year_ganZhi) + "年 " + ganZhi(month_ganZhi) + "月 " + ganZhi(day_ganZhi) + "日";
171     }
172 }

三、基本概念

天干地支，源自于中国远古时代对天象的观测。十干日：阏逢、旃蒙、柔兆、强圉、著雍、屠维、上章、重光、玄黓、昭阳。十二支日：困顿、赤奋若、摄提格、单阏、执徐、大荒落、敦牂、协洽、涒滩、作噩、阉茂、大渊献。

简化后的天干地支：“甲、乙、丙、丁、戊、己、庚、辛、壬、癸”称为十天干，“子、丑、寅、卯、辰、巳、午、未、申、酉、戌、亥”称为十二地支。

参考文章

转载于:https://www.cnblogs.com/doubleWin/p/10690127.html

java 天干地支计算天干地支计算时辰_mob6454cc6f8e48的技术博客_51CTO博客

java获取每天的农历 java农历日历_attitude的技术博客_51CTO博客

AI的实现思路

从1开始，0为10

天干地支的计算方法：比如，年柱的天干是（年份-3）%10，地支是（年份-3）%12。比如2023年，年干是（2023-3）%10=0，对应癸；地支是（2023-3）%12=2020%12=4，对应卯。所以2023年是癸卯年。年柱的天干地支需要农历转换

月份的地支是固定的，比如正月为寅，二月为卯，依此类推。但月份的天干需要根据年干来计算。比如，甲己之年丙作首，乙庚之岁戊为头，等等。所以，月干需要先知道年干，然后根据口诀确定。比如，年干是甲或己，那么正月的月干是丙，二月是丁，依此类推。

日的天干地支计算比较复杂。通常需要知道公历日期对应的儒略日数，然后根据公式计算。或者有没有更简单的方法？或者可能需要依赖已有的库，比如使用Java的Calendar类获取日期，然后应用某种算法。例如，日柱的计算公式可能为：根据某个基准日的天干地支，计算目标日期与基准日的天数差，然后模60得到干支序号。例如，已知公历2020年1月1日是己亥日（对应序号可能是某个数值），然后计算相差天数，再得到对应的干支。这可能需要预先知道一个基准点。

时辰的地支是固定的，根据小时来定。比如23-1点是子时，1-3点是丑时，依此类推。每个时辰对应的天干则由日干来决定，有相应的口诀。例如，甲己还加甲，乙庚丙作初，等等。比如，日干是甲或己，那么子时的天干是甲，丑时是乙，依此类推。

所以，总的步骤可能是：

1. 输入公历年月日和时间（小时）。

2. 计算年柱的天干地支。

3. 计算月柱的天干地支（需要年干）。

4. 计算日柱的天干地支（可能需要基准日）。

5. 计算时柱的天干地支（需要日干）。

6. 将这四个柱的天干地支转换为对应的五行属性。

7. 根据命理规则（比如年柱纳音，或者日柱的天干作为日主，其他柱的五行与日主的生克关系等）来确定五行属性。但用户可能只需要得到各柱的五行，或者某种综合计算？

附

以下是一个使用LunarCalendar库进行农历和公历转换的Java示例代码：

javaCopy Code

import com.xhinliang.LunarCalendar; // 假定的导入路径，请根据实际项目调整

public class LunarDemo {
    public static void main(String[] args) {
        LunarCalendar lunar = new LunarCalendar();

        // 将公历转为农历
        String lunarDate = lunar.solarToLunar(2023, 3, 1); // 假设方法接受年月日作为参数
        System.out.println("对应的农历日期: " + lunarDate);
    }
}

以下是几个常用的 Java 农历（阴历）库的下载和集成方式：

1. lunar-java

一个轻量、开源的农历和节气计算库，支持公历与农历的相互转换、节气查询等功能。

<dependency>
  <groupId>cn.6tail</groupId>
  <artifactId>lunar-java</artifactId>
  <version>1.3.1</version>
</dependency>

3. ChineseLunarCalendar

一个简单的农历日期转换工具。

GitHub 仓库：
https://github.com/yccheok/joda-time-chinese

Maven 依赖：

xml

<dependency>
  <groupId>org.yccheok</groupId>
  <artifactId>joda-time-chinese</artifactId>
  <version>1.0.0</version>
</dependency>

import cn.6tail.lunar.LunarUtil;

// 公历转农历
String lunarDate = LunarUtil.solarToLunar(2023, 10, 1);
System.out.println("农历日期：" + lunarDate); // 输出：2023-八月-十七