时间操作工具类大全

最新推荐文章于 2024-08-26 14:35:51 发布

阿松哥哥2018

最新推荐文章于 2024-08-26 14:35:51 发布

阅读量1.3k

点赞数 2

分类专栏： java java基础文章标签：时间操作时间转换时间工具

本文链接：https://blog.csdn.net/weixin_43171019/article/details/96613996

版权

java 同时被 2 个专栏收录

26 篇文章 1 订阅

订阅专栏

java基础

6 篇文章 0 订阅

订阅专栏

在日常编码中，我们会经常对日期，时间进行操作，每次操作如果都去new新对象的话，会相对很麻烦，且太多操作功能的话，多了也记不住。所以一个健全的项目需开发者自已封装一些工具类，需要时可以直接拿来使用，今天总结一下，现有项目中使用到的时间操作工具类，分享给大家使用

写完之后，感觉方法比较多，先给个方法目录吧，各位同仁可自行查找自已需要使用的方法：

将时间类型转换为字符串
将Object类型转换成Date格式
获取当前时间的年和月
获取指定日期的同年的第一天获取指定日期的同年的最后一天
给指定的日期追加指定年数
获取给定时间的同月份的第一天和最后一天
给指定的时间追加指定的月数
获取指定日期的同周的周一获取指定时期的同周的周日给指定时间追加指定的周数
给指定时间追加指定的天数给指定时间追加指定的小时给指定时间追加指定的分钟
获取传入的两个时间的天数差
传入的时间字符串获取传入时间的下一天0点0分0秒
获取某个时间点之前的时间
根据指定日期获得指定日期所在周的周一到周天的日期
传入日期计算自然周的开始结束时间
获取传入的两个时间时间字符串的天数差
获取传入的两个时间字符串之间的时间段间隔的天时分数，返回一个数组
返回两个指定时段中的日期集合
通过传递时间段去获取该时间段中的每天日期
通过传递时间参数（参数为Date类型的），判断这天是星期几，如"星期日", “星期一”, “星期二”, “星期三”, “星期四”, “星期五”, “星期六”
通过传递时间参数（参数为String形式），判断这天是星期几，如"星期日", “星期一”, “星期二”, “星期三”, “星期四”, “星期五”, “星期六”
获取今天是星期几
通过传递时间参数，判断这天属于几月
获取传入时间的当前月
获取传入时间的当前年
获取传入时间的当月总共天数
将字符串转换成时间类型

一.先上整体工具类，工具类为一个静态类其中的方法和常量都是静态方法和静态常量

public class DateUtil {
   //以下定义的是一些时间格式常量
   /** DATETIME_PATTERN(String):yyyy-MM-dd HH:mm:ss. */
   public static final String DATETIME_PATTERN = "yyyy-MM-dd HH:mm:ss";
   public static final String DATETIMENORMAL_PATTERN = "yyyy-MM-dd HH:mm";

   /** DATE_PATTERN(String):yyyy-MM-dd. */
   public static final String DATE_PATTERN = "yyyy-MM-dd";

   /** MONTH_PATTERN(String):yyyy-MM. */
   public static final String MONTH_PATTERN = "yyyy-MM";
   }

二.编写常用的时间操作的方法
方法一：将时间类型转换为字符串

/**
 * 转换为字符串.
 */
public static final String toString(Date date, String pattern) {
   String result = null;

   if (date != null) {
      result = DateFormatUtils.format(date, pattern);
   }

   return result;
}

方法二：将Object类型转换成Date格式

/**
 * 转换为java.util.Date对象.
 * 
 * @param value
 *            带转换对象
 * @param pattern
 *            日期格式
 * @return 对应的Date对象
 */
public static final Date toDate(Object value, String pattern) {
   Date result = null;

   if (value instanceof String) {
      if (StringUtils.isNotEmpty((String) value)) {
         try {
            result = DateUtils.parseDate((String) value,
                  new String[] { pattern });
         } catch (ParseException e) {
         }

         if (result == null && StringUtils.isNotEmpty((String) value)) {
            result = new Date(new Long((String) value).longValue());
         }
      }
   } else if (value instanceof Object[]) {
      Object[] array = (Object[]) value;

      if ((array != null) && (array.length >= 1)) {
         value = array[0];
         result = toDate(value, pattern);
      }
   } else if (Date.class.isAssignableFrom(value.getClass())) {
      result = (Date) value;
   }

   return result;
}

