Java常用日期格式转换工具类

最新推荐文章于 2024-06-22 11:08:31 发布
最新推荐文章于 2024-06-22 11:08:31 发布
阅读量213 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qigeshenmemingne/article/details/104923776
版权 
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import org.apache.commons.lang.StringUtils;

public class DateUtils {

	public static final String DATE_TIME_PATTERN = "yyyy-MM-dd HH:mm:ss";
	public static final String MINUTE_PATTERN = "yyyy-MM-dd HH:mm";
	public static final String HOUR_PATTERN = "yyyy-MM-dd HH:mm:ss";
	public static final String DATE_PATTERN = "yyyy-MM-dd";
	public static final String MONTH_PATTERN = "yyyy-MM";
	public static final String YEAR_PATTERN = "yyyy";
	public static final String MINUTE_ONLY_PATTERN = "mm";
	public static final String HOUR_ONLY_PATTERN = "HH";

	/**
	 * 日期相加减天数
	 * 
	 * @param date
	 *            如果为Null，则为当前时间
	 * @param days
	 *            加减天数
	 * @param includeTime
	 *            是否包括时分秒,true表示包含
	 * @return
	 * @throws ParseException
	 */
	public static Date dateAdd(Date date, int days, boolean includeTime) throws ParseException {
		if (date == null) {
			date = new Date();
		}
		if (!includeTime) {
			SimpleDateFormat sdf = new SimpleDateFormat(DateUtils.DATE_PATTERN);
			date = sdf.parse(sdf.format(date));
		}
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		cal.add(Calendar.DATE, days);
		return cal.getTime();
	}

	/**
	 * 时间格式化成字符串
	 * 
	 * @param date
	 *            Date
	 * @param pattern
	 *            StrUtils.DATE_TIME_PATTERN || StrUtils.DATE_PATTERN，
	 *            如果为空，则为yyyy-MM-dd
	 * @return
	 * @throws ParseException
	 */
	public static String dateFormat(Date date, String pattern) throws ParseException {
		if (StringUtils.isBlank(pattern)) {
			pattern = DateUtils.DATE_PATTERN;
		}
		SimpleDateFormat sdf = new SimpleDateFormat(pattern);
		return sdf.format(date);
	}

	/**
	 * 字符串解析成时间对象
	 * 
	 * @param dateTimeString
	 *            String
	 * @param pattern
	 *            StrUtils.DATE_TIME_PATTERN ||
	 *            StrUtils.DATE_PATTERN，如果为空，则为yyyy-MM-dd
	 * @return
	 * @throws ParseException
	 */
	public static Date dateParse(String dateTimeString, String pattern) throws ParseException {
		if (StringUtils.isBlank(pattern)) {
			pattern = DateUtils.DATE_PATTERN;
		}
		SimpleDateFormat sdf = new SimpleDateFormat(pattern);
		return sdf.parse(dateTimeString);
	}

	/**
	 * 将日期时间格式成只有日期的字符串（可以直接使用dateFormat，Pattern为Null进行格式化）
	 * 
	 * @param dateTime
	 *            Date
	 * @return
	 * @throws ParseException
	 */
	public static String dateTimeToDateString(Date dateTime) throws ParseException {
		String dateTimeString = DateUtils.dateFormat(dateTime, DateUtils.DATE_TIME_PATTERN);
		return dateTimeString.substring(0, 10);
	}

	/**
	 * 当时、分、秒为00:00:00时，将日期时间格式成只有日期的字符串， 当时、分、秒不为00:00:00时，直接返回
	 * 
	 * @param dateTime
	 *            Date
	 * @return
	 * @throws ParseException
	 */
	public static String dateTimeToDateStringIfTimeEndZero(Date dateTime) throws ParseException {
		String dateTimeString = DateUtils.dateFormat(dateTime, DateUtils.DATE_TIME_PATTERN);
		if (dateTimeString.endsWith("00:00:00")) {
			return dateTimeString.substring(0, 10);
		} else {
			return dateTimeString;
		}
	}

	/**
	 * 将日期时间格式成日期对象，和dateParse互用
	 * 
	 * @param dateTime
	 *            Date
	 * @return Date
	 * @throws ParseException
	 */
	public static Date dateTimeToDate(Date dateTime) throws ParseException {
		Calendar cal = Calendar.getInstance();
		cal.setTime(dateTime);
		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();
	}

