【java】时间常用工具类

逃离我推掉我的手 2022-12-02 03:51 452阅读 0赞

最近写课表系统，涉及到很多时间的计算，总结了一些常用的计算时间的方法，方便以后的查看,有些方法估计

文章目录

    • 可能要导入的包
    • 根据日期获取当天是周几
    • 日期的偏移,在指定的日期跳到指定的周
    • 获取当前时间处在第几周的日期
    • 得到当前月份
    • 在指定时间后，通过周几来查询到指定的时间
    • 获取某段时间内的周一（二等等）的日期
    • 这是将时间转换后只保留年月日
    • 将字符串的时间转换为Date
    • 将时间转为时间戳
    • 获取当天的周数
    • 获取单独的 年 月 日
    • 获取当天的年月日
    • 获取提前几分钟的时间

可能要导入的包

hutool工具包,这个是一个很全的工具文档，值得推荐

  1. import cn.hutool.core.date.DateTime;
  2. import cn.hutool.core.date.DateUtil;
  3. import java.text.DateFormat;
  4. import java.text.ParseException;
  5. import java.text.SimpleDateFormat;
  6. import java.util.ArrayList;
  7. import java.util.Calendar;
  8. import java.util.Date;
  9. import java.util.List;

根据日期获取当天是周几

  1. /**
  2.      * 根据日期获取当天是周几
  3.      *
  4.      * @param datetime 日期
  5.      * @return 周几
  6.      */
  7.     public static int dateToWeek(String datetime) {
  9.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
  10.         Calendar cal = Calendar.getInstance();
  11.         System.out.println(cal);
  12.         Date date;
  13.         try {
  15.             date = sdf.parse(datetime);
  16.             cal.setTime(date);
  17.         } catch (ParseException e) {
  19.             e.printStackTrace();
  20.         }
  21.         int w = cal.get(Calendar.DAY_OF_WEEK) - 1;
  22.         System.out.println("w为:" + w);
  23.         return w;
  24.     }

日期的偏移,在指定的日期跳到指定的周

  1. /**
  2.      * 日期的偏移,在指定的日期跳到指定的周
  3.      *
  4.      * @param datetime
  5.      * @param startWeek
  6.      * @return
  7.      */
  8.     public static Date timeMove(String datetime, Integer startWeek) {
  11.         Date date = DateUtil.parse(datetime);
  13.         //常用偏移，结果：2017-03-04 22:33:23
  14.         Date newDate2 = DateUtil.offsetDay(date, 7 * (startWeek - 1));
  15.         return newDate2;
  16.     }

获取当前时间处在第几周的日期

  1. /**
  2.      * 获取当前时间处在第几周的日期
  3.      * @param date 当前的时间，是从周一开始
  4.      * @param startWeek 第几周
  5.      * @return
  6.      */
  7.     public static List<String> dayListByWeek(Date date, Integer startWeek){
  9.         List<String> dayList=new ArrayList<>();
  10.         SimpleDateFormat sdf2= new SimpleDateFormat("dd");
  11.         for (int i = 0; i <7 ; i++) {
  13.             DateTime newDate2 = DateUtil.offsetDay(date, i);
  14.             String day = sdf2.format(newDate2);
  15.             dayList.add(day);
  16.         }
  18.         return dayList;
  19.     }

得到当前月份

  1. /**
  2.      * 得到当前月份
  3.      * @param date
  4.      * @return
  5.      */
  6.     public static String getMonth(Date date){
  8.         SimpleDateFormat sdf= new SimpleDateFormat("MM");
  9.         String month = sdf.format(date);
  10.         return month;
  11.     }

在指定时间后，通过周几来查询到指定的时间

  1. /**
  2.      * 在指定时间后，通过周几来查询到指定的时间
  3.      *
  4.      * @param date
  5.      * @param week
  6.      * @return
  7.      */
  8.     public static Date dayMove(Date date, Integer week) {
  10.         //常用偏移，结果：2017-03-04 22:33:23
  11.         Date newDate2 = DateUtil.offsetDay(date, week - 1);
  12.         return newDate2;
  13.     }