方法三：获取当前时间的年和月

public static final String getCurYearMonth()
{
    int year;
    int month;
    String date;
    Calendar calendar = Calendar.getInstance();
    year = calendar.get(Calendar.YEAR);
    month = calendar.get(Calendar.MONTH) + 1;
    date = year + "年" + ( month<10 ? "0" + month : month)+"月";
    return date;
}

方法四：获取指定日期的同年的第一天
获取指定日期的同年的最后一天

/**
 * 获取指定日期同一年的第一天.
 */
public static final Date getFirstDateOfYear(Date date) {
   Calendar cal = Calendar.getInstance();
   cal.setTime(date);
   cal.set(Calendar.DAY_OF_YEAR, 1);
   return cal.getTime();
}
/**
 * 获取指定日期同一年的最后一天.
 */
public static final Date getLastDateOfYear(Date date) {
   Calendar cal = Calendar.getInstance();
   cal.setTime(getFirstDateOfYear(date));
   cal.set(Calendar.YEAR, cal.get(Calendar.YEAR) + 1);
   cal.add(Calendar.DAY_OF_YEAR, -1);
   return cal.getTime();
}

方法五：给指定的日期追加指定年数

/**
 * 指定日期追加指定年数.
 */
public static final Date addYear(Date date, int year) {
   Calendar cal = Calendar.getInstance();
   cal.setTime(date);
   cal.add(Calendar.YEAR, year);
   return cal.getTime();
}

方法六：获取给定时间的同月份的第一天和最后一天

/**
 * 获取给定时间同月份的第一天.
 */
public static final Date getFirstDateOfMonth(Date date) {
   Calendar cal = Calendar.getInstance();
   cal.setTime(date);
   cal.set(Calendar.DAY_OF_MONTH, 1);
   return cal.getTime();
}

/**
 * 获取给定时间同月份的最后一天.
 */
public static final Date getLastDateOfMonth(Date date) {
   Calendar cal = Calendar.getInstance();
   cal.setTime(getFirstDateOfMonth(date));
   cal.set(Calendar.MONTH, cal.get(Calendar.MONTH) + 1);
   cal.add(Calendar.DAY_OF_YEAR, -1);
   return cal.getTime();
}

方法七：给指定的时间追加指定的月数

/**
 * 给指定的时间追加指定的月数.
 */
public static final Date addMonth(Date date, int month) {
   Calendar cal = Calendar.getInstance();
   cal.setTime(date);
   cal.add(Calendar.MONTH, month);
   return cal.getTime();
}

方法八：获取指定日期的同周的周一
获取指定时期的同周的周日
给指定时间追加指定的周数

/**
 * 获取指定日期同周的星期一.
 */
public static final Date getFirstDateOfWeek(Date date) {
   Calendar cal = Calendar.getInstance();
   cal.setTime(date);
   cal.setFirstDayOfWeek(Calendar.MONDAY);
   cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
   return cal.getTime();
}

/**
 * 获取指定日期同周的星期日.
 */
public static final Date getLastDateOfWeek(Date date) {
   Calendar cal = Calendar.getInstance();
   cal.setTime(date);
   cal.setFirstDayOfWeek(Calendar.MONDAY);
   cal.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);
   return cal.getTime();
}

/**
 * 给指定日期追加指定的周数.
 */
public static final Date addWeek(Date date, int week) {
   Calendar cal = Calendar.getInstance();
   cal.setTime(date);
   cal.add(Calendar.WEEK_OF_YEAR, week);
   return cal.getTime();
}

方法九：给指定时间追加指定的天数
给指定时间追加指定的小时
给指定时间追加指定的分钟

/**
 * 给指定时间追加指定天数.
 */
public static final Date addDay(Date date, int day) {
   Calendar c = Calendar.getInstance();
   c.setTime(date);
   c.add(Calendar.DATE, day);

   return c.getTime();
}

