Java封装常用时间工具类

蔚落 2022-01-15 00:45 354阅读 0赞 
  1. public class DateUtils {
  3.     /** 系统默认 日期类型 yyyy-MM-dd */
  4.     public static final String DATE_PATTERN_DEFAULT = "yyyy-MM-dd";
  6.     /** 时间 日期类型 HH:mm:ss */
  7.     public static final String DATE_PATTERN_TIME = "HH:mm:ss";
  9.     /** 日期时间 日期类型 yyyy-MM-dd HH:mm:ss */
  10.     public static final String DATE_PATTERN_DATETIME = "yyyy-MM-dd HH:mm:ss";
  12.     /** 时期格式 yyyy-MM-dd */
  13.     public static DateFormat dateformater;
  15.     /** 时间格式 HH:mm:ss */
  16.     public static DateFormat timeformater;
  18.     /** 日期时间格式 yyyy-MM-dd HH:mm */
  19.     public static DateFormat dateTimeformater;
  21.     static {
  22.         if (DateUtils.dateformater == null) {
  23.             DateUtils.dateformater = new SimpleDateFormat(DateUtils.DATE_PATTERN_DEFAULT);
  24.         }
  25.         if (DateUtils.timeformater == null) {
  26.             DateUtils.timeformater = new SimpleDateFormat(DateUtils.DATE_PATTERN_TIME);
  27.         }
  29.         if (DateUtils.dateTimeformater == null) {
  30.             DateUtils.dateTimeformater = new SimpleDateFormat(DateUtils.DATE_PATTERN_DATETIME);
  31.         }
  32.     }
  34.     /** 一天毫秒数 */
  35.     public static final long DAY_IN_MILLISECOND = 1000 * 3600 * 24;
  37.     /** 一小时毫秒数 */
  38.     public static final long HOUR_IN_MILLISECOND = 1000 * 3600;
  40.     /** 构造方法私有化 */
  41.     private DateUtils() {
  42.     }
  44.     /**
  45.      * 得到现在时间
  46.      *
  47.      * @return 字符串 yyyyMMdd HHmmss
  48.      */
  49.     public static String getStringToday() {
  50.         final Date currentTime = new Date();
  51.         final SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMddHHmmss");
  52.         final String dateString = formatter.format(currentTime);
  53.         return dateString;
  54.     }
  56.     /**
  57.      *
  58.      * 根据 yyyy-MM-dd 字符串解析成相应的日期
  59.      *
  60.      * @param strDate
  61.      *            yyyy-MM-dd 格式的日期
  62.      *
  63.      * @return 转换后的日期
  64.      *
  65.      */
  66.     public static Date parseDate(String strDate) {
  67.         Date date = null;
  68.         if (StringUtils.isNotBlank(strDate)) {
  69.             try {
  70.                 date = DateUtils.dateformater.parse(strDate);
  71.             }
  72.             catch (final Exception e) {
  73.                 e.printStackTrace();
  74.                 return date;
  75.             }
  76.         }
  77.         return date;
  78.     }
  80.     /**
  81.      *
  82.      * 根据传入的日期格式 将字符串解析成 日期类型
  83.      *
  84.      * @param strDate
  85.      *            日期字符串
  86.      *
  87.      * @param pattern
  88.      *            日期格式 如果传入格式为空，则为默认格式 yyyy-MM-dd
  89.      *
  90.      * @return 日期类型
  91.      *
  92.      */
  93.     public static Date parseDate(String strDate, String pattern) {
  94.         Date date = null;
  95.         try {
  96.             final DateFormat format = DateUtils.getDateFormat(pattern);
  97.             date = format.parse(strDate);
  98.         }
  99.         catch (final Exception e) {
  100.             e.printStackTrace();
  101.             return date;
  102.         }
  103.         return date;
  104.     }
  106.     /**
  107.      *
  108.      * 根据 HH:mm:ss 字符串解析成相应的时间格式
  109.      *
  110.      * @param strTime
  111.      *            HH:mm:ss 格式的时间格式
  112.      *
  113.      * @return 转换后的时间
  114.      *
  115.      */
  116.     public static Date parseTime(String strTime) {
  117.         Date date = null;
  118.         try {
  119.             date = DateUtils.timeformater.parse(strTime);
  120.         }
  121.         catch (final Exception e) {
  122.             e.printStackTrace();
  123.             return date;
  124.         }
  125.         return date;
  126.     }
  128.     /**
  129.      *
  130.      * 根据yyyy-MM-dd HH:mm字符串解析成相应的日期时间
  131.      * @param strDateTime 以"yyyy-MM-dd HH:mm:ss"为格式的时间字符串
  132.      * @return 转换后的日期
  133.      *
  134.      */
  135.     public static Date parseDateTime(String strDateTime) {
  136.         Date date = new Date();
  137.         try {
  138.             date = DateUtils.dateTimeformater.parse(strDateTime);
  139.         }
  140.         catch (final Exception e) {
  141.             e.printStackTrace();
  142.             return date;
  143.         }
  144.         return date;
  145.     }
  147.     /**
  148.      *
  149.      * 获取系统当前时间
  150.      *
  151.      * @return 系统当前时间
  152.      *
  153.      */
  154.     public static Date getCurrentDate() {
  155.         final Calendar gc = Calendar.getInstance();
  156.         return gc.getTime();
  157.     }
  159.     /**
  160.      *
  161.      * 得到日期的起始日期，例如2004-1-1 15:12，转换后为 2004-1-1 00:00
  162.      *
  163.      * @param date
  164.      *            需要转换的日期
  165.      *
  166.      * @return 该日期的零点
  167.      *
  168.      */
  169.     public static Date getTodayStart(Date date) {
  170.         final Calendar gc = Calendar.getInstance();
  171.         gc.setTime(date);
  172.         gc.set(Calendar.HOUR_OF_DAY, 0);
  173.         gc.set(Calendar.MINUTE, 0);
  174.         gc.set(Calendar.SECOND, 0);
  175.         gc.set(Calendar.MILLISECOND, 0);
  176.         return gc.getTime();
  177.     }
  179.     /**
  180.      *
  181.      * 得到日期的结束日期，例如2004-1-1 15:12，转换后为2004-1-2 00:00，注意为第二天的0点整
  182.      *
  183.      * @param date
  184.      *            所要转换的日期
  185.      *
  186.      * @return 为第二天的零点整
  187.      *
  188.      */
  189.     public static Date getTodayEnd(Date date) {
  190.         final Calendar gc = Calendar.getInstance();
  191.         gc.setTime(DateUtils.dateDayAdd(date, 1));
  192.         return DateUtils.getTodayStart(gc.getTime());
  193.     }
  195.     /**
  196.      *
  197.      * 得到日期所在月份的开始日期（第一天的开始日期），例如2004-1-15 15:10，转换后为2004-1-1 00:00
  198.      *
  199.      * @param date
  200.      *            需要转换的日期
  201.      *
  202.      * @return 日期所在月份的开始日期
  203.      *
  204.      */
  205.     public static Date getMonthBegin(Date date) {
  206.         final Calendar gc = Calendar.getInstance();
  207.         gc.setTime(date);
  208.         final int year = gc.get(Calendar.YEAR);
  209.         final int mon = gc.get(Calendar.MONTH);
  210.         final Calendar gCal = new GregorianCalendar(year, mon, 1);
  211.         return gCal.getTime();
  212.     }
  214.     /**
  215.      *
  216.      * 根据年、月返回由年、月构成的日期的月份开始日期
  217.      *
  218.      * @param year
  219.      *            所在的年
  220.      *
  221.      * @param month
  222.      *            所在的月份，从1月到12月
  223.      *
  224.      * @return 由年、月构成的日期的月份开始日期
  225.      *
  226.      */
  227.     public static Date getMonthBegin(int year, int month) {
  228.         if ((month <= 0) || (month > 12)) {
  229.             throw new IllegalArgumentException("month must from 1 to 12");
  230.         }
  231.         final Calendar gc = new GregorianCalendar(year, month - 1, 1);
  232.         return gc.getTime();
  233.     }
  235.     /**
  236.      *
  237.      * 根据日期所在的月份，得到下个月的第一天零点整
  238.      *
  239.      * @param date
  240.      *            需要转换的日期
  241.      *
  242.      * @return 对应日期的下个月的第一天零点整
  243.      *
  244.      */
  245.     public static Date getMonthEnd(Date date) {
  246.         final Calendar cal = Calendar.getInstance();
  247.         cal.setTime(date);
  248.         final int lastDay = cal.getActualMaximum(Calendar.DAY_OF_MONTH);
  249.         cal.set(Calendar.DAY_OF_MONTH, lastDay);
  250.         return DateUtils.getTodayEnd(cal.getTime());
  251.     }
  253.     /**
  254.      *
  255.      * 根据日期所在的星期，得到这个星期的开始日期，注意，每周从星期日开始计算
  256.      *
  257.      * @param date
  258.      *            需要转换的日期
  259.      *
  260.      * @return 传入日期所在周的第一天的零点整
  261.      *
  262.      */
  263.     public static Date getWeekBegin(Date date) {
  264.         final Calendar gCal = Calendar.getInstance();
  265.         gCal.setTime(date);
  266.         final int startDay = gCal.getActualMinimum(Calendar.DAY_OF_WEEK);
  267.         gCal.set(Calendar.DAY_OF_WEEK, startDay);
  268.         return gCal.getTime();
  269.     }
  271.     /**
  272.      *
  273.      * 根据日期所在的星期，得到下周开始第一天的零点整
  274.      *
  275.      * @param date
  276.      *            需要转换的日期
  277.      *
  278.      * @return 传入日期的下周开始第一天的零点整
  279.      *
  280.      */
  281.     public static Date getWeekEnd(Date date) {
  282.         final Calendar gCal = Calendar.getInstance();
  283.         gCal.setTime(date);
  284.         final int lastDay = gCal.getActualMaximum(Calendar.DAY_OF_WEEK);
  285.         gCal.set(Calendar.DAY_OF_WEEK, lastDay);
  286.         return DateUtils.getTodayEnd(gCal.getTime());
  287.     }
  289.     /**
  290.      *
  291.      * 根据年、月返回由年、月构成的日期的下一个月第一天零点整
  292.      *
  293.      * @param year
  294.      *            所在的年
  295.      *
  296.      * @param month
  297.      *            所在的月份，从1月到12月
  298.      *
  299.      * @return 下一个月第一天零点整
  300.      *
  301.      */
  302.     public static Date getMonthEnd(int year, int month) {
  303.         final Date start = DateUtils.getMonthBegin(year, month);
  304.         return DateUtils.getMonthEnd(start);
  305.     }
  307.     /**
  308.      *
  309.      * 根据日期所在的年份，得到当年的开始日期，为每年的1月1日零点整
  310.      *
  311.      * @param date
  312.      *            需要转换的日期
  313.      *
  314.      * @return 当年的开始日期，为每年的1月1日零点整
  315.      *
  316.      */
  317.     public static Date getYearBegin(Date date) {
  318.         final Calendar gCal = Calendar.getInstance();
  319.         gCal.setTime(date);
  320.         gCal.set(Calendar.DAY_OF_YEAR, 1);
  321.         return DateUtils.getTodayStart(gCal.getTime());
  322.     }
  324.     /**
  325.      *
  326.      * 根据日期所在的年份，得到当年的结束日期，为来年的1月1日零点整
  327.      *
  328.      * @param date
  329.      *            需要转换的日期
  330.      *
  331.      * @return 来年的1月1日零点整
  332.      *
  333.      */
  334.     public static Date getYearEnd(Date date) {
  335.         final Calendar cal = Calendar.getInstance();
  336.         cal.setTime(date);
  337.         final int lastday = cal.getActualMaximum(Calendar.DAY_OF_YEAR);
  338.         cal.set(Calendar.DAY_OF_YEAR, lastday);
  339.         return DateUtils.getTodayEnd(cal.getTime());
  340.     }
  342.     /**
  343.      *
  344.      * 转换日期为 yyyy-MM-dd 格式的字符串
  345.      *
  346.      * @param date
  347.      *            需要转换的日期
  348.      *
  349.      * @return 转换后的日期字符串
  350.      *
  351.      */
  352.     public static String formatDate(Date date) {
  353.         String str = "";
  354.         if (date != null) {
  355.             str = DateUtils.dateformater.format(date);
  356.         }
  357.         return str;
  359.     }
  361.     /**
  362.      *
  363.      * 转换指定日期成时间格式 HH:mm:ss 格式的字符串
  364.      *
  365.      * @param date
  366.      *            指定的时间
  367.      *
  368.      * @return 转换后的字符串
  369.      *
  370.      */
  371.     public static String formatTime(Date date) {
  372.         return DateUtils.timeformater.format(date);
  373.     }
  375.     /**
  376.      *
  377.      * 转换指定日期成 yyyy-MM-dd HH:mm:ss 格式的字符串
  378.      *
  379.      * @param date
  380.      *            需要转换的日期
  381.      *
  382.      * @return 转换后的字符串
  383.      *
  384.      */
  385.     public static String formatDateTime(Date date) {
  386.         return DateUtils.dateTimeformater.format(date);
  387.     }
  389.     /**
  390.      *
  391.      * 根据指定的转化模式，转换日期成字符串
  392.      *
  393.      * @param date
  394.      *            需要转换的日期
  395.      *
  396.      * @param pattern
  397.      *            日期格式 如果传入格式为空，则为默认格式 yyyy-MM-dd
  398.      *
  399.      * @return 转换后的字符串
  400.      *
  401.      */
  402.     public static String formatDate(Date date, String pattern) {
  403.         final DateFormat formater = DateUtils.getDateFormat(pattern);
  404.         return formater.format(date);
  405.     }
  407.     /**
  408.      *
  409.      * 在指定日期的基础上，增加或是减少月份信息，如1月31日，增加一个月后，则为2月28日（非闰年）
  410.      *
  411.      * @param date
  412.      *            指定的日期
  413.      *
  414.      * @param months
  415.      *            增加或是减少的月份数，正数为增加，负数为减少
  416.      *
  417.      * @return 增加或是减少后的日期
  418.      *
  419.      */
  420.     public static Date dateMonthAdd(Date date, int months) {
  421.         final Calendar cal = Calendar.getInstance();
  422.         cal.setTime(date);
  423.         int m = cal.get(Calendar.MONTH) + months;
  424.         if (m < 0) {
  425.             m += -12;
  426.         }
  427.         cal.roll(Calendar.YEAR, m / 12);
  428.         cal.roll(Calendar.MONTH, months);
  429.         return cal.getTime();
  430.     }
  432.     /**
  433.      *
  434.      * 在指定的日期基础上，增加或是减少天数
  435.      *
  436.      * @param date
  437.      *            指定的日期
  438.      *
  439.      * @param days
  440.      *            需要增加或是减少的天数，正数为增加，负数为减少
  441.      *
  442.      * @return 增加或是减少后的日期
  443.      *
  444.      */
  445.     public static Date dateDayAdd(Date date, int days) {
  446.         final long now = date.getTime() + (days * DateUtils.DAY_IN_MILLISECOND);
  447.         return new Date(now);
  448.     }
  450.     /**
  451.      *
  452.      * 在指定的日期基础上，增加或是减少年数
  453.      *
  454.      * @param date
  455.      *            指定的日期
  456.      *
  457.      * @param year
  458.      *            需要增加或是减少的年数，正数为增加，负数为减少
  459.      *
  460.      * @return 增加或是减少后的日期
  461.      *
  462.      */
  463.     public static Date dateYearAdd(Date date, int year) {
  464.         final Calendar cal = Calendar.getInstance();
  465.         cal.setTime(date);
  466.         cal.roll(Calendar.YEAR, year);
  467.         return cal.getTime();
  468.     }
  470.     /**
  471.      *
  472.      * 得到日期的年数
  473.      *
  474.      * @param date
  475.      *            指定的日期
  476.      *
  477.      * @return 返回指定日期的年数
  478.      *
  479.      */
  480.     public static int getDateYear(Date date) {
  481.         final Calendar cal = Calendar.getInstance();
  482.         cal.setTime(date);
  483.         return cal.get(Calendar.YEAR);
  484.     }
  486.     /**
  487.      *
  488.      * 得到指定日期的月份数
  489.      *
  490.      * @param date
  491.      *            指定的日期
  492.      *
  493.      * @return 返回指定日期的月份数
  494.      *
  495.      */
  496.     public static int getDateMonth(Date date) {
  497.         final Calendar cal = Calendar.getInstance();
  498.         cal.setTime(date);
  499.         return cal.get(Calendar.MONDAY);
  500.     }
  502.     /**
  503.      *
  504.      * 得到制定日期在当前天数，例如2004-5-20日，返回141
  505.      *
  506.      * @param date
  507.      *            指定的日期
  508.      *
  509.      * @return 返回的天数
  510.      *
  511.      */
  512.     public static int getDateYearDay(Date date) {
  513.         final Calendar cal = Calendar.getInstance();
  514.         cal.setTime(date);
  515.         return cal.get(Calendar.DAY_OF_YEAR);
  516.     }
  518.     /**
  519.      *
  520.      * 得到制定日期在当前月中的天数，例如2004-5-20日，返回20
  521.      *
  522.      * @param date
  523.      *            指定的日期
  524.      *
  525.      * @return 返回天数
  526.      *
  527.      */
  528.     public static int getDateMonthDay(Date date) {
  529.         final Calendar cal = Calendar.getInstance();
  530.         cal.setTime(date);
  531.         return cal.get(Calendar.DAY_OF_MONTH);
  532.     }
  534.     /**
  535.      *
  536.      * 得到指定日期的年份
  537.      *
  538.      * @param date
  539.      *            指定的日期
  540.      *
  541.      * @return 日期的年份
  542.      *
  543.      */
  544.     public static int getYear(Date date) {
  545.         final Calendar cal = Calendar.getInstance();
  546.         cal.setTime(date);
  547.         return cal.get(Calendar.YEAR);
  548.     }
  550.     /**
  551.      *
  552.      * 得到指定日期在当在一年中的月份数，从1开始
  553.      *
  554.      * @param date
  555.      *            指定的日期
  556.      *
  557.      * @return 指定日期在当在一年中的月份数
  558.      *
  559.      */
  560.     public static int getMonth(Date date) {
  561.         final Calendar cal = Calendar.getInstance();
  562.         cal.setTime(date);
  563.         return cal.get(Calendar.MONTH) + 1;
  564.     }
  566.     /**
  567.      *
  568.      * 得到指定日期在当在一月中的号数，从1开始
  569.      *
  570.      * @param date
  571.      *            指定的日期
  572.      *
  573.      * @return 日期在当在一月中的号数
  574.      *
  575.      */
  576.     public static int getDay(Date date) {
  577.         final Calendar cal = Calendar.getInstance();
  578.         cal.setTime(date);
  579.         return cal.get(Calendar.DAY_OF_MONTH);
  580.     }
  582.     /**
  583.      *
  584.      * 得到指定日期在当前星期中的天数，例如2004-5-20日，返回5，
  585.      *
  586.      * 每周以周日为开始按1计算，所以星期四为5
  587.      *
  588.      * @param date
  589.      *            指定的日期
  590.      *
  591.      * @return 返回天数
  592.      *
  593.      */
  594.     public static int getDateWeekDay(Date date) {
  595.         final Calendar cal = Calendar.getInstance();
  596.         cal.setTime(date);
  597.         return cal.get(Calendar.DAY_OF_WEEK) - 1;
  598.     }
  600.     /**
  601.      *
  602.      * 得到指定日期在当前周内是第几天 (周一开始)
  603.      *
  604.      * @param date
  605.      *            指定日期
  606.      *
  607.      * @return 周内天书
  608.      *
  609.      */
  610.     public static int getWeek(Date date) {
  611.         final Calendar cal = Calendar.getInstance();
  612.         cal.setTime(date);
  613.         return ((cal.get(Calendar.DAY_OF_WEEK) - 1) + 7) % 7;
  614.     }
  616.     /**
  617.      *
  618.      * 根据传入的格式，获取日期格式化实例，如果传入格式为空，则为默认格式 yyyy-MM-dd
  619.      * @param pattern 日期格式
  620.      * @return 格式化实例
  621.      *
  622.      */
  623.     public static DateFormat getDateFormat(String pattern) {
  624.         if (StringUtils.isBlank(pattern.trim())) {
  625.             return new SimpleDateFormat(DateUtils.DATE_PATTERN_DEFAULT);
  626.         } else {
  627.             return new SimpleDateFormat(pattern);
  628.         }
  629.     }
  631.     /**
  632.      *
  633.      * 计算两个时间之间的时间差
  634.      *
  635.      * @param from
  636.      *            开始
  637.      *
  638.      * @param to
  639.      *            结束
  640.      *
  641.      * @return 时间差
  642.      *
  643.      */
  644.     public static long calculateTimeInMillis(Date from, Date to) {
  645.         final Calendar fromCal = DateUtils.getCalendar(from);
  646.         final Calendar toCal = DateUtils.getCalendar(to);
  647.         if (fromCal.after(toCal)) {
  648.             fromCal.setTime(to);
  649.             toCal.setTime(from);
  650.         }
  651.         return toCal.getTimeInMillis() - fromCal.getTimeInMillis();
  652.     }
  654.     /**
  655.      *
  656.      * 获取Calendar实例
  657.      *
  658.      * @param date
  659.      *            日期类型
  660.      *
  661.      * @return
  662.      *
  663.      */
  664.     public static Calendar getCalendar(Date date) {
  665.         final Calendar gc = Calendar.getInstance();
  666.         gc.setTime(date);
  667.         return gc;
  668.     }
  670.     /**
  671.      *
  672.      * 根据 yyyyMMdd HH:mm 日期格式，转换成数据库使用的时间戳格式
  673.      *
  674.      * @param strTimestamp
  675.      *            以 yyyyMMdd HH:mm 格式的时间字符串
  676.      *
  677.      * @return 转换后的时间戳
  678.      *
  679.      */
  680.     public static java.sql.Timestamp parseTimestamp(String strTimestamp) {
  681.         return new java.sql.Timestamp(DateUtils.parseDateTime(strTimestamp).getTime());
  682.     }
  684.     /**
  685.     *
  686.     * 根据出生时间计算岁数
  687.     * Date birthday
  688.     * @return 年龄
  689.     *
  690.     */
  691.     public static int getAgeByBirth(Date birthday) {
  692.         int age = 0;
  693.         try {
  694.             final Calendar now = Calendar.getInstance();
  695.             now.setTime(new Date());// 当前时间
  697.             final Calendar birth = Calendar.getInstance();
  698.             birth.setTime(birthday);
  700.             if (birth.after(now)) {// 如果传入的时间，在当前时间的后面，返回0岁
  701.                 age = 0;
  702.             } else {
  703.                 age = now.get(Calendar.YEAR) - birth.get(Calendar.YEAR);
  704.                 if (now.get(Calendar.DAY_OF_YEAR) > birth.get(Calendar.DAY_OF_YEAR)) {
  705.                     age += 1;
  706.                 }
  707.             }
  708.             return age;
  709.         }
  710.         catch (final Exception e) {// 兼容性更强,异常后返回数据
  711.             return 0;
  712.         }
  713.     }
  714. }

发表评论

表情：
评论列表 （有 0 条评论，354人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Java常用工具类

    异常处理 什么是异常？ 有异于常态，和正常状态不一样，有错误出现，阻止当前方法或作用域等等都称之为异常。 有什么常见异常？ ![70][] 处理异常

    悠悠悠悠/ 0 赞/ 419 阅读