JAVA-时间类型的工具类

你算哪块小饼干咯

已于 2022-06-02 14:04:16 修改

阅读量609

点赞数

分类专栏： JAVA基础文章标签： java

于 2022-04-02 17:09:41 首次发布

本文链接：https://blog.csdn.net/weixin_46690278/article/details/123891356

版权

日期处理 Java 时间戳日历时间计算

关键词由CSDN通过智能技术生成

JAVA基础专栏收录该内容

31 篇文章 1 订阅

订阅专栏

import java.sql.Timestamp;
import java.util.*;

public class DateProUtil {
	
	public static void main(String[] args) {
//		System.out.println("当天开始时间："+getDayBegin());
//		System.out.println("当天结束时间："+getDayBegin());
//		System.out.println("昨天的开始时间:"+getBeginDayOfYesterday());
//		System.out.println("昨天的结束时间:"+getBeginDayOfYesterday());
//		System.out.println("明天的开始时间"+getBeginDayOfTomorrow());
//		System.out.println("明天的结束时间:"+getEndDayOfTomorrow());
//		System.out.println("昨天的结束时间:"+getBeginDayOfYesterday());
//		System.out.println("本周的开始时间:"+getBeginDayOfWeek());
//		System.out.println("本周的结束时间:"+getEndDayOfWeek());
//		System.out.println("上周的开始时间:"+getBeginDayOfLastWeek());
//		System.out.println("上周的结束时间:"+getEndDayOfLastWeek());
		System.out.println("本月的开始时间:"+getBeginDayOfMonth());
		System.out.println("本月的结束时间:"+getEndDayOfMonth());
		System.out.println("上月开始的时间:"+getBeginDayOfLastMonth());
		System.out.println("上月结束的时间:"+getEndDayOfLastMonth());
		System.out.println("下月开始的时间:"+getBeginDayOfNextMonth());
		System.out.println("下月结束的时间:"+getEndDayOfNextMonth());
		System.out.println("本年的开始时间"+getBeginDayOfYear());
		System.out.println("本年的结束时间"+getEndDayOfYear());
		System.out.println("某个日期的开始时间:"+getDayStartTime(new Date()));
		System.out.println("某个日期的结束时间:"+getDayEndTime(new Date()));
		System.out.println("今年是哪一年:"+getNowYear());
		System.out.println("本月是哪一月:"+getNowMonth());
		System.out.println("两个日期相减得到的天数"+getDiffDays(new Date(), new Date()));
		System.out.println("上月开始的时间:"+getBeginDayOfLastMonth());
		System.out.println("上月开始的时间:"+getBeginDayOfLastMonth());
		System.out.println("上月开始的时间:"+getBeginDayOfLastMonth());
		System.out.println("上月开始的时间:"+getBeginDayOfLastMonth());
	}
	
	/**
	 * 获取当天的开始时间
	 * @return
	 */
	public static Date getDayBegin() {
		Calendar cal = new GregorianCalendar();
		cal.set(Calendar.HOUR_OF_DAY, 0);
		cal.set(Calendar.MINUTE, 0);
		cal.set(Calendar.SECOND, 0);
		cal.set(Calendar.MILLISECOND, 0);
		return cal.getTime();
	}

	/**
	 * 获取当天的结束时间
	 * @return
	 */
	public static Date getDayEnd() {
		Calendar cal = new GregorianCalendar();
		cal.set(Calendar.HOUR_OF_DAY, 23);
		cal.set(Calendar.MINUTE, 59);
		cal.set(Calendar.SECOND, 59);
		return cal.getTime();
	}

	/**
	 * 获取昨天的开始时间
	 * @return
	 */
	public static Date getBeginDayOfYesterday() {
		Calendar cal = new GregorianCalendar();
		cal.setTime(getDayBegin());
		cal.add(Calendar.DAY_OF_MONTH, -1);
		return cal.getTime();
	}

	/**
	 * 获取昨天的结束时间
	 * @return
	 */
	public static Date getEndDayOfYesterDay() {
		Calendar cal = new GregorianCalendar();
		cal.setTime(getDayEnd());
		cal.add(Calendar.DAY_OF_MONTH, -1);
		return cal.getTime();
	}

	/**
	 * 获取明天的开始时间
	 * @return
	 */
	public static Date getBeginDayOfTomorrow() {
		Calendar cal = new GregorianCalendar();
		cal.setTime(getDayBegin());
		cal.add(Calendar.DAY_OF_MONTH, 1);
		return cal.getTime();
	}