/**
 * 给指定时间追加指定的小时.
 */
public static final Date addHour(Date date, int hour) {
   Calendar c = Calendar.getInstance();
   c.setTime(date);
   c.add(Calendar.HOUR_OF_DAY, hour);

   return c.getTime();
}

/**
 * 给指定时间追加指定的分钟数.
 */
public static final Date addMinute(Date date, int minute) {
   Calendar c = Calendar.getInstance();
   c.setTime(date);
   c.add(Calendar.MINUTE, minute);

   return c.getTime();
}

方法十：获取传入的两个时间的天数差

/**
 * 获取传入的两个时间的天数差
 * @param date1    时间一
 * @param date2    时间二
 * @return
 */
public static int getIntervalDateMinusDate(Date date1,Date date2){
   int result = (int) ((date1.getTime() - date2.getTime()) / (1000*3600*24));
   return result;
}

方法十一：传入的时间字符串获取传入时间的下一天0点0分0秒

/**
 * 传入的时间字符串 获取传入时间的下一天0点0分0秒
 * @param date
 * @return
 */
public static Date getNextDay(String date){

   SimpleDateFormat format=new SimpleDateFormat("yyyy-MM-dd");
   Date dateTemp=null;
   try {
      dateTemp=format.parse(date);
      Calendar calendar  =   Calendar.getInstance();

      calendar.setTime(dateTemp); //需要将date数据转移到Calender对象中操作
      calendar.add(calendar.DATE, 1);//把日期往后增加n天.正数往后推,负数往前移动
      dateTemp=calendar.getTime();   //这个时间就是日期往后推一天的结果
   } catch (ParseException e) {
      e.printStackTrace();
   }
   return dateTemp;
}

方法十二：获取某个时间点之前的时间

/**
 * 获取某个时间点之前的时间
 * @param dateFormatStr    时间格式
 * @param dataStr               指定的时间
 * @param calendarType   Calendar类中的字段属性值   ERA = 0 、YEAR = 1、MONTH = 2、WEEK_OF_YEAR = 3、WEEK_OF_MONTH = 4.......,具体可查看   *                                          Calendar类
 * @param beforeNum       时间间隔数  根据calendarType   确定是年  月 日 等
 * @return beforeDateStr
 */
   public static String getBeforeDateStr(String dateFormatStr,String dataStr,int calendarType, int beforeNum){
   SimpleDateFormat sdf = new SimpleDateFormat(dateFormatStr);
   Calendar calendar = Calendar.getInstance();
   try {
      calendar.setTime(sdf.parse(dataStr));
   } catch (ParseException e) {
      e.printStackTrace();
   }
   calendar.add(calendarType, -beforeNum);
   Date beforeDate = calendar.getTime();
   String result = sdf.format(beforeDate);
       return result;
}

方法十三：根据指定日期获得指定日期所在周的周一到周天的日期


/**
 * 根据指定日期获得指定日期所在周的周一到周天的日期 * 
 * @param mdate
 * @return
 */
public static List<Date> dateToCurrentWeek(Date mdate) {
    Calendar cal = Calendar.getInstance();
    cal.setTime(mdate);

    int b = cal.get(Calendar.DAY_OF_WEEK) - 1;
    if (b == 0) {
        b = 7;
    }
    Date fdate;
    List<Date> list = new ArrayList<Date>();
    Long fTime = mdate.getTime() - b * 24 * 3600000;
    for (int a = 1; a <= 7; a++) {
        fdate = new Date();
        fdate.setTime(fTime + (a * 24 * 3600000));
        list.add(a - 1, fdate);
    }
    return list;
}

方法十四：传入日期计算自然周的开始结束时间


/**
    * 传入日期计算自然周的开始结束时间
    *  DATETIMENORMAL_PATTERN  是类里面定义的类变量的日期格式   请看该博客
    * 最开始给的类的属性
    */
   public static String[] getWeekDayBeginDateAndEndDateWithDateStr(Date date) {
   String[] beStr = new String[2];
   SimpleDateFormat formt = new SimpleDateFormat(DATETIMENORMAL_PATTERN);   
   List<Date> list = new ArrayList<Date>();
   list = dateToCurrentWeek(date);
   beStr[0] = formt.format(list.get(0));
   beStr[1] = formt.format(list.get(6));
   return beStr;
   }