	/**
	 * 时间加减小时
	 * 
	 * @param startDate
	 *            要处理的时间，Null则为当前时间
	 * @param hours
	 *            加减的小时
	 * @return Date
	 */
	public static Date dateAddHours(Date startDate, int hours) {
		if (startDate == null) {
			startDate = new Date();
		}
		Calendar c = Calendar.getInstance();
		c.setTime(startDate);
		c.set(Calendar.HOUR, c.get(Calendar.HOUR) + hours);
		return c.getTime();
	}

	/**
	 * 时间加减分钟
	 * 
	 * @param startDate
	 *            要处理的时间，Null则为当前时间
	 * @param minutes
	 *            加减的分钟
	 * @return
	 */
	public static Date dateAddMinutes(Date startDate, int minutes) {
		if (startDate == null) {
			startDate = new Date();
		}
		Calendar c = Calendar.getInstance();
		c.setTime(startDate);
		c.set(Calendar.MINUTE, c.get(Calendar.MINUTE) + minutes);
		return c.getTime();
	}

	/**
	 * 时间加减秒数
	 * 
	 * @param startDate
	 *            要处理的时间，Null则为当前时间
	 * @param minutes
	 *            加减的秒数
	 * @return
	 */
	public static Date dateAddSeconds(Date startDate, int seconds) {
		if (startDate == null) {
			startDate = new Date();
		}
		Calendar c = Calendar.getInstance();
		c.setTime(startDate);
		c.set(Calendar.SECOND, c.get(Calendar.SECOND) + seconds);
		return c.getTime();
	}

	/**
	 * 时间加减天数
	 * 
	 * @param startDate
	 *            要处理的时间，Null则为当前时间
	 * @param days
	 *            加减的天数
	 * @return Date
	 */
	public static Date dateAddDays(Date startDate, int days) {
		if (startDate == null) {
			startDate = new Date();
		}
		Calendar c = Calendar.getInstance();
		c.setTime(startDate);
		c.set(Calendar.DATE, c.get(Calendar.DATE) + days);
		return c.getTime();
	}

	/**
	 * 时间加减月数
	 * 
	 * @param startDate
	 *            要处理的时间，Null则为当前时间
	 * @param months
	 *            加减的月数
	 * @return Date
	 */
	public static Date dateAddMonths(Date startDate, int months) {
		if (startDate == null) {
			startDate = new Date();
		}
		Calendar c = Calendar.getInstance();
		c.setTime(startDate);
		c.set(Calendar.MONTH, c.get(Calendar.MONTH) + months);
		return c.getTime();
	}

	/**
	 * 时间加减年数
	 * 
	 * @param startDate
	 *            要处理的时间，Null则为当前时间
	 * @param years
	 *            加减的年数
	 * @return Date
	 */
	public static Date dateAddYears(Date startDate, int years) {
		if (startDate == null) {
			startDate = new Date();
		}
		Calendar c = Calendar.getInstance();
		c.setTime(startDate);
		c.set(Calendar.YEAR, c.get(Calendar.YEAR) + years);
		return c.getTime();
	}

	/**
	 * 时间比较（如果myDate>compareDate返回1，<返回-1，相等返回0）
	 * 
	 * @param myDate
	 *            时间
	 * @param compareDate
	 *            要比较的时间
	 * @return int
	 */
	public static int dateCompare(Date myDate, Date compareDate) {
		Calendar myCal = Calendar.getInstance();
		Calendar compareCal = Calendar.getInstance();
		myCal.setTime(myDate);
		compareCal.setTime(compareDate);
		return myCal.compareTo(compareCal);
	}

	/**
	 * 获取两个时间中最小的一个时间
	 * 
	 * @param date
	 * @param compareDate
	 * @return
	 */
	public static Date dateMin(Date date, Date compareDate) {
		if (date == null) {
			return compareDate;
		}
		if (compareDate == null) {
			return date;
		}
		if (1 == dateCompare(date, compareDate)) {
			return compareDate;
		} else if (-1 == dateCompare(date, compareDate)) {
			return date;
		}
		return date;
	}

	/**
	 * 获取两个时间中最大的一个时间
	 * 
	 * @param date
	 * @param compareDate
	 * @return
	 */
	public static Date dateMax(Date date, Date compareDate) {
		if (date == null) {
			return compareDate;
		}
		if (compareDate == null) {
			return date;
		}
		if (1 == dateCompare(date, compareDate)) {
			return date;
		} else if (-1 == dateCompare(date, compareDate)) {
			return compareDate;
		}
		return date;
	}

