使用joda-time封装的日期工具类

深碍√TFBOYSˉ_ 2023-06-30 09:14 76阅读 0赞

1、Joda-time简介
Joda-Time这个专门处理日期时间的库
2、类说明
Instant：不可变类，代表时间线上的一个瞬时的时间点
DateTime：不可变类，它以毫秒级的精度封装时间上的某个瞬间时刻，用来替换JDK的Calendar类
LocalDate：不可变类，该类封装了一个年/月/日的组合。没有时区信息
LocalTime：不可变类，表示一个本地的时间，而不包含日期部分。没有时区信息
LocalDateTime：不可变类，该类封装了一个年/月/日 时：分：秒的组合。没有时区信息
详细代码如下：
封装了常见的日期处理方式

  1. public class DateUtils { 
  4.     public static  final String FORMAT_YYYY_MM_DD = "yyyy-MM-dd";
  6.     public static final String FORMAT_YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";
  8.     public static final String FORMAT_CHINESE = "yyyy年M月d日";
  10.     public static final String FORMAT_HH_MM = "HH:mm";
  12.     public static final String FORMAT_YMDHMS = "yyyyMMdd hh:mm:ss";
  14.     public static final String START_TIME = "00:00:00";
  16.     public static final String END_TIME = "23:59:59";
  18.     public static DateTimeFormatter dateTimeFormatter = DateTimeFormat.forPattern(FORMAT_YYYY_MM_DD_HH_MM_SS);
  21.     /** * 获取系统当前时间 返回 yyyy-MM-dd HH:mm:ss * @return */
  22.     public static String getCurrentTime() { 
  23.         DateTime dt = new DateTime();
  24.         String time = dt.toString(FORMAT_YYYY_MM_DD_HH_MM_SS);
  25.         return time;
  26.     }
  28.     /** * 获取系统当前时间按照指定格式返回 * @param pattern * @return */
  29.     public static String getCurrentTimePattern(String pattern) { 
  30.         DateTime dt = new DateTime();
  31.         String time = dt.toString(pattern);
  32.         return time;
  33.     }
  35.     /** * 获取当前日期 * @return yyyy-MM-dd */
  36.     public static String getCurrentDate() { 
  37.         DateTime dt = new DateTime();
  38.         String date = dt.toString(FORMAT_YYYY_MM_DD);
  39.         return date;
  40.     }
  42.     /** * 获取当前日期按照指定格式 * @param pattern * @return */
  43.     public static String getCurrentDatePattern(String pattern) { 
  44.         DateTime dt = new DateTime();
  45.         String date = dt.toString(pattern);
  46.         return date;
  47.     }
  49.     /** * 按照时区转换时间 * @param date * @param timeZone 时区 * @param pattern * @return */
  50.     public static String format(Date date, TimeZone timeZone, String pattern) { 
  51.         if (date == null) { 
  52.             return null;
  53.         }
  54.         SimpleDateFormat sdf = new SimpleDateFormat(pattern);
  55.         sdf.setTimeZone(timeZone);
  56.         return sdf.format(date);
  57.     }
  59.     /** * 获取指定时间 * @param year 年 * @param month 月 * @param day 天 * @param hour 小时 * @param minute 分钟 * @param seconds 秒 * @return yyyy-MM-dd HH:mm:ss */
  60.     public static String getPointTime(Integer year, Integer month, Integer day, Integer hour, Integer minute, Integer seconds) { 
  61.         DateTime dt = new DateTime(year, month, day, hour, minute, seconds);
  62.         String date = dt.toString(FORMAT_YYYY_MM_DD_HH_MM_SS);
  63.         return date;
  64.     }
  66.     /** * 获取指定时间 指定返回格式 * @param year 年 * @param month 月 * @param day 天 * @param hour 小时 * @param minute 分钟 * @param seconds 秒 * @param pattern 自定义格式 * @return pattern */
  67.     public static String getPointTimePattern(Integer year, Integer month, Integer day, Integer hour,
  68.                                              Integer minute, Integer seconds, String pattern) { 
  69.         DateTime dt = new DateTime(year, month, day, hour, minute, seconds);
  70.         String date = dt.toString(pattern);
  71.         return date;
  72.     }
  74.     /** * 获取指定日期 * @param year * @param month * @param day * @return */
  75.     public static String getPointDate(Integer year, Integer month, Integer day) { 
  76.         LocalDate dt = new LocalDate(year, month, day);
  77.         String date = dt.toString(FORMAT_YYYY_MM_DD);
  78.         return date;
  79.     }
  81.     /** * 获取指定日期 返回指定格式 * @param year * @param month * @param day * @param pattern * @return */
  82.     public static String getPointDatPattern(Integer year, Integer month, Integer day, String pattern) { 
  83.         LocalDate dt = new LocalDate(year, month, day);
  84.         String date = dt.toString(pattern);
  85.         return date;
  86.     }
  89.     /** * 获取当前是一周星期几 * @return */
  90.     public static String getWeek() { 
  91.         DateTime dts = new DateTime();
  92.         return DayWeekEnum.getNameByCode(dts.getDayOfWeek());
  93.     }
  96.     /** * 获取指定时间是一周的星期几 * @param year * @param month * @param day * @return */
  97.     public static String getWeekPoint(Integer year, Integer month, Integer day) { 
  98.         LocalDate dts = new LocalDate(year, month, day);
  99.         return DayWeekEnum.getNameByCode(dts.getDayOfWeek());
  100.     }
  103.     /** * 格式化日期 日期转为字符串 * @param date * @return yyyy-MM-dd HH:mm:ss */
  104.     public static String format(Date date) { 
  105.         if (date == null) { 
  106.             return null;
  107.         }
  108.         SimpleDateFormat format = new SimpleDateFormat(FORMAT_YYYY_MM_DD_HH_MM_SS);
  109.         return format.format(date);
  110.     }
  112.     /** * 日期转为字符串 指定格式 * @param date 日期 * @param pattern 日期格式 * @return */
  114.     public static String format(Date date, String pattern) { 
  115.         if (date == null) { 
  116.             return null;
  117.         }
  118.         SimpleDateFormat format = new SimpleDateFormat(pattern);
  119.         return format.format(date);
  120.     }
  122.     /** * 字符串转为日期 指定格式 * @param date 日期字符串 * @param pattern 日期格式 * @return */
  123.     public static Date parse(String date, String pattern) { 
  124.         if (date == null) { 
  125.             return null;
  126.         }
  127.         Date resultDate = null;
  128.         try { 
  129.             resultDate = new SimpleDateFormat(pattern).parse(date);
  130.         } catch (ParseException e) { 
  131.             throw new GenericBusinessException(e);
  132.         }
  133.         return resultDate;
  134.     }
  136.     /** * 字符串转为日期 * @param date 日期字符串 * @return */
  137.     public static Date parse(String date) { 
  138.         if (date == null) { 
  139.             return null;
  140.         }
  141.         try { 
  142.             return new SimpleDateFormat(FORMAT_YYYY_MM_DD_HH_MM_SS).parse(date);
  143.         } catch (ParseException e) { 
  144.             throw new GenericBusinessException(e);
  145.         }
  146.     }
  148.     /** * 毫秒数转为字符串 按照指定格式转换 * @param timestamp * @return */
  149.     public static String format(Long timestamp, String pattern) { 
  150.         String dateStr = "";
  151.         if (null == timestamp || timestamp.longValue() < 0) { 
  152.             return dateStr;
  153.         }
  154.         try { 
  155.             Date date = new Date(timestamp);
  156.             SimpleDateFormat format = new SimpleDateFormat(pattern);
  157.             dateStr = format.format(date);
  158.         } catch (Exception e) { 
  159.             throw new GenericBusinessException(e);
  160.         }
  161.         return dateStr;
  162.     }
  164.     /** *获取当前时间前几天时间,按指定格式返回 * @param days * @return */
  165.     public static String forwardDay(Integer days, String format) { 
  166.         DateTime dt = new DateTime();
  167.         DateTime y = dt.minusDays(days);
  168.         return y.toString(format);
  169.     }
  171.     /** * 获取当前时间前几天时间 * @param days * @return */
  172.     public static Date forwardDay(Integer days) { 
  173.         DateTime dt = new DateTime();
  174.         DateTime y = dt.minusDays(days);
  175.         return y.toDate();
  176.     }
  178.     /** * 计算两个时间相差多少天 * @param startDate * @param endDate * @return */
  179.     public static Integer diffDay(Date startDate, Date endDate) { 
  180.         if (startDate == null || endDate == null) { 
  181.             return null;
  182.         }
  183.         DateTime dt1 = new DateTime(startDate);
  184.         DateTime dt2 = new DateTime(endDate);
  185.         int day = Days.daysBetween(dt1, dt2).getDays();
  186.         return Math.abs(day);
  187.     }
  189.     /** * 获取指定间隔天数的日期 * @param date * @param offset * @return */
  190.     public static Date addDay(Date date, int offset) { 
  191.         DateTime dt1;
  192.         if (date == null) { 
  193.             dt1 = new DateTime().plusDays(offset);
  194.             return dt1.toDate();
  195.         }
  196.         dt1 = new DateTime(date).plusDays(offset);
  197.         return dt1.toDate();
  198.     }
  200.     /** * 获取日期的开始时间 * @param dateStr * @return */
  201.     public static Date getDateStart(String dateStr) { 
  202.         SimpleDateFormat simpleDateFormat = new SimpleDateFormat(FORMAT_YMDHMS);
  203.         String subStr = dateStr.substring(0,8);
  204.         try { 
  205.             Date date = simpleDateFormat.parse(subStr + " " + START_TIME);
  206.             return date;
  207.         } catch (ParseException e) { 
  208.             throw new GenericBusinessException(e);
  209.         }
  210.     }
  212.     /** * 获取日期的结束时间 * @param dateStr * @return */
  213.     public static Date getDateEnd(String dateStr) { 
  214.         SimpleDateFormat simpleDateFormat = new SimpleDateFormat(FORMAT_YMDHMS);
  215.         String subStr = dateStr.substring(0,8);
  216.         try { 
  217.             Date date = simpleDateFormat.parse(subStr + " " + END_TIME);
  218.             return date;
  219.         } catch (ParseException e) { 
  220.             throw new GenericBusinessException(e);
  221.         }
  222.     }

辛苦点赞
源码地址

发表评论

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

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

相关阅读

    相关 自己封装的JDBC类

    > 对JDBC进行一些简单的封装，可以方便在项目中调用，同时也减少了重复代码量，降低代码的冗余度，提高代码的可读性和美观。 package JdbcUtil

    た 入场券た 入场券/ 0 赞/ 503 阅读