	/**
	 * 获取明天的结束时间
	 * @return
	 */
	public static Date getEndDayOfTomorrow() {
		Calendar cal = new GregorianCalendar();
		cal.setTime(getDayEnd());
		cal.add(Calendar.DAY_OF_MONTH, 1);
		return cal.getTime();
	}

	/**
	 * 获取本周的开始时间
	 * @return
	 */
	@SuppressWarnings("unused")
	public static Date getBeginDayOfWeek() {
		Date date = new Date();
		if (date == null) {
			return null;
		}
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		int dayofweek = cal.get(Calendar.DAY_OF_WEEK);
		if (dayofweek == 1) {
			dayofweek += 7;
		}
		cal.add(Calendar.DATE, 2 - dayofweek);
		return getDayStartTime(cal.getTime());
	}

	/**
	 * 获取本周的结束时间
	 * @return
	 */
	public static Date getEndDayOfWeek() {
		Calendar cal = Calendar.getInstance();
		cal.setTime(getBeginDayOfWeek());
		cal.add(Calendar.DAY_OF_WEEK, 6);
		Date weekEndSta = cal.getTime();
		return getDayEndTime(weekEndSta);
	}

	/**
	 * 获取上周的开始时间
	 * @return
	 */
	@SuppressWarnings("unused")
	public static Date getBeginDayOfLastWeek() {
		Date date = new Date();
		if (date == null) {
			return null;
		}
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		int dayofweek = cal.get(Calendar.DAY_OF_WEEK);
		if (dayofweek == 1) {
			dayofweek += 7;
		}
		cal.add(Calendar.DATE, 2 - dayofweek - 7);
		return getDayStartTime(cal.getTime());
	}

	/**
	 * 获取上周的结束时间
	 * @return
	 */
	public static Date getEndDayOfLastWeek() {
		Calendar cal = Calendar.getInstance();
		cal.setTime(getBeginDayOfLastWeek());
		cal.add(Calendar.DAY_OF_WEEK, 6);
		Date weekEndSta = cal.getTime();
		return getDayEndTime(weekEndSta);
	}
	
	/**
	 * 获取下周的开始时间
	 * 
	 * @return
	 */
	@SuppressWarnings("unused")
	public static Date getBeginDayOfNextWeek() {
		Date date = new Date();
		if (date == null) {
			return null;
		}
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		int dayofweek = cal.get(Calendar.DAY_OF_WEEK);
		if (dayofweek == 1) {
			dayofweek += 7;
		}
		cal.add(Calendar.DATE, 2 - dayofweek + 7);
		return getDayStartTime(cal.getTime());
	}

	/**
	 * 获取下周的结束时间
	 * 
	 * @return
	 */
	public static Date getEndDayOfNextWeek() {
		Calendar cal = Calendar.getInstance();
		cal.setTime(getBeginDayOfNextWeek());
		cal.add(Calendar.DAY_OF_WEEK, 6);
		Date weekEndSta = cal.getTime();
		return getDayEndTime(weekEndSta);
	}

	/**
	 * 获取本月的开始时间
	 * @return
	 */
	public static Date getBeginDayOfMonth() {
		Calendar calendar = Calendar.getInstance();
		calendar.set(getNowYear(), getNowMonth() - 1, 1);
		return getDayStartTime(calendar.getTime());
	}

	/**
	 * 获取本月的结束时间
	 * @return
	 */
	public static Date getEndDayOfMonth() {
		Calendar calendar = Calendar.getInstance();
		calendar.set(getNowYear(), getNowMonth() - 1, 1);
		int day = calendar.getActualMaximum(5);
		calendar.set(getNowYear(), getNowMonth() - 1, day);
		return getDayEndTime(calendar.getTime());
	}

	/**
	 * 获取上月的开始时间
	 * @return
	 */
	public static Date getBeginDayOfLastMonth() {
		Calendar calendar = Calendar.getInstance();
		calendar.set(getNowYear(), getNowMonth() - 2, 1);
		return getDayStartTime(calendar.getTime());
	}

	/**
	 * 获取上月的结束时间
	 * @return
	 */
	public static Date getEndDayOfLastMonth() {
		Calendar calendar = Calendar.getInstance();
		calendar.set(getNowYear(), getNowMonth() - 2, 1);
		int day = calendar.getActualMaximum(5);
		calendar.set(getNowYear(), getNowMonth() - 2, day);
		return getDayEndTime(calendar.getTime());
	}