获取某段时间内的周一（二等等）的日期

  1. /**
  2.      * 获取某段时间内的周一（二等等）的日期
  3.      * @param dataBegin 开始日期
  4.      * @param dataEnd 结束日期
  5.      * @param weekDays 获取周几，1－6代表周一到周六。0代表周日
  6.      * @return 返回日期List
  7.      */
  8.     public static List<String> getDayOfWeekWithinDateInterval(String dataBegin, String dataEnd, int weekDays) {
  10.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
  11.         List<String> dateResult = new ArrayList<>();
  12.         Calendar cal = Calendar.getInstance();
  13.         String[] dateInterval = {
  14.     dataBegin, dataEnd};
  15.         Date[] dates = new Date[dateInterval.length];
  16.         for (int i = 0; i < dateInterval.length; i++) {
  18.             String[] ymd = dateInterval[i].split("[^\\d]+");
  19.             cal.set(Integer.parseInt(ymd[0]), Integer.parseInt(ymd[1]) - 1, Integer.parseInt(ymd[2]));
  20.             dates[i] = cal.getTime();
  21.         }
  22.         for (Date date = dates[0]; date.compareTo(dates[1]) <= 0; ) {
  24.             cal.setTime(date);
  25.             if (cal.get(Calendar.DAY_OF_WEEK) - 1 == weekDays) {
  27.                 String format = sdf.format(date);
  28.                 dateResult.add(format);
  29.             }
  30.             cal.add(Calendar.DATE, 1);
  31.             date = cal.getTime();
  32.         }
  33.         return dateResult;
  34.     }

这是将时间转换后只保留年月日

  1. /**
  2.      * 这是将时间转换后只保留年月日
  3.      *
  4.      * @param date
  5.      * @return
  6.      */
  7.     public static String dateConversion(Date date) {
  9.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
  10.         String s = sdf.format(date); // 把带时分秒的 date 转为 yyyy-MM-dd 格式的字符串
  11.         try {
  13.             Date date2 = sdf.parse(s); // 把上面的字符串解析为日期类型
  14.             String format = sdf.format(date2);
  15.             System.out.println("这是转换后只保留年月日的时间" + format);
  16.             return format;
  17.         } catch (ParseException e) {
  19.             e.printStackTrace();
  20.         }
  21.         return null;
  22.     }

将字符串的时间转换为Date

  1. /**
  2.      * 将字符串的时间转换为Date
  3.      *
  4.      * @param dateStr
  5.      * @return
  6.      */
  7.     public static Date strToDate(String dateStr) {
  9.         SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  10.         Date dateTime = null;
  11.         try {
  13.             dateTime = simpleDateFormat.parse(dateStr);
  14.         } catch (ParseException e) {
  16.             e.printStackTrace();
  17.         }
  19.         return dateTime;
  20.     }

将时间转为时间戳

  1. /**
  2.      * 将时间转为时间戳
  3.      * @param date
  4.      * @return
  5.      */
  6.     public static Long toUnixTime(Date date) {
  8.         DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm");
  9.         String t = df.format(date);
  10.         /**
  11.          * 获取日期转换为Unix时间戳
  12.          */
  13.         long epoch = 0;
  14.         try {
  16.             epoch = df.parse(t).getTime();
  17.         } catch (ParseException e) {
  19.             e.printStackTrace();
  20.         }
  21.         return epoch;
  22.     }
  25.     /**
  26.      * 将字符时间转换为Unix时间戳,毫秒
  27.      * @param timeStr
  28.      * @return
  29.      */
  30.     public static Long jointUnixTime(String timeStr) {
  32.         Date date = strToDate(timeStr);
  34.         Long aLong = toUnixTime(date);
  35.         return aLong;
  36.     }
  38.     /**
  39.      * 将字符时间转换为Unix时间戳,秒
  40.      * @param timeStr
  41.      * @return
  42.      */
  43.     public static Long jointUnixTimeSec(String timeStr) {
  45.         Date date = strToDate(timeStr);
  46.         long time = date.getTime()/1000;
  47.         return time;
  48.     }