	/**
	 * 获取两个日期（不含时分秒）相差的天数，不包含今天
	 * 
	 * @param startDate
	 * @param endDate
	 * @return
	 * @throws ParseException
	 */
	public static int dateBetween(Date startDate, Date endDate) throws ParseException {
		Date dateStart = dateParse(dateFormat(startDate, DATE_PATTERN), DATE_PATTERN);
		Date dateEnd = dateParse(dateFormat(endDate, DATE_PATTERN), DATE_PATTERN);
		return (int) ((dateEnd.getTime() - dateStart.getTime()) / 1000 / 60 / 60 / 24);
	}

	/**
	 * 获取两个日期（不含时分秒）相差的天数，包含今天
	 * 
	 * @param startDate
	 * @param endDate
	 * @return
	 * @throws ParseException
	 */
	public static int dateBetweenIncludeToday(Date startDate, Date endDate) throws ParseException {
		return dateBetween(startDate, endDate) + 1;
	}

	/**
	 * 获取日期时间的年份，如2017-02-13，返回2017
	 * 
	 * @param date
	 * @return
	 */
	public static int getYear(Date date) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		return cal.get(Calendar.YEAR);
	}

	/**
	 * 获取日期时间的月份，如2017年2月13日，返回2
	 * 
	 * @param date
	 * @return
	 */
	public static int getMonth(Date date) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		return cal.get(Calendar.MONTH) + 1;
	}

	/**
	 * 获取日期时间的第几天（即返回日期的dd），如2017-02-13，返回13
	 * 
	 * @param date
	 * @return
	 */
	public static int getDate(Date date) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		return cal.get(Calendar.DATE);
	}

	/**
	 * 获取日期时间当月的总天数，如2017-02-13，返回28
	 * 
	 * @param date
	 * @return
	 */
	public static int getDaysOfMonth(Date date) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		return cal.getActualMaximum(Calendar.DATE);
	}

	/**
	 * 获取日期时间当年的总天数，如2017-02-13，返回2017年的总天数
	 * 
	 * @param date
	 * @return
	 */
	public static int getDaysOfYear(Date date) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		return cal.getActualMaximum(Calendar.DAY_OF_YEAR);
	}

	/**
	 * 根据时间获取当月最大的日期 <li>2017-02-13，返回2017-02-28</li> <li>
	 * 2016-02-13，返回2016-02-29</li> <li>2016-01-11，返回2016-01-31</li>
	 * 
	 * @param date
	 *            Date
	 * @return
	 * @throws Exception
	 */
	public static Date maxDateOfMonth(Date date) throws Exception {
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		int value = cal.getActualMaximum(Calendar.DATE);
		return dateParse(dateFormat(date, MONTH_PATTERN) + "-" + value, null);
	}

	/**
	 * 根据时间获取当月最小的日期，也就是返回当月的1号日期对象
	 * 
	 * @param date
	 *            Date
	 * @return
	 * @throws Exception
	 */
	public static Date minDateOfMonth(Date date) throws Exception {
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		int value = cal.getActualMinimum(Calendar.DATE);
		return dateParse(dateFormat(date, MONTH_PATTERN) + "-" + value, null);
	}

	/*public static void main(String[] args) throws Exception {
		
		 * System.out.println(dateTimeToDate(new Date()));
		 * System.out.println(dateParse("2017-02-04 14:58:20", null));
		 * System.out.println(dateTimeToDateStringIfTimeEndZero(new Date()));
		 * System
		 * .out.println(dateTimeToDateStringIfTimeEndZero(dateTimeToDate(new
		 * Date())));
		 
		// System.out.println(dateBetween(dateParse("2017-01-30", null),
		// dateParse("2017-02-01", null)));
		// System.out.println(dateBetweenIncludeToday(dateParse("2017-01-30",
		// null), dateParse("2017-02-01", null)));
		System.out.println(getDate(dateParse("2017-01-17", null)));
		
		 * System.out.println(getDaysOfMonth(dateParse("2017-02-01", null)));
		 * System.out.println(getDaysOfYear(dateParse("2017-01-30", null)));
		 
		// System.out.println(dateFormat(dateAddMonths(dateParse("2017-02-07",
		// StrUtils.MONTH_PATTERN), -12), StrUtils.MONTH_PATTERN));
		
		 * System.out.println(dateFormat(maxDateOfMonth(dateParse("2016-02",
		 * "yyyy-MM")), null));
		 * System.out.println(dateFormat(minDateOfMonth(dateParse("2016-03-31",
		 * null)), null));
		 
	}*/

	/**
     * 判断是否是工作时间，8:30-11:30    13:30-17:00	周六	周日(bky：9.26)
     * @param nowTime
     * @return
     */
    public static boolean isWorkTime(String nowTime) {
    	
    	try{
    		SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
    		Date aBegin = sdf.parse("00:00:00");
    		Date aEnd = sdf.parse("00:00:00");
    		
    		Date bmBegin = sdf.parse("23:59:59");
    		Date bmEnd = sdf.parse("23:59:59");
    		
    		//2018.10.10开始24小时
    		/*Date aBegin = sdf.parse("00:00:00");
    		Date aEnd = sdf.parse("23:59:59");*/
    		
    		//判断是否是周末
    		/*SimpleDateFormat sdf14 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    		if("6".equals(getWeekOfDate(sdf14.parse(nowTime))) || "7".equals(getWeekOfDate(sdf14.parse(nowTime)))){
    			return false;
    		}*/
    		
    		//判断是否是工作时间
    		String hTime = nowTime.substring(nowTime.indexOf(" ")+1);
    		if(!isEffectiveDate(sdf.parse(hTime), aBegin, aEnd) && !isEffectiveDate(sdf.parse(hTime), bmBegin, bmEnd)){
    			return true;
    		}else{
    			return false;
    		}
    		/*if(!isEffectiveDate(sdf.parse(hTime), aBegin, aEnd)){
    			return true;
    		}else{
    			return false;
    		}*/
    	}catch(Exception e){
    		return false;
    	}
		
    }

    /**
     * 判断当前时间是否在[startTime, endTime]区间，注意时间格式要一致(bky:9.26)
     */
	public static boolean isEffectiveDate(Date nowTime, Date startTime, Date endTime) {
        if (nowTime.getTime() == startTime.getTime()
                || nowTime.getTime() == endTime.getTime()) {
            return true;
        }

        Calendar date = Calendar.getInstance();
        date.setTime(nowTime);

        Calendar begin = Calendar.getInstance();
        begin.setTime(startTime);

        Calendar end = Calendar.getInstance();
        end.setTime(endTime);

        if (date.after(begin) && date.before(end)) {
            return true;
        } else {
            return false;
        }
    }

	/**
     * 获取当前日期是星期几(bky:9.26)
     * 
     * @param dt
     * @return 当前日期是星期几
     */
    public static String getWeekOfDate(Date dt) {
        String[] weekDays = {"7", "1", "2", "3", "4", "5", "6"};
        Calendar cal = Calendar.getInstance();
        cal.setTime(dt);
        int w = cal.get(Calendar.DAY_OF_WEEK) - 1;
        if (w < 0)
            w = 0;
        return weekDays[w];
    }

	public static String subtract_date(String DATE1, String DATE2) {

        DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
	            Date date1 = df.parse(DATE1);
	            Date date2 = df.parse(DATE2);
	            // 得到微秒级别的差值
	            long diff = date2.getTime() - date1.getTime();
	            // 将级别提升到天
	            long days = diff / (1000 * 60 * 60 * 24);
		         // if(days<1){
		         // days = 0;
		         // }
		         // 将级别提升到小时
		         long hours = diff / (1000 * 60 * 60);
		         // if(hours<1){
		         // hours = 0;
		         // }
		         // 将级别提升到分钟
		         long minutes = diff / (1000 * 60);
		         // if(minutes<1){
		         // minutes = 0;
		         // }
		         //将级别提升到秒
		         long seconds = diff / 1000;
		
		         return seconds+"";

	     } catch (Exception e) {
	         e.printStackTrace();
	     }
        return null;
    }

	/*public static void main(String[] args) throws Exception {
		SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		System.out.println(subtract_date("2018-08-08 12:00:00", "2018-08-08 13:00:00"));
	}*/
}
失眠患者1
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
日期格式转化工具类(java版本)
10-24
史上最全日期类型转化，包括各种形式的日期转化，时间转化。并可以获取当前年份，月份，以及当前星期等。可以获取过去的时间时间，小时，分钟数等。
java日期工具类-各种转换
06-22
各种日期格式化和转换 将 Calendar 转为字符串 获取当前月份的最后一天 根据 timestamp 生成各类时间状态串 计算两个日期之间相差的天数 等等等等
java日期格式转换工具类
小柒的专栏
09-18 9090
package com.ace.backoffice.utils; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; import javax.xml.datatype.DatatypeConfiguratio
Java时间转换工具类
最新发布
pangHu很菜
06-22 3051
【代码】Java时间转换工具类。
JAVA日期转换工具类
m0_49229693的博客
07-29 1026
JAVA日期转换工具类
Java日期格式转换工具类
福建开源社区创始人www.fjkysq.com
09-09 419
此文章转载于福建开源社区http://www.fjkysq.com Java中util包下有很多的工具类及方法，但往往有很多并能直接用到业务中，我们需要在这些工具上进行一些加工，比如日期格式，以下带有Main方法，可以自行调试，然后加上注释，以便以后使用。 import java.sql.Timestamp; import java.text.ParseException; import j...
Java常用的时间工具类实例
08-30
本文主要介绍了Java常用的时间工具类，结合具体实例形式分析了Java日期时间的常用转换、判断、输出相关操作技巧。 首先，时间工具类（DateUtils）是一个非常重要的工具类，它提供了一系列的时间处理方法，如将时间...
java常用工具类 Date日期、Mail邮件工具类
08-25
Date 日期工具类是 Java 中的一个基本工具类，提供了对日期和时间的操作和格式化。DateHelper 类是 Date 日期工具类的一个实现，提供了多种方法来操作和格式化日期。 1. 日期格式化 DateHelper 类提供了多种方法来...
Java实现时间日期格式转换示例
08-31
本文将深入探讨Java中如何实现日期和时间的格式转换。 首先，Java通过`java.text.SimpleDateFormat`类来实现日期和时间的格式化。这个类允许我们定义日期和时间的输出格式，并将其转换为字符串。例如，在`...
Java语言Lang包下常用的工具类介绍
08-29
DateFormatUtils类提供了许多实用的方法，可以帮助开发者快速处理日期和时间格式转换。例如，format方法可以将日期转换为字符串；parse方法可以将字符串转换为日期等。 5. DateUtils类： DateUtils类提供了许多...
java针对于时间转换的DateUtils工具类
08-28
Java 中的 DateUtils 工具类是 Java 语言中的一种常用工具类，用于处理日期和时间的转换。该工具类提供了多种日期和时间的转换方法，包括 String 转 Timestamp、String 转 Date、Date 转 String、Date 转 Timestamp ...
一个非常好的Java工具类(字符窜处理，时间格式转换，加密解密等)
07-16
一个非常好的Java工具类 包括字符窜加密解密，非法字符过滤和替换 时间格式转换，常用验证等等很多非常有用的函数
Java日期转换工具类
Siege_Lion的博客
06-09 160
public class DateUtils { //日期转换为字符串 public static String dateToString(Date date,String pattern){ SimpleDateFormat simpleDateFormat = new SimpleDateFormat(pattern); String string = simpleDateFormat.format(date); return strin
java 日期转换工具类
weixin_49075777的博客
07-03 412
日期转换工具类 直接用. /** * Copyright (c) 2013-Now http://jeesite.com All rights reserved. */ package com.huitai.common.utils; import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.time.FastDateFormat; import java.lang.management.Manageme
Java——日期获取转换(工具类)
专注写bug
09-22 732
Java日期转换工具类
java日期转化工具类
zlzhaoe的博客
06-16 86
package com.rest.ful.utils; import java.text.DateFormat; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; /** * 日期工具...
java日期转换工具类
weixin_38669513的博客
06-20 155
package com.saic.usedcar.weixin;import java.text.SimpleDateFormat;  import java.util.Calendar;  import java.util.Date;    /**  */  public class DateTest2 {      public static void main(String[] args) ...
Java工具集-日期转换工具类
逍遥云恋
06-08 381
代码示例 import org.apache.commons.collections.CollectionUtils; import org.apache.commons.lang3.StringUtils; import java.util.ArrayList; import java.util.Collections; import java.util.List; /** * @program: simple_tools * @description: 日期转换工具类 * @author:
Java时间格式化工具类
"Java时间格式大全，包括了各种时间转换的工具类，适用于Java开发者，提供了获取当前日期和时间的不同格式方法。" 在Java开发中，处理日期和时间是一项常见的任务，Java提供了一系列的类来支持日期和时间的格式化、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值