	/**
	 * 获取下月的开始时间
	 * @return
	 */
	public static Date getBeginDayOfNextMonth() {
		Calendar calendar = Calendar.getInstance();
		calendar.set(getNowYear(), getNowMonth(), 1);
		return getDayStartTime(calendar.getTime());
	}

	/**
	 * 获取下月的结束时间
	 * @return
	 */
	public static Date getEndDayOfNextMonth() {
		Calendar calendar = Calendar.getInstance();
		calendar.set(getNowYear(), getNowMonth(), 1);
		int day = calendar.getActualMaximum(5);
		calendar.set(getNowYear(), getNowMonth(), day);
		return getDayEndTime(calendar.getTime());
	}

	/**
	 * 获取本年的开始时间
	 * @return
	 */
	public static Date getBeginDayOfYear() {
		Calendar cal = Calendar.getInstance();
		cal.set(Calendar.YEAR, getNowYear());
		cal.set(Calendar.MONTH, Calendar.JANUARY);
		cal.set(Calendar.DATE, 1);
		return getDayStartTime(cal.getTime());
	}

	/**
	 * 获取本年的结束时间
	 * @return
	 */
	public static Date getEndDayOfYear() {
		Calendar cal = Calendar.getInstance();
		cal.set(Calendar.YEAR, getNowYear());
		cal.set(Calendar.MONTH, Calendar.DECEMBER);
		cal.set(Calendar.DATE, 31);
		return getDayEndTime(cal.getTime());
	}

	/**
	 * 获取某个日期的开始时间
	 * @param d
	 * @return
	 */
	public static Timestamp getDayStartTime(Date d) {
		Calendar calendar = Calendar.getInstance();
		if (null != d)
			calendar.setTime(d);
		calendar.set(calendar.get(Calendar.YEAR), calendar.get(Calendar.MONTH), calendar.get(Calendar.DAY_OF_MONTH), 0,
				0, 0);
		calendar.set(Calendar.MILLISECOND, 0);
		return new Timestamp(calendar.getTimeInMillis());
	}

	/**
	 * 获取某个日期的结束时间
	 * @param d
	 * @return
	 */
	public static Timestamp getDayEndTime(Date d) {
		Calendar calendar = Calendar.getInstance();
		if (null != d)
			calendar.setTime(d);
		calendar.set(calendar.get(Calendar.YEAR), calendar.get(Calendar.MONTH), calendar.get(Calendar.DAY_OF_MONTH), 23,
				59, 59);
		calendar.set(Calendar.MILLISECOND, 999);
		return new Timestamp(calendar.getTimeInMillis());
	}

	/**
	 * 获取今年是哪一年
	 * @return
	 */
	public static Integer getNowYear() {
		Date date = new Date();
		GregorianCalendar gc = (GregorianCalendar) Calendar.getInstance();
		gc.setTime(date);
		return Integer.valueOf(gc.get(1));
	}

	/**
	 * 获取本月是哪一月
	 * @return
	 */
	public static int getNowMonth() {
		Date date = new Date();
		GregorianCalendar gc = (GregorianCalendar) Calendar.getInstance();
		gc.setTime(date);
		return gc.get(2) + 1;
	}

	/**
	 * 两个日期相减得到的天数
	 * @param beginDate  开始日期
	 * @param endDate   结束日期
	 * @return
	 */
	public static int getDiffDays(Date beginDate, Date endDate) {
		if (beginDate == null || endDate == null) {
			throw new IllegalArgumentException("getDiffDays param is null!");
		}
		long diff = (endDate.getTime() - beginDate.getTime()) / (1000 * 60 * 60 * 24);
		int days = new Long(diff).intValue();
		return days;
	}

	/**
	 * 两个日期相减得到的毫秒数
	 * @param beginDate 开始日期
	 * @param endDate 结束日期
	 * @return
	 */
	public static long dateDiff(Date beginDate, Date endDate) {
		long date1ms = beginDate.getTime();
		long date2ms = endDate.getTime();
		return date2ms - date1ms;
	}

	/**
	 * 获取两个日期中的最大日期
	 * @param beginDate
	 * @param endDate
	 * @return
	 */
	public static Date max(Date beginDate, Date endDate) {
		if (beginDate == null) {
			return endDate;
		}
		if (endDate == null) {
			return beginDate;
		}
		if (beginDate.after(endDate)) {
			return beginDate;
		}
		return endDate;
	}