方法十五：获取传入的两个时间时间字符串的天数差

public static long getDistanceDays(String str1, String str2) {
   DateFormat df = new SimpleDateFormat(DATE_PATTERN);   //DATE_PATTERN  是类里面定义的类变量的日期格式  请看该博客最开始给的类的属性
   Date one;
   Date two;
   long day = 0;
   try {
      one = df.parse(str1);
      two = df.parse(str2);
      long time1 = one.getTime();
      long time2 = two.getTime();
      long diff ;
      if(time1<time2) {
         diff = time2 - time1;
      } else {
         diff = time1 - time2;
      }
      day = diff / (24 * 60 * 60 * 1000);
   } catch (ParseException e) {
      e.printStackTrace();
   }
   return day;
}

方法十六：获取传入的两个时间字符串之间的时间段间隔的天时分数，返回一个数组

public static long[] getLateDistanceTimes(String beginDate, String endDate) {
   DateFormat df = new SimpleDateFormat(DATETIME_PATTERN);  //DATETIME_PATTERN  是类里面定义的类变量的日期格式  请看该博客最开始给的类的属性
   Date one;
   Date two;
   long day = 0;
   long hour = 0;
   long min = 0;
   long sec = 0;
   try {
      one = df.parse(beginDate);
      two = df.parse(endDate);
      long time1 = one.getTime();
      long time2 = two.getTime();
      long diff ;
      if(time1<time2) {
         diff = time2 - time1;
         day = diff / (24 * 60 * 60 * 1000);
         hour = (diff / (60 * 60 * 1000) - day * 24);
         min = ((diff / (60 * 1000)) - day * 24 * 60 - hour * 60);
         sec = (diff/1000-day*24*60*60-hour*60*60-min*60);
      }
   } catch (ParseException e) {
      e.printStackTrace();
   }
   long[] times = {day, hour, min, sec};

   return times;
}

方法十七：返回两个指定时段中的日期集合

public static List<String> getDays(String startTime, String endTime) {
   // 返回的日期集合
   List<String> days = new ArrayList<String>();
   DateFormat dateFormat = new SimpleDateFormat(DATE_PATTERN);  //DATE_PATTERN  是类里面定义的类变量的日期格式  请看该博客最开始给的类的属性
   try {
      Date start = dateFormat.parse(startTime);
      Date end = dateFormat.parse(endTime);
      Calendar tempStart = Calendar.getInstance();
      tempStart.setTime(start);
      Calendar tempEnd = Calendar.getInstance();
      tempEnd.setTime(end);
      tempEnd.add(Calendar.DATE, +1);// 日期加1(包含结束)
      while (tempStart.before(tempEnd)) {
         days.add( new SimpleDateFormat("MM-dd").format(tempStart.getTime()));
         tempStart.add(Calendar.DAY_OF_YEAR, 1);
      }
   } catch (ParseException e) {
      e.printStackTrace();
   }
   return days;
}

方法十八：通过传递时间段去获取该时间段中的每天日期

/**
 * @return 通过传递时间段去获取该时间段中的每天日期
 * @throws ParseException 
 * @see 开始时间和结束时间请传递类似于2018-12-12这样的时间-字符串
 *  DATE_PATTERN  是类里面定义的类变量的日期格式  请看该博客最开始给的类的属性
  */
public static final Date[] getDateArrays(String startPar,String endPar ,int calendarType)  {
   SimpleDateFormat sd = new SimpleDateFormat(DATE_PATTERN);      
   Date start = null;
   Date end = null;
   try {
      start = sd.parse(startPar);
      end = sd.parse(endPar);
   } catch (ParseException e) {
      e.printStackTrace();
   }
       ArrayList<Date> ret = new ArrayList<Date>();  
       Calendar calendar = Calendar.getInstance();  
       calendar.setTime(start);  
       Date tmpDate = calendar.getTime();  
       long endTime = end.getTime();  
       while(tmpDate.before(end)||tmpDate.getTime() == endTime){  
           ret.add(calendar.getTime());  
           calendar.add(calendarType, 1);  
           tmpDate = calendar.getTime();  
       }         
       Date[] dates = new Date[ret.size()];  
       return ret.toArray(dates);  
}