获取当天的周数

  1. /**
  2.      * 获取当天的周数
  3.      * @param beginDateStr  开始的时间
  4.      * @param endDateStr    结束的时间
  5.      * @return
  6.      */
  7.     public static long getDaySub(String beginDateStr, String endDateStr) {
  9.         long day = 0;
  10.         SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
  11.         java.util.Date beginDate;
  12.         java.util.Date endDate;
  13.         try {
  15.             //先判断学期开始日期是星期几
  16.             Calendar c = Calendar.getInstance();// 获得一个日历的实例
  17.             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
  18.             c.setTime(sdf.parse(beginDateStr));
  19.             int dayNum[] = {
  20.     6, 0, 1, 2, 3, 4, 5};//对应的星期几和星期一倒推相差几天
  21.             //算出的星期几，和星期一差几天就把开始时间多倒推几天
  22.             c.add(Calendar.DATE, -dayNum[c.get(Calendar.DAY_OF_WEEK) - 1]);
  23.             beginDate = c.getTime();
  24.             //beginDate = format.parse(beginDateStr);
  25.             System.out.println(sdf.format(beginDate));
  26.             endDate = format.parse(endDateStr);
  27.             day = (endDate.getTime() - beginDate.getTime()) / (24 * 60 * 60 * 1000);
  28.             //System.out.println("相隔的天数="+day);
  29.         } catch (ParseException e) {
  31.             // TODO 自动生成 catch 块
  32.             e.printStackTrace();
  33.         }
  34.         return day / 7 + 1;
  35.     }

获取单独的 年 月 日

  1. /**
  2.      *获取单独的 年 月 日
  3.      * @param date  传过来的时间  例：2020-08-01
  4.      * @return
  5.      */
  6.     public static String getYear(Date date){
  8.         SimpleDateFormat sdf0 = new SimpleDateFormat("yyyy");
  10.         SimpleDateFormat sdf1 = new SimpleDateFormat("MM");
  11.         SimpleDateFormat sdf2= new SimpleDateFormat("dd");
  12.         String str1 = sdf0.format(date);
  14.         String str2 = sdf1.format(date);
  16.         String str3 = sdf2.format(date);
  18.         System.out.println("年份bai为："+str1);
  20.         System.out.println("月份为："+str2);
  22.         System.out.println("日为："+str3);
  23.         return "年"+str1+" "+"月"+" "+str2+"日"+str3;
  24.     }

获取当天的年月日

  1. /**
  2.      * 获取当天的年月日
  3.      * @return
  4.      */
  5.     public static String getDay(){
  7.         DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
  8.         String day = df.format(new Date());
  10.         return day;
  11.     }
  13. /**
  14.      * 获取当天的星期一日期
  15.      * @return
  16.      */
  17.     public static String getMondeyDate(){
  19.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
  21.         Calendar cal = Calendar.getInstance();
  22.         cal.setFirstDayOfWeek(Calendar.MONDAY);// 设置一个星期的第一天，按中国的习惯一个星期的第一天是星期一
  23.         int dayWeek = cal.get(Calendar.DAY_OF_WEEK);// 获得当前日期是一个星期的第几天
  24.         if(dayWeek==1){
  26.             dayWeek = 8;
  27.         }
  28.         cal.add(Calendar.DATE, cal.getFirstDayOfWeek() - dayWeek);// 根据日历的规则，给当前日期减去星期几与一个星期第一天的差值
  29.         Date mondayDate = cal.getTime();
  30.         String weekBegin = sdf.format(mondayDate);
  31.         return weekBegin;
  32.     }

获取提前几分钟的时间

  1. /**
  2.      * 获取提前几分钟的时间
  3.      * @param time
  4.      * @return
  5.      */
  6.     public static String beforeTime(String time){
  8.         String dateStr=time;
  9.         Date date = DateUtil.parse(dateStr);
  10.         Calendar beforeTime = Calendar.getInstance();
  11.         beforeTime.setTime(date);
  13.         beforeTime.add(Calendar.MINUTE, -5);// 5分钟之前的时间
  15.         Date beforeD = beforeTime.getTime();
  16.         String before5 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(beforeD);
  17.         return before5;
  19.     }

发表评论

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

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

相关阅读

    相关 JAVA常用工具类

    引言 说起工具类，大家都不会陌生。常用的工具类有Apache 的Commons、 Google 的Guava、以及处理时间日期的Joda扩展包。那么本文主要来讲这几个工具

    向右看齐向右看齐/ 0 赞/ 460 阅读

    相关 Java常用工具类

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

    悠悠悠悠/ 0 赞/ 421 阅读