	/**
	 * 获取两个日期中的最小日期
	 * @param beginDate
	 * @param endDate
	 * @return
	 */
	public static Date min(Date beginDate, Date endDate) {
		if (beginDate == null) {
			return endDate;
		}
		if (endDate == null) {
			return beginDate;
		}
		if (beginDate.after(endDate)) {
			return endDate;
		}
		return beginDate;
	}

	/**
	 * 返回某月该季度的第一个月
	 * @param date
	 * @return
	 */
	public static Date getFirstSeasonDate(Date date) {
		final int[] SEASON = { 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4 };
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		int sean = SEASON[cal.get(Calendar.MONTH)];
		cal.set(Calendar.MONTH, sean * 3 - 3);
		return cal.getTime();
	}

	/**
	 * 返回某个日期下几天的日期
	 * @param date
	 * @param i
	 * @return
	 */
	public static Date getNextDay(Date date, int i) {
		Calendar cal = new GregorianCalendar();
		cal.setTime(date);
		cal.set(Calendar.DATE, cal.get(Calendar.DATE) + i);
		return cal.getTime();
	}

	/**
	 * 返回某个日期前几天的日期
	 * @param date
	 * @param i
	 * @return
	 */
	public static Date getFrontDay(Date date, int i) {
		Calendar cal = new GregorianCalendar();
		cal.setTime(date);
		cal.set(Calendar.DATE, cal.get(Calendar.DATE) - i);
		return cal.getTime();
	}

	/**
	 * 获取某年某月到某年某月按天的切片日期集合(间隔天数的集合)
	 * @param beginYear
	 * @param beginMonth
	 * @param endYear
	 * @param endMonth
	 * @param k
	 * @return
	 */
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public static List getTimeList(int beginYear, int beginMonth, int endYear, int endMonth, int k) {
		List list = new ArrayList();
		if (beginYear == endYear) {
			for (int j = beginMonth; j <= endMonth; j++) {
				list.add(getTimeList(beginYear, j, k));
			}
		} else {
			{
				for (int j = beginMonth; j < 12; j++) {
					list.add(getTimeList(beginYear, j, k));
				}
				for (int i = beginYear + 1; i < endYear; i++) {
					for (int j = 0; j < 12; j++) {
						list.add(getTimeList(i, j, k));
					}
				}
				for (int j = 0; j <= endMonth; j++) {
					list.add(getTimeList(endYear, j, k));
				}
			}
		}
		return list;
	}

	/**
	 * 获取某年某月按天切片日期集合(某个月间隔多少天的日期集合)
	 * @param beginYear
	 * @param beginMonth
	 * @param k
	 * @return
	 */
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public static List getTimeList(int beginYear, int beginMonth, int k) {
		List list = new ArrayList();
		Calendar begincal = new GregorianCalendar(beginYear, beginMonth, 1);
		int max = begincal.getActualMaximum(Calendar.DATE);
		for (int i = 1; i < max; i = i + k) {
			list.add(begincal.getTime());
			begincal.add(Calendar.DATE, k);
		}
		begincal = new GregorianCalendar(beginYear, beginMonth, max);
		list.add(begincal.getTime());
		return list;
	}

