通过Java日期时间API系列7-----Jdk8中java.time包中的新的日期时间API类的优点，java8具有很多优点，现在网上查到的农历转换工具类都是基于jdk7及以前的类写的，下面使用java新的日期时间API重写农历LunarDate。

1. version 0.1版本 农历原始算法来自网络，有2个问题：

（1）com.xkzhangsan.time.LunarDate.lunarInfo 数据有误，导致个别农历计算不准确。

（2）没有二十四节气计算。

2.version 0.2版本修改了上面问题：

  1. package com.xkzhangsan.time;
  2.  
  3. import java.time.Instant;
  4. import java.time.LocalDate;
  5. import java.time.LocalDateTime;
  6. import java.time.temporal.Temporal;
  7. import java.time.temporal.TemporalField;
  8. import java.time.temporal.TemporalUnit;
  9. import java.util.Date;
  10.  
  11. import com.xkzhangsan.time.calculator.DateTimeCalculatorUtil;
  12. import com.xkzhangsan.time.converter.DateTimeConverterUtil;
  13. import com.xkzhangsan.time.holiday.ChineseHolidayEnum;
  14.  
  15. /**
  16.  * 农历日期
  17.  * 仅支持公历1901-1950年的农历转换
  18. * @ClassName: LunarDate
  19. * @Description: LunarDate
  20. * @author xkzhangsan
  21. * @date 2019年12月30日
  22. * @version 0.2 试用
  23.  */
  24. public final class LunarDate implements Temporal{
  25.  
  26.     /**
  27.      * 农历信息
  28.      */
  29.     private static final long[] lunarInfo = new long[] { 0x04bd8, 0x04ae0, 0x0a570, 0x054d5, 0x0d260, 0x0d950, 0x16554,
  30.             0x056a0, 0x09ad0, 0x055d2, 0x04ae0, 0x0a5b6, 0x0a4d0, 0x0d250, 0x1d255, 0x0b540, 0x0d6a0, 0x0ada2, 0x095b0,
  31.             0x14977, 0x04970, 0x0a4b0, 0x0b4b5, 0x06a50, 0x06d40, 0x1ab54, 0x02b60, 0x09570, 0x052f2, 0x04970, 0x06566,
  32.             0x0d4a0, 0x0ea50, 0x06e95, 0x05ad0, 0x02b60, 0x186e3, 0x092e0, 0x1c8d7, 0x0c950, 0x0d4a0, 0x1d8a6, 0x0b550,
  33.             0x056a0, 0x1a5b4, 0x025d0, 0x092d0, 0x0d2b2, 0x0a950, 0x0b557, 0x06ca0, 0x0b550, 0x15355, 0x04da0, 0x0a5b0,
  34.             0x14573, 0x052b0, 0x0a9a8, 0x0e950, 0x06aa0, 0x0aea6, 0x0ab50, 0x04b60, 0x0aae4, 0x0a570, 0x05260, 0x0f263,
  35.             0x0d950, 0x05b57, 0x056a0, 0x096d0, 0x04dd5, 0x04ad0, 0x0a4d0, 0x0d4d4, 0x0d250, 0x0d558, 0x0b540, 0x0b6a0,
  36.             0x195a6, 0x095b0, 0x049b0, 0x0a974, 0x0a4b0, 0x0b27a, 0x06a50, 0x06d40, 0x0af46, 0x0ab60, 0x09570, 0x04af5,
  37.             0x04970, 0x064b0, 0x074a3, 0x0ea50, 0x06b58, 0x055c0, 0x0ab60, 0x096d5, 0x092e0, 0x0c960, 0x0d954, 0x0d4a0,
  38.             0x0da50, 0x07552, 0x056a0, 0x0abb7, 0x025d0, 0x092d0, 0x0cab5, 0x0a950, 0x0b4a0, 0x0baa4, 0x0ad50, 0x055d9,
  39.             0x04ba0, 0x0a5b0, 0x15176, 0x052b0, 0x0a930, 0x07954, 0x06aa0, 0x0ad50, 0x05b52, 0x04b60, 0x0a6e6, 0x0a4e0,
  40.             0x0d260, 0x0ea65, 0x0d530, 0x05aa0, 0x076a3, 0x096d0, 0x04bd7, 0x04ad0, 0x0a4d0, 0x1d0b6, 0x0d250, 0x0d520,
  41.             0x0dd45, 0x0b5a0, 0x056d0, 0x055b2, 0x049b0, 0x0a577, 0x0a4b0, 0x0aa50, 0x1b255, 0x06d20, 0x0ada0,
  42.             0x14b63 };
  43.  
  44.     /**
  45.      * 农历月份列表
  46.      */
  47.     public static final String[] lunarMonth = new String[] { "", "正", "二", "三", "四", "五", "六", "七", "八", "九", "十", "冬",
  48.             "腊" };
  49.  
  50.     /**
  51.      * 天干列表
  52.      */
  53.     private static final String[] tianGan = new String[] { "甲", "乙", "丙", "丁", "戊", "己", "庚", "辛", "壬", "癸" };
  54.  
  55.     /**
  56.      * 地支列表
  57.      */
  58.     private static final String[] diZhi = new String[] { "子", "丑", "寅", "卯", "辰", "巳", "午", "未", "申", "酉", "戌", "亥" };
  59.  
  60.     /**
  61.      * 生肖列表
  62.      */
  63.     private static final String[] animals = new String[] { "鼠", "牛", "虎", "兔", "龙", "蛇", "马", "羊", "猴", "鸡", "狗", "猪" };
  64.  
  65.     /**
  66.      * 中文数字0-9
  67.      */
  68.     public static final String[] numStr = new String[] { "〇", "一", "二", "三", "四", "五", "六", "七", "八", "九"};    
  69.  
  70.     /**
  71.      * 二十四节气
  72.      */
  73.     public static final String[] solarTerms = new String[] {"小寒","大寒","立春","雨水","惊蛰","春分","清明","谷雨","立夏","小满","芒种","夏至","小暑","大暑","立秋","处暑","白露","秋分","寒露","霜降","立冬","小雪","大雪","冬至"};
  74.  
  75.     /**
  76.      * 二十四节气数据
  77.      */
  78.     private static final long[] solarTermInfo = new long[] {0,21208,42467,63836,85337,107014,128867,150921,173149,195551,218072,240693,263343,285989,308563,331033,353350,375494,397447,419210,440795,462224,483532,504758};
  79.  
  80.     /**
  81.      * 标准日期
  82.      */
  83.     private final LocalDate localDate;
  84.  
  85.     /**
  86.      * 农历日期，中文
  87.      */
  88.     private String lDateCn;
  89.  
  90.     /**
  91.      * 岁次
  92.      */
  93.     private String suiCi;
  94.  
  95.     /**
  96.      * 生肖
  97.      */
  98.     private String lAnimal;
  99.  
  100.     /**
  101.      * 农历年
  102.      */
  103.     private int lYear;
  104.  
  105.     /**
  106.      * 农历月
  107.      */
  108.     private int lMonth;
  109.  
  110.     /**
  111.      * 农历日
  112.      */
  113.     private int lDay;
  114.  
  115.     /**
  116.      * 农历年，中文
  117.      */
  118.     private String lYearCn;
  119.  
  120.     /**
  121.      * 农历月，中文
  122.      */
  123.     private String lMonthCn;
  124.  
  125.     /**
  126.      * 农历日，中文
  127.      */
  128.     private String lDayCn;
  129.  
  130.     /**
  131.      * 星期，中文
  132.      */
  133.     private String weekCn;
  134.  
  135.     /**
  136.      * 二十四节气
  137.      */
  138.     private String solarTerm;
  139.  
  140.     /**
  141.      * 当前日期月份是否为闰月，是 为"闰"
  142.      */
  143.     private String leapMonthCn;
  144.  
  145.     private LunarDate(LocalDate localDate) {
  146.         super();
  147.         this.localDate = localDate;
  148.         initialize();
  149.     }
  150.  
  151.     /**
  152.      * 初始化农历日期
  153.      */
  154.     public void initialize() {
  155.         int year = localDate.getYear();
  156.         int month = localDate.getMonthValue();
  157.         int day = localDate.getDayOfMonth();
  158.         long[] l = calElement(year, month, day);
  159.  
  160.         this.lYear = (int) l[0];
  161.         this.lMonth = (int) l[1];
  162.         this.lDay = (int) l[2];
  163.  
  164.         this.suiCi = cyclical(this.lYear);
  165.         this.lAnimal = animalsYear(this.lYear);
  166.  
  167.         this.lYearCn = getChinaYear(this.lYear);
  168.         this.lMonthCn = lunarMonth[this.lMonth];
  169.         this.lDayCn = getChinaDay(this.lDay);
  170.  
  171.         this.weekCn = getWeekCn(localDate.getDayOfWeek().getValue());
  172.         if(l[7] != -1){
  173.             this.solarTerm = solarTerms[(int)l[7]];
  174.         }else{
  175.             this.solarTerm = "";
  176.         }
  177.         if(l[6] == 1){
  178.             this.leapMonthCn = "闰";
  179.         }else{
  180.             this.leapMonthCn = "";
  181.         }
  182.         this.lDateCn = this.lYearCn + "年" + this.leapMonthCn + this.lMonthCn + "月" + this.lDayCn;
  183.     }
  184.  
  185.     /**
  186.      * 通过LocalDateTime创建LunarDate
  187.      * @param localDateTime
  188.      * @return
  189.      */
  190.     public static LunarDate from(LocalDateTime localDateTime) {
  191.         return new LunarDate(DateTimeConverterUtil.toLocalDate(localDateTime));
  192.     }
  193.  
  194.     /**
  195.      * 通过LocalDate创建LunarDate
  196.      * @param localDate
  197.      * @return
  198.      */
  199.     public static LunarDate from(LocalDate localDate) {
  200.         return new LunarDate(localDate);
  201.     }
  202.  
  203.     /**
  204.      * 通过Instant创建LunarDate
  205.      * @param instant
  206.      * @return
  207.      */
  208.     public static LunarDate from(Instant instant) {
  209.         return new LunarDate(DateTimeConverterUtil.toLocalDate(instant));
  210.     }    
  211.  
  212.     /**
  213.      * 通过Date创建LunarDate
  214.      * @param date
  215.      * @return
  216.      */
  217.     public static LunarDate from(Date date) {
  218.         return new LunarDate(DateTimeConverterUtil.toLocalDate(date));
  219.     }
  220.  
  221.     public static LunarDate from(Temporal temporal) {
  222.         return new LunarDate(DateTimeConverterUtil.toLocalDate(temporal));
  223.     }
  224.  
  225.     /**
  226.      * 传回农历year年的总天数
  227.      *
  228.      * @param year
  229.      * @return
  230.      */
  231.     private static final int lunarYearDays(int year) {
  232.         int i, sum = 348;
  233.         for (i = 0x8000; i > 0x8; i >>= 1) {
  234.             if ((lunarInfo[year - 1900] & i) != 0)
  235.                 sum += 1;
  236.         }
  237.         return (sum + leapMonthDays(year));
  238.     }
  239.  
  240.     /**
  241.      * 传回农历 year年闰月的天数
  242.      *
  243.      * @param year
  244.      * @return
  245.      */
  246.     private static final int leapMonthDays(int year) {
  247.         if (leapMonth(year) != 0) {
  248.             if ((lunarInfo[year - 1900] & 0x10000) != 0)
  249.                 return 30;
  250.             else
  251.                 return 29;
  252.         } else
  253.             return 0;
  254.     }
  255.  
  256.     /**
  257.      * 传回农历 year年闰哪个月 1-12 , 没闰传回 0
  258.      *
  259.      * @param year
  260.      * @return
  261.      */
  262.     private static final int leapMonth(int year) {
  263.         return (int) (lunarInfo[year - 1900] & 0xf);
  264.     }
  265.  
  266.     /**
  267.      * 传回农历 year年month月的总天数
  268.      *
  269.      * @param year
  270.      * @param month
  271.      * @return
  272.      */
  273.     private static final int monthDays(int year, int month) {
  274.         if ((lunarInfo[year - 1900] & (0x10000 >> month)) == 0)
  275.             return 29;
  276.         else
  277.             return 30;
  278.     }
  279.  
  280.     /**
  281.      * 传回农历 year年的生肖
  282.      *
  283.      * @param year
  284.      * @return
  285.      */
  286.     public static final String animalsYear(int year) {
  287.         return animals[(year - 4) % 12];
  288.     }
  289.  
  290.     /**
  291.      * 传入 月日的offset 传回干支,0=甲子
  292.      *
  293.      * @param num
  294.      * @return
  295.      */
  296.     private static final String cyclicalm(int num) {
  297.         return (tianGan[num % 10] + diZhi[num % 12]);
  298.     }
  299.  
  300.     /**
  301.      * 传入 offset 传回干支, 0=甲子
  302.      *
  303.      * @param year
  304.      * @return
  305.      */
  306.     public static final String cyclical(int year) {
  307.         int num = year - 1900 + 36;
  308.         return (cyclicalm(num));
  309.     }
  310.  
  311.     /**
  312.      * 计算某年第n个节气的天
  313.      * @param year 公历年
  314.      * @param n
  315.      * @return
  316.      */
  317.     public static final int solarTerm(int year, int n){
  318.         LocalDateTime startLocalDateTime = LocalDateTime.of(1900,1,6,2,5);
  319.         long millis = (long) ((31556925974.7*(year-1900) + solarTermInfo[n]*60000));
  320.         LocalDateTime tempLocalDateTime = DateTimeCalculatorUtil.plusMillis(startLocalDateTime, millis);
  321.         return tempLocalDateTime.getDayOfMonth();
  322.     }
  323.  
  324.     /**
  325.      * 传出year年month月day日对应的农历.year0 .month1 .day2 .yearCyl3 .monCyl4 .dayCyl5
  326.      * .isLeap6.solarTermIndex7
  327.      *
  328.      * @param year
  329.      * @param month
  330.      * @param day
  331.      * @return
  332.      */
  333.     public static final long[] calElement(int year, int month, int day) {
  334.         long[] nongDate = new long[8];
  335.         int i = 0, temp = 0, leap = 0;
  336.         LocalDateTime baseDate = LocalDate.of(1900, 1, 31).atStartOfDay();
  337.         LocalDateTime objDate = LocalDate.of(year, month, day).atStartOfDay();
  338.         long offset = DateTimeCalculatorUtil.betweenTotalDays(baseDate, objDate);
  339.         nongDate[5] = offset + 40;
  340.         nongDate[4] = 14;
  341.         for (i = 1900; i < 2050 && offset > 0; i++) {
  342.             temp = lunarYearDays(i);
  343.             offset -= temp;
  344.             nongDate[4] += 12;
  345.         }
  346.         if (offset < 0) {
  347.             offset += temp;
  348.             i--;
  349.             nongDate[4] -= 12;
  350.         }
  351.         nongDate[0] = i;
  352.         nongDate[3] = i - 1864;
  353.         leap = leapMonth(i); // 闰哪个月
  354.         nongDate[6] = 0;
  355.         for (i = 1; i < 13 && offset > 0; i++) {
  356.             // 闰月
  357.             if (leap > 0 && i == (leap + 1) && nongDate[6] == 0) {
  358.                 --i;
  359.                 nongDate[6] = 1;
  360.                 temp = leapMonthDays((int) nongDate[0]);
  361.             } else {
  362.                 temp = monthDays((int) nongDate[0], i);
  363.             }
  364.             // 解除闰月
  365.             if (nongDate[6] == 1 && i == (leap + 1))
  366.                 nongDate[6] = 0;
  367.             offset -= temp;
  368.             if (nongDate[6] == 0)
  369.                 nongDate[4]++;
  370.         }
  371.         if (offset == 0 && leap > 0 && i == leap + 1) {
  372.             if (nongDate[6] == 1) {
  373.                 nongDate[6] = 0;
  374.             } else {
  375.                 nongDate[6] = 1;
  376.                 --i;
  377.                 --nongDate[4];
  378.             }
  379.         }
  380.         if (offset < 0) {
  381.             offset += temp;
  382.             --i;
  383.             --nongDate[4];
  384.         }
  385.         nongDate[1] = i;
  386.         nongDate[2] = offset + 1;
  387.  
  388.         //二十四节气
  389.         int solarTermIndex = -1;
  390.         int tempMonth = month - 1;
  391.         int firstSolarTermOfMonth = solarTerm(year, tempMonth*2);
  392.         int secondSolarTermOfMonth = solarTerm(year, tempMonth*2+1);
  393.         if(day == firstSolarTermOfMonth){
  394.             solarTermIndex = tempMonth*2;
  395.         }else if(day == secondSolarTermOfMonth){
  396.             solarTermIndex = tempMonth*2 + 1;
  397.         }
  398.         nongDate[7] = solarTermIndex;
  399.         return nongDate;
  400.     }
  401.  
  402.     /**
  403.      * 获取农历中文年
  404.      * @param year
  405.      * @return
  406.      */
  407.     public final static String getChinaYear(int year) {
  408.         String ge = numStr[year % 10];
  409.         String shi = numStr[year / 10 % 10];
  410.         String bai = numStr[year / 100 % 10];
  411.         String qian = numStr[year / 1000 % 10];
  412.         return qian + bai + shi + ge;
  413.     }
  414.     /**
  415.      * 获取农历中文日期
  416.      * @param day
  417.      * @return
  418.      */
  419.     public final static String getChinaDay(int day) {
  420.         String a = "";
  421.         if (day == 10)
  422.             return "初十";
  423.         if (day == 20)
  424.             return "二十";
  425.         if (day == 30)
  426.             return "三十";
  427.         int two = (int) ((day) / 10);
  428.         if (two == 0)
  429.             a = "初";
  430.         if (two == 1)
  431.             a = "十";
  432.         if (two == 2)
  433.             a = "廿";
  434.         if (two == 3)
  435.             a = "三";
  436.         int one = (int) (day % 10);
  437.         switch (one) {
  438.         case 1:
  439.             a += "一";
  440.             break;
  441.         case 2:
  442.             a += "二";
  443.             break;
  444.         case 3:
  445.             a += "三";
  446.             break;
  447.         case 4:
  448.             a += "四";
  449.             break;
  450.         case 5:
  451.             a += "五";
  452.             break;
  453.         case 6:
  454.             a += "六";
  455.             break;
  456.         case 7:
  457.             a += "七";
  458.             break;
  459.         case 8:
  460.             a += "八";
  461.             break;
  462.         case 9:
  463.             a += "九";
  464.             break;
  465.         default:
  466.             a += "";
  467.             break;
  468.         }
  469.         return a;
  470.     }
  471.  
  472.     /**
  473.      * 获取中文星期
  474.      * @param week
  475.      * @return
  476.      */
  477.     public final static String getWeekCn(int week) {
  478.         String weekCn = "";
  479.         switch (week) {
  480.         case 1:
  481.             weekCn = "星期一";
  482.             break;
  483.         case 2:
  484.             weekCn = "星期二";
  485.             break;
  486.         case 3:
  487.             weekCn = "星期三";
  488.             break;
  489.         case 4:
  490.             weekCn = "星期四";
  491.             break;
  492.         case 5:
  493.             weekCn = "星期五";
  494.             break;
  495.         case 6:
  496.             weekCn = "星期六";
  497.             break;
  498.         case 7:
  499.             weekCn = "星期日";
  500.             break;
  501.         default:
  502.             weekCn = "";
  503.             break;
  504.         }
  505.         return weekCn;
  506.     }
  507.  
  508.     /**
  509.      * 以当前时间创建农历日期LunarDate
  510.      * @return
  511.      */
  512.     public static LunarDate now() {
  513.         LocalDate today = LocalDate.now();
  514.         return new LunarDate(today);
  515.     }
  516.  
  517.     public LocalDate getLocalDate() {
  518.         return localDate;
  519.     }
  520.  
  521.     public String getlDateCn() {
  522.         return lDateCn;
  523.     }
  524.  
  525.     public String getSuiCi() {
  526.         return suiCi;
  527.     }
  528.  
  529.     public String getlAnimal() {
  530.         return lAnimal;
  531.     }
  532.  
  533.     public int getlYear() {
  534.         return lYear;
  535.     }
  536.  
  537.     public int getlMonth() {
  538.         return lMonth;
  539.     }
  540.  
  541.     public int getlDay() {
  542.         return lDay;
  543.     }
  544.  
  545.     public String getlYearCn() {
  546.         return lYearCn;
  547.     }
  548.  
  549.     public String getlMonthCn() {
  550.         return lMonthCn;
  551.     }
  552.  
  553.     public String getlDayCn() {
  554.         return lDayCn;
  555.     }
  556.  
  557.     public String getWeekCn() {
  558.         return weekCn;
  559.     }
  560.  
  561.     public String getSolarTerm() {
  562.         return solarTerm;
  563.     }
  564.  
  565.     public String getLeapMonthCn() {
  566.         return leapMonthCn;
  567.     }
  568.  
  569.     @Override
  570.     public String toString() {
  571.         return "LunarDate [localDate=" + localDate + ",lDateCn=" + lDateCn + ", suiCi=" + suiCi + ", lAnimal=" + lAnimal + ", lYear=" + lYear
  572.                 + ", lMonth=" + lMonth + ", lDay=" + lDay + ", lYearCn=" + lYearCn + ", lMonthCn=" + lMonthCn
  573.                 + ", lDayCn=" + lDayCn + ", weekCn=" + weekCn + ", solarTerm=" + solarTerm + ", leapMonthCn=" + leapMonthCn + "]";
  574.     }
  575.  
  576.     /**
  577.      * 格式化输出，如：庚子鼠年 二〇二〇年正月初一 星期六 春节
  578.      * @return
  579.      */
  580.     public String formatLongCnWithChineseHoliday(){
  581.         return suiCi + lAnimal + "年 " + lDateCn + " " + weekCn + " " + ChineseHolidayEnum.getHoliday(localDate).getName();
  582.     }    
  583.  
  584.     /**
  585.      * 格式化输出，如： 己亥猪年 二〇一九年腊月初六 星期二
  586.      * @return
  587.      */
  588.     public String formatLongCn(){
  589.         return suiCi + lAnimal + "年 " + lDateCn + " " + weekCn;
  590.     }
  591.  
  592.     /**
  593.      * 格式化输出，如： 0101
  594.      * @return
  595.      */
  596.     public String formatShort(){
  597.         return String.format("%02d", lMonth) + String.format("%02d", lDay);
  598.     }
  599.  
  600.     @Override
  601.     public boolean isSupported(TemporalField field) {
  602.         return localDate.isSupported(field);
  603.     }
  604.  
  605.     @Override
  606.     public long getLong(TemporalField field) {
  607.         return localDate.getLong(field);
  608.     }
  609.  
  610.     @Override
  611.     public boolean isSupported(TemporalUnit unit) {
  612.         return localDate.isSupported(unit);
  613.     }
  614.  
  615.     @Override
  616.     public Temporal with(TemporalField field, long newValue) {
  617.         return localDate.with(field, newValue);
  618.     }
  619.  
  620.     @Override
  621.     public Temporal plus(long amountToAdd, TemporalUnit unit) {
  622.         return localDate.plus(amountToAdd, unit);
  623.     }
  624.  
  625.     @Override
  626.     public long until(Temporal endExclusive, TemporalUnit unit) {
  627.         return localDate.until(endExclusive, unit);
  628.     }
  629.  
  630.     public static void main(String[] args) {
  631.         String str =LunarDate.now().toString();
  632.         System.out.println(str);
  633.     }
  634.  
  635. }