方法十九：通过传递时间参数(参数为Date类型的)，判断这天是星期几，如"星期日", “星期一”, “星期二”, “星期三”, “星期四”, “星期五”, “星期六”

/**
 * @return 通过传递时间参数，判断这天是星期几，如"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"
 * @throws ParseException 
 * @see 请传递类似于2018-12-12这样的时间
 */
public static final String getWeekDayByDate(Date date)  {
   Calendar cal = Calendar.getInstance();
   cal.setTime(date);
     String[] weekOfDays = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};             
     int w = cal.get(Calendar.DAY_OF_WEEK) - 1;      
     if (w < 0){        
         w = 0;      
     } 
   return weekOfDays[w];
}

方法二十：通过传递时间参数（参数为字符串形式），判断这天是星期几，如"星期日", “星期一”, “星期二”, “星期三”, “星期四”, “星期五”, “星期六”

/**
 * @return 通过传递时间参数，判断这天是星期几，如"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"
 * @throws ParseException 
 * @see 请传递类似于2018-12-12这样的时间字符串
 */
public static final String getWeekDayByDateStr(String dateStr)  {
   Calendar cal = Calendar.getInstance();
   SimpleDateFormat formt = new SimpleDateFormat(DATE_PATTERN);
   Date date = null;
   try {
      date = formt.parse(dateStr);
   } catch (ParseException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
   }
   cal.setTime(date);
     String[] weekOfDays = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};             
     int w = cal.get(Calendar.DAY_OF_WEEK) - 1;      
     if (w < 0){        
         w = 0;      
     } 
   return weekOfDays[w];
}

方法二十一：获取今天是星期几

/**
 * @return 今天是星期几，如"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"
 */
public static final String getWeekDay() {
   Calendar cal = Calendar.getInstance();
   cal.setTime(new Date());
     String[] weekOfDays = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};             
     int w = cal.get(Calendar.DAY_OF_WEEK) - 1;      
     if (w < 0){        
         w = 0;      
     } 
   return weekOfDays[w];
}

方法二十二：通过传递时间参数，判断这天属于几月


/**
 * @return 通过传递时间参数，判断这天是几月，如"一月", "二月", "三月", "四月", "五月", "六月", "七月", "八月", "九月", "十月", "十一月", "十二月"
 * @throws ParseException 
 * @see 请传递类似于2018-12-12这样的时间
 */
public static final String getMonthByDate(Date date) {
   Calendar cal = Calendar.getInstance();
   cal.setTime(date);
     String[] monthOfYear = {"一月", "二月", "三月", "四月", "五月", "六月", "七月", "八月", "九月", "十月", "十一月", "十二月"};             
     int m = cal.get(Calendar.MONDAY);   
     return monthOfYear[m];
}

方法二十三：获取传入时间的当前月

/**
 * 获取传入时间的当前月
 */
public static final int getMonth(Date date) {
   Calendar cal = Calendar.getInstance();
   cal.setTime(date);
   return cal.get(Calendar.MONTH)+1;
}

方法二十四：获取传入时间的当前年

/**
 * 获取传入时间的当前年
 */
public static final int getYear(Date date) {
   Calendar cal = Calendar.getInstance();
   cal.setTime(date);
   return cal.get(Calendar.YEAR);
}

方法二十五：获取传入时间的当月总共天数

/**
 * 获取传入时间的当月总共天数
 */
public static final int getDays(Date date) {
   Calendar cal = Calendar.getInstance();
   cal.setTime(date);
   return cal.getActualMaximum(Calendar.DAY_OF_MONTH);
}

方法二十六：将字符串转换成时间类型

public static final Date stringToDate(String dateStr, String format) {
   SimpleDateFormat sdf = new SimpleDateFormat(format);
   Date date = null;
   try {
      date = sdf.parse(dateStr);
   } catch (ParseException e) {
   }
   return date;
}