    /**
     * 得到当前日期的前一天日期
     * @return
     */
    public String getNowDate(){
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.DATE, -1); //得到前一天
        Date date = calendar.getTime();
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
        String yesterday=df.format(date);
        return yesterday;
    }    

    /**
     * 得到指定日期后x年日期
     * @param day
     * @return
     */
    public static Date getDateAfterYears(Date day,int year){
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(day);
        calendar.add(Calendar.DATE, +year); //得到后x年
        Date date = calendar.getTime();
        return date;
    }

    /**
     * 得到当前日期的前x天日期
     * @param day
     * @return
     */
    public static Date getNowDate(int day){
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.DATE, -day); //得到前x天
        Date date = calendar.getTime();
        return date;
    }

    /**
     * 得到当前日期的前x天日期
     * @param year
     * @return
     */
    public static Date getFutureDate(int year){
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.YEAR, +year); //得到前x年
        Date date = calendar.getTime();
        return date;
    }

     /**
     * 根据具体年份周数获取日期范围（2019-12-1~2019-12-7）
     * 传入（2019-51） 年+多少周
     * @param date
     * @return
     */
    public String getWeekDays(String date) {
        String[] arry=date.split("-");
        // 计算目标周数
        Integer targetNum=0;
        String str=arry[0];
        String wk=arry[1];
        int year=Integer.parseInt(str.trim());
        int week=Integer.parseInt(wk.trim());
        if (week + targetNum > 52) {
            year++;
            //修改：2020-01-07  sql查询出的是53周，导致页面出现两个一样的周数
            week += targetNum - 53;
        } else if (week + targetNum <= 0) {
            year--;
            week += targetNum + 52;
        } else {
            week += targetNum;
        }

        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
        Calendar cal=Calendar.getInstance();

        // 设置每周的开始日期
        cal.setFirstDayOfWeek(Calendar.SUNDAY);

        cal.set(Calendar.YEAR, year);
        cal.set(Calendar.WEEK_OF_YEAR, week);

        cal.set(Calendar.DAY_OF_WEEK, cal.getFirstDayOfWeek());
        String beginDate = sdf.format(cal.getTime());

        cal.add(Calendar.DAY_OF_WEEK, 6);
        String endDate = sdf.format(cal.getTime());
        return beginDate + "~" + endDate;
    }

    /**
     * 计算月份范围（2019-5 =2019-4~2019-5）
     * 传入（2019-5）年+月
     * @param dates
     * @return
     */
    public String getMonth(String dates){
        String[] arry=dates.split("-");
        // 计算目标周数
        String str=arry[0];
        String wk=arry[1];
        int year=Integer.parseInt(str.trim());//年
        int month=Integer.parseInt(wk.trim());//月
        int mon=0;
        int yea=0;
        if (month>0 && month<13){
            mon=month+1;
            if (mon==13){
                mon=1;
                yea=year+1;
            }else if (mon==2){
                yea=year+1;
            }
        }
        String date=year+"-"+month+"~"+yea+"-"+mon;
        return date;
    }
	
}

还有一些,等会儿补

========================================================================

import org.apache.commons.lang3.time.DateFormatUtils;

import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

public class DateUtil extends org.apache.commons.lang3.time.DateUtils {
	public static final String DATE_FORMATE_1 = "yyyy-MM-dd";

	public static final String DATE_FORMATE_2 = "yyyy-MM-dd HH:mm:ss";

	public static final String DATE_FORMATE_3 = "yyyy/MM/dd";

	public static final String DATE_FORMATE_4 = "yyyy/MM/dd HH:mm:ss";

	public static final String DATE_FORMATE_5 = "yyyyMMddHHmmss";

	private static String[] parsePatterns = { "yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", "yyyy-MM",
			"yyyy/MM/dd", "yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm", "yyyy/MM", "yyyy.MM.dd", "yyyy.MM.dd HH:mm:ss",
			"yyyy.MM.dd HH:mm", "yyyy.MM", "yyyyMMddHHmmss" };

	/**
	 * 得到当前日期字符串 格式（yyyy-MM-dd）
	 */
	public static String getDate() {
		return getDate("yyyy-MM-dd");
	}

	/**
	 * 得到当前日期字符串 格式（yyyyMM）
	 */
	public static String getDateMonth() {
		return getDate("yyyyMM");
	}
	/**
	 * 得到当前日期字符串 格式（yyyyMMdd）
	 */
	public static String getDateDay() {
		return getDate("yyyyMMdd");
	}

	/**
	 * 得到当前日期字符串 格式（yyyy-MM-dd） pattern可以为："yyyy-MM-dd" "HH:mm:ss" "E"
	 */
	public static String getDate(String pattern) {
		return DateFormatUtils.format(new Date(), pattern);
	}

	/**
	 * 得到指定日期后x分钟日期
	 * @param minute
	 * @return
	 */
	public static Date getDateAfterMinute(Date day,int minute){
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(day);
		calendar.add(Calendar.MINUTE, +minute); //得到后x分钟
		Date date = calendar.getTime();
		return date;
	}

	/**
	 * 得到日期字符串 默认格式（yyyy-MM-dd） pattern可以为："yyyy-MM-dd" "HH:mm:ss" "E"
	 */
	public static String formatDate(Date date, Object... pattern) {
		String formatDate;
		if (pattern != null && pattern.length > 0) {
			formatDate = DateFormatUtils.format(date, pattern[0].toString());
		} else {
			formatDate = DateFormatUtils.format(date, "yyyy-MM-dd");
		}
		return formatDate;
	}

	/**
	 * 得到日期时间字符串，转换格式（yyyy-MM-dd HH:mm:ss）
	 */
	public static String formatDateTime(Date date) {
		return formatDate(date, "yyyy-MM-dd HH:mm:ss");
	}

	/**
	 * 得到当前时间字符串 格式（HH:mm:ss）
	 */
	public static String getTime() {
		return formatDate(new Date(), "HH:mm:ss");
	}