输出：

  1. LunarDate [localDate=2020-03-22,lDateCn=二〇二〇年二月廿九, suiCi=庚子, lAnimal=鼠, lYear=2020, lMonth=2, lDay=29, lYearCn=二〇二〇, lMonthCn=二, lDayCn=廿九, weekCn=星期日, solarTerm=, leapMonthCn=]

源码地址：https://github.com/xkzhangsan/xk-time

Java日期时间API系列11-----Jdk8中java.time包中的新的日期时间API类，使用java8日期时间API重写农历LunarDate的更多相关文章

  1. 在swt中获取jar包中的文件 uri is not hierarchical

    uri is not hierarchical 学习了:http://blog.csdn.net/zdsdiablo/article/details/1519719 在swt中获取jar包中的文件: ...

  2. API接口自动化之3 同一个war包中多个接口做自动化测试

    同一个war包中多个接口做自动化测试 一个接口用一个测试类,每个测试用例如下,比如下面是4个测试用例,每个详细的测试用例中含有请求入参,返回体校验,以此来判断每条测试用例是否通过 一个war包中,若含 ...

  3. Andriod项目开发实战（1）——如何在Eclipse中的一个包下建新包

    最开始是想将各个类分门别类地存放在不同的包中,所以想在项目源码包中新建几个不同功能的包eg:utils.model.receiver等,最后的结果应该是下图左边这样的:   很明显建立项目后的架构是上 ...

  4. Mac 如何导出ipa文件中Assets.car包中的切图

    在之前 获取 AppStore 中 应用 的 IPA 包文件(Mac OS 13+)中获取到应用的 IPA 包,可以取出应用的部分图片(如 Logo),如果项目工程中把图片添加到 Assets.xca ...

  5. JDK中的Atomic包中的类及使用

    引言 Java从JDK1.5开始提供了java.util.concurrent.atomic包,方便程序员在多线程环境下,无锁的进行原子操作.原子变量的底层使用了处理器提供的原子指令,但是不同的CPU ...

  6. 【转】Eclipse中查看jar包中的源码

    (简单的方式:通过jd-gui来进行反编译,最简单!,参考我的另一篇博文, 地址:http://www.cnblogs.com/gmq-sh/p/4277991.html) Java Decompil ...

  7. Package.json中dependencies依赖包中^符号和~符号前缀的区别

    刚git了webpack的包发现package.json里面dependencies依赖包的版本号前面的符号有两种,一种是~,一种是^,如下图标记: 然后搜了下在stackoverflow上找到一个比 ...

  8. Java日期时间API系列6-----Jdk8中java.time包中的新的日期时间API类

    因为Jdk7及以前的日期时间类的不方便使用问题和线程安全问题等问题,2005年,Stephen Colebourne创建了Joda-Time库,作为替代的日期和时间API.Stephen向JCP提交了 ...

  9. Redis总结（五）缓存雪崩和缓存穿透等问题 Web API系列(三)统一异常处理 C#总结（一）AutoResetEvent的使用介绍（用AutoResetEvent实现同步） C#总结（二）事件Event 介绍总结 C#总结（三）DataGridView增加全选列 Web API系列(二)接口安全和参数校验 RabbitMQ学习系列（六）: RabbitMQ 高可用集群

    Redis总结(五)缓存雪崩和缓存穿透等问题   前面讲过一些redis 缓存的使用和数据持久化.感兴趣的朋友可以看看之前的文章,http://www.cnblogs.com/zhangweizhon ...

随机推荐

  1. 【题解】Rusty String [CF827E]

    [题解]Rusty String [CF827E] 传送门:\(\text{Rusty String}\) \(\text{[CF827E]}\) [题目描述] 多组数据,每组数据给出一个由 \(V, ...

  2. php自动读取文件夹下所有图片

    $path = 'xxxxx';///当前目录$handle = opendir($path); //当前目录while (false !== ($file = readdir($handle))) ...

  3. Atcoder Beginner Contest145E（01背包记录路径）

    #define HAVE_STRUCT_TIMESPEC#include<bits/stdc++.h>using namespace std;int a[3007],b[3007];int ...

  4. Go类型断言

    package main import ( "fmt" ) type Point struct { x int y int } func main() { var a interf ...

  5. Hadoop学习1—浅谈hadoop

    大数据这个词越来越热,本人一直想学习一下,正巧最近有时间了解一下.先从hadoop入手,在此记录学习中的点滴. 什么是hadoop? What Is Apache Hadoop? The Apache ...

  6. python练习：使用二分法查找求近似平方根，使用二分法查找求近似立方根。

    python练习:使用二分法查找求近似平方根,使用二分法查找求近似立方根. 重难点:原理为一个数的平方根一定在,0到这个数之间,那么就对这之间的数,进行二分遍历.精确度的使用.通过最高值和最低值确定二 ...

  7. Codeforces 1045F Shady Lady 凸包+数学

    题目链接:https://codeforc.es/contest/1045/problem/F 题意:先给出一个系数不确定的二元多项式,Borna可以给这个多项式的每一项填上正的系数,Ani能从这个多 ...

  8. ASP.NET Core搭建多层网站架构【9.2-使用Castle.Core实现动态代理拦截器】

    2020/01/31, ASP.NET Core 3.1, VS2019, Autofac.Extras.DynamicProxy 4.5.0, Castle.Core.AsyncIntercepto ...

  9. 【Go语言系列】1.2、GO语言简介：哪些大公司正在使用Go语言

    Go语言的强项在于它适合用来开发网络并发方面的服务,比如消息推送.监控.容器等,所以在高并发的项目上大多数公司会优先选择 Golang 作为开发语言. 1.Google 这个不用多做介绍,作为开发Go ...

  10. 喵星之旅-狂奔的兔子-基于docker的redis分布式集群

    一.docker安装(略) 二.下载redis安装包(redis-4.0.8.tar.gz) 以任何方式获取都可以.自行官网下载. 三.拉取centos7的docker镜像 命令:docker pul ...