	/**
	 * 得到当前日期和时间字符串 格式（yyyyMMddHHmmss）
	 */
	public static String getDateTimeStamp() {
		return formatDate(new Date(), "yyyyMMddHHmmss");
	}
	/**
	 * 得到当前日期和时间字符串 格式（yyyy-MM-dd HH:mm:ss）
	 */
	public static String getDateTime() {
		return formatDate(new Date(), "yyyy-MM-dd HH:mm:ss");
	}

	public static String getDateTime(String pattern) {
		return formatDate(new Date(), pattern);
	}

	/**
	 * 得到当前年份字符串 格式（yyyy）
	 */
	public static String getYear() {
		return formatDate(new Date(), "yyyy");
	}

	/**
	 * 得到当前月份字符串 格式（MM）
	 */
	public static String getMonth() {
		return formatDate(new Date(), "MM");
	}

	/**
	 * 得到当天字符串 格式（dd）
	 */
	public static String getDay() {
		return formatDate(new Date(), "dd");
	}

	/**
	 * 得到当前星期字符串 格式（E）星期几
	 */
	public static String getWeek() {
		return formatDate(new Date(), "E");
	}

	/**
	 * 日期型字符串转化为日期 格式 { "yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm",
	 * "yyyy/MM/dd", "yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm", "yyyy.MM.dd",
	 * "yyyy.MM.dd HH:mm:ss", "yyyy.MM.dd HH:mm" }
	 */
	public static Date parseDate(Object str) {
		if (str == null) {
			return null;
		}

		try {
			return parseDate(str.toString(), parsePatterns);
		} catch (ParseException e) {
			return null;
		}
	}

	/**
	 * 获取过去的天数
	 */
	public static long pastDays(Date date) {
		long t = System.currentTimeMillis() - date.getTime();
		return t / (24 * 60 * 60 * 1000);
	}

	/**
	 * 获取过去的小时
	 */
	public static long pastHour(Date date) {
		long t = System.currentTimeMillis() - date.getTime();
		return t / (60 * 60 * 1000);
	}

	/**
	 * 获取过去的分钟
	 */
	public static long pastMinutes(Date date) {
		long t = System.currentTimeMillis() - date.getTime();
		return t / (60 * 1000);
	}

	/**
	 * 转换为时间（天,时:分:秒.毫秒）
	 */
	public static String formatDateTime(long timeMillis) {
		long day = timeMillis / (24 * 60 * 60 * 1000);
		long hour = (timeMillis / (60 * 60 * 1000) - day * 24);
		long min = ((timeMillis / (60 * 1000)) - day * 24 * 60 - hour * 60);
		long s = (timeMillis / 1000 - day * 24 * 60 * 60 - hour * 60 * 60 - min * 60);
		long sss = (timeMillis - day * 24 * 60 * 60 * 1000 - hour * 60 * 60 * 1000 - min * 60 * 1000 - s * 1000);
		return (day > 0 ? day + "," : "") + hour + ":" + min + ":" + s + "." + sss;
	}

	/**
	 * 获取两个日期之间的天数
	 */
	public static double getDistanceOfTwoDate(Date before, Date after) {
		long beforeTime = before.getTime();
		long afterTime = after.getTime();
		return (afterTime - beforeTime) / (1000 * 60 * 60 * 24);
	}

	public static Timestamp getTimestamp() {
		return new Timestamp(System.currentTimeMillis());
	}

	/**
	 * 获取当前时间之前或之后 N 天的时间
	 *
	 * @param i
	 *            天数, 负数为之前天数, 正数为之后天数
	 */
	public static Timestamp getTimestamp(int i) {
		Date date = new Date();

		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		calendar.add(Calendar.DAY_OF_MONTH, i);
		date = calendar.getTime();

		return new Timestamp(date.getTime());
	}
	
	/**
	 * String时间字符串转换LocalDateTime
	 * @param str
	 * @return
	 */
	public static LocalDateTime stringToLocalDateTime(String str) {
		if (str != null && !"".equals(str.trim())) {
			str = str.replaceAll("/", "-");
			if (str.contains("Z")){
				DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
				return LocalDateTime.parse(str, df);
			}else {
				DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
				LocalDateTime ldt = LocalDateTime.parse(str, df);
				return ldt;
			}
		}
		return null;
	}

	/**
	 * yyyy-MM-dd'T'HH:mm:ss.SSS'Z'
	 * String时间字符串转换LocalDateTime
	 * @param str
	 * @return
	 */
	public static LocalDateTime longTimeToLocalDateTime(String str) {
		if (str != null && !"".equals(str.trim())) {
			DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
			return LocalDateTime.parse(str, df);
		}
		return null;
	}

	/**
	 * yyyy-MM-dd格式的String时间字符串转换LocalDateTime
	 * @param str
	 * @return
	 */
	public static LocalDateTime TimeToLocalDateTime(String str) {
		SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		Date date = null;
		try {
			date = simpleDateFormat.parse(str + " 00:00:00");
		} catch (ParseException e) {
			e.printStackTrace();
		}
		LocalDateTime localDateTime = formatDateToLocalDateTime(date);
		return localDateTime;
	}

	/**
	 * String时间字符串转换LocalDate
	 * @param str
	 * @return
	 */
	public static LocalDate stringToLocalDate(String str) {
		if (str!=null && !str.trim().equals("")) {
			return  LocalDate.parse(str, DateTimeFormatter.ofPattern("yyyy-MM-dd"));
		}
		return null;
	}
	
	 /**
     * 日期转星期
     * @param date yyyy-MM-dd
     * @return
     */
    public static String dateToWeek(String date) {
        SimpleDateFormat f = new SimpleDateFormat("yyyy-MM-dd");
        String[] weekDays = { "周日", "周一", "周二", "周三", "周四", "周五", "周六" };
        Calendar cal = Calendar.getInstance(); // 获得一个日历
        try {
            Date dateT = f.parse(date);
            cal.setTime(dateT);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        int w = cal.get(Calendar.DAY_OF_WEEK) - 1; // 指示一个星期中的某天。
        if (w < 0)
            w = 0;
        return weekDays[w];
    }

	/**
	 * 获取当天0点0时0分0秒
	 * @return
	 */
	public static String todayBeginTime(){
		SimpleDateFormat sdfYMD = new SimpleDateFormat(DATE_FORMATE_2);
		Calendar calendar = calendarInit();
		String format = sdfYMD.format(calendar.getTime());
		return format;
	}

	/**
	 * 获取昨天0点0时0分0秒
	 * @return
	 */
	public static String yesterdayBeginTime(){
		SimpleDateFormat sdfYMD = new SimpleDateFormat(DATE_FORMATE_2);
		Calendar calendar = calendarInit();
		calendar.add(Calendar.DATE,-1); //当前日期加一
		String format  = sdfYMD.format(calendar.getTime());
		return format;
	}

	/**
	 * calendar初始化-当天0点0时0分0秒
	 * @return
	 */
	public static Calendar calendarInit(){
		Calendar calendar = Calendar.getInstance();
		calendar.set(Calendar.SECOND,0); //这是将当天的【秒】设置为0
		calendar.set(Calendar.MINUTE,0); //这是将当天的【分】设置为0
		calendar.set(Calendar.HOUR_OF_DAY,0); //这是将当天的【时】设置为0
		return calendar;
	}

	/**
	 * 日期范围 - 切片
	 * @param startDate 起始日期
	 * @param endDate 结束日期
	 * @param type 切片类型 1-年 2-月 3-日 4-小时
	 * @return 切片日期
	 */
	public static List<String> sliceUpDateRange(String startDate, String endDate , int type ) {
		List<String> rs = new ArrayList<>();

		try {
			int dt = Calendar.DATE;
			String pattern = "yyyy-MM-dd";
			if (type==1) {
				pattern = "yyyy";
				dt = Calendar.YEAR;
			} else if (type==2) {
				pattern = "yyyy-MM";
				dt = Calendar.MONTH;
			} else if (type==3) {
				pattern = "yyyy-MM-dd";
				dt = Calendar.DATE;
			}else if (type==4) {
				pattern = "yyyy-MM-dd HH";
				dt = Calendar.HOUR_OF_DAY;
			}
			SimpleDateFormat sd = new SimpleDateFormat(pattern);
			Calendar sc = Calendar.getInstance();
			Calendar ec = Calendar.getInstance();
			sc.setTime(sd.parse(startDate));
			ec.setTime(sd.parse(endDate));
			while (sc.compareTo(ec) < 1) {
				rs.add(sd.format(sc.getTime()));
				sc.add(dt, 1);
			}
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return rs;
	}

	/**
	 * LocalDateTime转String
	 * @param date
	 * @return
	 */
	public static String formatLocalDateTimeString(LocalDateTime date) {
		DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
		return date.format(dtf);
	}

	/**
	 * Date转LocalDateTime
	 * @param date
	 * @return
	 */
	public static LocalDateTime formatDateToLocalDateTime(Date date){
		LocalDateTime localDateTime = date.toInstant().atZone(ZoneOffset.ofHours(8)).toLocalDateTime();
//		LocalDate localDate = date.toInstant().atZone(ZoneOffset.ofHours(8)).toLocalDate();
		return localDateTime;
	}


}

LocalDateTime类型比较大小:

    /**
     * 比较日期大小 A小于B
     * @param date1
     * @param date2
     * @return true 小于 false 大于
     */
    public static boolean localDateBefore(Date date1,Date date2) {
        Instant startTime = date1.toInstant();
        Instant endTime = date2.toInstant();
        ZoneId zoneId = ZoneId.systemDefault();
        LocalDateTime startDate = LocalDateTime.ofInstant(startTime, zoneId);
        LocalDateTime endDate = LocalDateTime.ofInstant(endTime, zoneId);
        return startDate.isBefore(endDate);
    }


    /**
     * 比较日期大小 A大于B
     * @param date1
     * @param date2
     * @return true 大于 false 小于
     */
    public static boolean localDateAfter(Date date1,Date date2) {
        Instant startTime = date1.toInstant();
        Instant endTime = date2.toInstant();
        ZoneId zoneId = ZoneId.systemDefault();
        LocalDateTime startDate = LocalDateTime.ofInstant(startTime, zoneId);
        LocalDateTime endDate = LocalDateTime.ofInstant(endTime, zoneId);
        return startDate.isAfter(endDate);
    }


   /**
     * 比较日期大小 A等于B
     * @param date1
     * @param date2
     * @return true 相等 false 不相等
     */
    public static boolean localDateEqual(Date date1,Date date2) {
        Instant startTime = date1.toInstant();
        Instant endTime = date2.toInstant();
        ZoneId zoneId = ZoneId.systemDefault();
        LocalDateTime startDate = LocalDateTime.ofInstant(startTime, zoneId);
        LocalDateTime endDate = LocalDateTime.ofInstant(endTime, zoneId);
        return startDate.isEqual(endDate);
    }

List对象过滤时间区间:

if(StringUtils.isNotBlank(param.getStartApplyDate())){
                tmpList = tmpList.stream().filter(t -> param.getStartApplyDate() != null && t.getApplyDate().isAfter(DateUtil.TimeToLocalDateTime(param.getStartApplyDate()))).collect(Collectors.toList());
            }
if(StringUtils.isNotBlank(param.getEndApplyDate())){
                tmpList = tmpList.stream().filter(t -> param.getEndApplyDate() != null && t.getApplyDate().isBefore(DateUtil.TimeToLocalDateTime(param.getEndApplyDate()))).collect(Collectors.toList());
            }

1.LocalDate转Date

LocalDate nowLocalDate = LocalDate.now();
Date date = Date.from(localDate.atStartOfDay(ZoneOffset.ofHours(8)).toInstant());

2.LocalDateTime转Date

LocalDateTime localDateTime = LocalDateTime.now();
Date date = Date.from(localDateTime.atZone(ZoneOffset.ofHours(8)).toInstant());

3.Date转LocalDateTime(LocalDate)

Date date =newDate();
LocalDateTime localDateTime = date.toInstant().atZone(ZoneOffset.ofHours(8)).toLocalDateTime();
LocalDate localDate = date.toInstant().atZone(ZoneOffset.ofHours(8)).toLocalDate();

4.LocalDate转时间戳

LocalDate localDate = LocalDate.now();
longtimestamp = localDate.atStartOfDay(ZoneOffset.ofHours(8)).toInstant().toEpochMilli();

5.LocalDateTime转时间戳

LocalDateTime localDateTime = LocalDateTime.now();
longtimestamp = localDateTime.toInstant(ZoneOffset.ofHours(8)).toEpochMilli();

6.时间戳转LocalDateTime(LocalDate)

longtimestamp = System.currentTimeMillis();
LocalDate localDate = Instant.ofEpochMilli(timestamp).atZone(ZoneOffset.ofHours(8)).toLocalDate();
LocalDateTime localDateTime = Instant.ofEpochMilli(timestamp).atZone(ZoneOffset.ofHours(8)).toLocalDateTime();

获取系统时间

SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); 
System.out.println(df.format(System.currentTimeMillis()));

后面再有再补~~~~~~~~~~

你算哪块小饼干咯

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录