1.  package com.chinagas.common.utils;
  2.  
  3.  import java.text.ParseException;
  4.  import java.text.SimpleDateFormat;
  5.  import java.util.Calendar;
  6.  import java.util.Date;
  7.  
  8.  public class DateUtils {
  9.  
  10.      public static final String DATE_TIME_PATTERN = "yyyy-MM-dd HH:mm:ss";
  11.      public static final String MINUTE_PATTERN = "yyyy-MM-dd HH:mm";
  12.      public static final String HOUR_PATTERN = "yyyy-MM-dd HH:mm:ss";
  13.      public static final String DATE_PATTERN = "yyyy-MM-dd";
  14.      public static final String MONTH_PATTERN = "yyyy-MM";
  15.      public static final String YEAR_PATTERN = "yyyy";
  16.      public static final String MINUTE_ONLY_PATTERN = "mm";
  17.      public static final String HOUR_ONLY_PATTERN = "HH";
  18.  
  19.      /**
  20.       * 日期相加减天数
  21.       * @param date 如果为Null，则为当前时间
  22.       * @param days 加减天数
  23.       * @param includeTime 是否包括时分秒,true表示包含
  24.       * @return
  25.       * @throws ParseException
  26.       */
  27.      public static Date dateAdd(Date date, int days, boolean includeTime) throws ParseException{
  28.          if(date == null){
  29.              date = new Date();
  30.          }
  31.          if(!includeTime){
  32.              SimpleDateFormat sdf = new SimpleDateFormat(DateUtils.DATE_PATTERN);
  33.              date = sdf.parse(sdf.format(date));
  34.          }
  35.          Calendar cal = Calendar.getInstance();
  36.          cal.setTime(date);
  37.          cal.add(Calendar.DATE, days);
  38.          return cal.getTime();
  39.      }
  40.  
  41.      /**
  42.       * 时间格式化成字符串
  43.       * @param date Date
  44.       * @param pattern StrUtils.DATE_TIME_PATTERN || StrUtils.DATE_PATTERN， 如果为空，则为yyyy-MM-dd
  45.       * @return
  46.       * @throws ParseException
  47.       */
  48.      public static String dateFormat(Date date, String pattern) throws ParseException{
  49.          if(StrUtils.isBlank(pattern)){
  50.              pattern = DateUtils.DATE_PATTERN;
  51.          }
  52.          SimpleDateFormat sdf = new SimpleDateFormat(pattern);
  53.          return sdf.format(date);
  54.      }
  55.  
  56.      /**
  57.       * 字符串解析成时间对象
  58.       * @param dateTimeString String
  59.       * @param pattern StrUtils.DATE_TIME_PATTERN || StrUtils.DATE_PATTERN，如果为空，则为yyyy-MM-dd
  60.       * @return
  61.       * @throws ParseException
  62.       */
  63.      public static Date dateParse(String dateTimeString, String pattern) throws ParseException{
  64.          if(StrUtils.isBlank(pattern)){
  65.              pattern = DateUtils.DATE_PATTERN;
  66.          }
  67.          SimpleDateFormat sdf = new SimpleDateFormat(pattern);
  68.          return sdf.parse(dateTimeString);
  69.      }
  70.  
  71.      /**
  72.       * 将日期时间格式成只有日期的字符串（可以直接使用dateFormat，Pattern为Null进行格式化）
  73.       * @param dateTime Date
  74.       * @return
  75.       * @throws ParseException
  76.       */
  77.      public static String dateTimeToDateString(Date dateTime) throws ParseException{
  78.          String dateTimeString = DateUtils.dateFormat(dateTime, DateUtils.DATE_TIME_PATTERN);
  79.          return dateTimeString.substring(0, 10);
  80.      }
  81.  
  82.      /**
  83.       * 当时、分、秒为00:00:00时，将日期时间格式成只有日期的字符串，
  84.       * 当时、分、秒不为00:00:00时，直接返回
  85.       * @param dateTime Date
  86.       * @return
  87.       * @throws ParseException
  88.       */
  89.      public static String dateTimeToDateStringIfTimeEndZero(Date dateTime) throws ParseException{
  90.          String dateTimeString = DateUtils.dateFormat(dateTime, DateUtils.DATE_TIME_PATTERN);
  91.          if(dateTimeString.endsWith("00:00:00")){
  92.              return dateTimeString.substring(0, 10);
  93.          }else{
  94.              return dateTimeString;
  95.          }
  96.      }
  97.  
  98.      /**
  99.       * 将日期时间格式成日期对象，和dateParse互用
  100.       * @param dateTime Date
  101.       * @return Date
  102.       * @throws ParseException
  103.       */
  104.      public static Date dateTimeToDate(Date dateTime) throws ParseException{
  105.          Calendar cal = Calendar.getInstance();
  106.          cal.setTime(dateTime);
  107.          cal.set(Calendar.HOUR_OF_DAY, 0);
  108.          cal.set(Calendar.MINUTE, 0);
  109.          cal.set(Calendar.SECOND, 0);
  110.          cal.set(Calendar.MILLISECOND, 0);
  111.          return cal.getTime();
  112.      }
  113.  
  114.      /**
  115.       * 时间加减小时
  116.       * @param startDate 要处理的时间，Null则为当前时间
  117.       * @param hours 加减的小时
  118.       * @return Date
  119.       */
  120.      public static Date dateAddHours(Date startDate, int hours) {
  121.          if (startDate == null) {
  122.              startDate = new Date();
  123.          }
  124.          Calendar c = Calendar.getInstance();
  125.          c.setTime(startDate);
  126.          c.set(Calendar.HOUR, c.get(Calendar.HOUR) + hours);
  127.          return c.getTime();
  128.      }
  129.  
  130.      /**
  131.       * 时间加减分钟
  132.       * @param startDate 要处理的时间，Null则为当前时间
  133.       * @param minutes 加减的分钟
  134.       * @return
  135.       */
  136.      public static Date dateAddMinutes(Date startDate, int minutes) {
  137.          if (startDate == null) {
  138.              startDate = new Date();
  139.          }
  140.          Calendar c = Calendar.getInstance();
  141.          c.setTime(startDate);
  142.          c.set(Calendar.MINUTE, c.get(Calendar.MINUTE) + minutes);
  143.          return c.getTime();
  144.      }
  145.  
  146.      /**
  147.       * 时间加减秒数
  148.       * @param startDate 要处理的时间，Null则为当前时间
  149.       * @param minutes 加减的秒数
  150.       * @return
  151.       */
  152.      public static Date dateAddSeconds(Date startDate, int seconds) {
  153.          if (startDate == null) {
  154.              startDate = new Date();
  155.          }
  156.          Calendar c = Calendar.getInstance();
  157.          c.setTime(startDate);
  158.          c.set(Calendar.SECOND, c.get(Calendar.SECOND) + seconds);
  159.          return c.getTime();
  160.      }
  161.  
  162.      /**
  163.       * 时间加减天数
  164.       * @param startDate 要处理的时间，Null则为当前时间
  165.       * @param days 加减的天数
  166.       * @return Date
  167.       */
  168.      public static Date dateAddDays(Date startDate, int days) {
  169.          if (startDate == null) {
  170.              startDate = new Date();
  171.          }
  172.          Calendar c = Calendar.getInstance();
  173.          c.setTime(startDate);
  174.          c.set(Calendar.DATE, c.get(Calendar.DATE) + days);
  175.          return c.getTime();
  176.      }
  177.  
  178.      /**
  179.       * 时间加减月数
  180.       * @param startDate 要处理的时间，Null则为当前时间
  181.       * @param months 加减的月数
  182.       * @return Date
  183.       */
  184.      public static Date dateAddMonths(Date startDate, int months) {
  185.          if (startDate == null) {
  186.              startDate = new Date();
  187.          }
  188.          Calendar c = Calendar.getInstance();
  189.          c.setTime(startDate);
  190.          c.set(Calendar.MONTH, c.get(Calendar.MONTH) + months);
  191.          return c.getTime();
  192.      }
  193.  
  194.      /**
  195.       * 时间加减年数
  196.       * @param startDate 要处理的时间，Null则为当前时间
  197.       * @param years 加减的年数
  198.       * @return Date
  199.       */
  200.      public static Date dateAddYears(Date startDate, int years) {
  201.          if (startDate == null) {
  202.              startDate = new Date();
  203.          }
  204.          Calendar c = Calendar.getInstance();
  205.          c.setTime(startDate);
  206.          c.set(Calendar.YEAR, c.get(Calendar.YEAR) + years);
  207.          return c.getTime();
  208.      }  
  209.  
  210.      /**
  211.       * 时间比较（如果myDate>compareDate返回1，<返回-1，相等返回0）
  212.       * @param myDate 时间
  213.       * @param compareDate 要比较的时间
  214.       * @return int
  215.       */
  216.      public static int dateCompare(Date myDate, Date compareDate) {
  217.          Calendar myCal = Calendar.getInstance();
  218.          Calendar compareCal = Calendar.getInstance();
  219.          myCal.setTime(myDate);
  220.          compareCal.setTime(compareDate);
  221.          return myCal.compareTo(compareCal);
  222.      }
  223.  
  224.      /**
  225.       * 获取两个时间中最小的一个时间
  226.       * @param date
  227.       * @param compareDate
  228.       * @return
  229.       */
  230.      public static Date dateMin(Date date, Date compareDate) {
  231.          if(date == null){
  232.              return compareDate;
  233.          }
  234.          if(compareDate == null){
  235.              return date;
  236.          }
  237.          if(1 == dateCompare(date, compareDate)){
  238.              return compareDate;
  239.          }else if(-1 == dateCompare(date, compareDate)){
  240.              return date;
  241.          }
  242.          return date;
  243.      }
  244.  
  245.      /**
  246.       * 获取两个时间中最大的一个时间
  247.       * @param date
  248.       * @param compareDate
  249.       * @return
  250.       */
  251.      public static Date dateMax(Date date, Date compareDate) {
  252.          if(date == null){
  253.              return compareDate;
  254.          }
  255.          if(compareDate == null){
  256.              return date;
  257.          }
  258.          if(1 == dateCompare(date, compareDate)){
  259.              return date;
  260.          }else if(-1 == dateCompare(date, compareDate)){
  261.              return compareDate;
  262.          }
  263.          return date;
  264.      }
  265.  
  266.      /**
  267.       * 获取两个日期（不含时分秒）相差的天数，不包含今天
  268.       * @param startDate
  269.       * @param endDate
  270.       * @return
  271.       * @throws ParseException
  272.       */
  273.      public static int dateBetween(Date startDate, Date endDate) throws ParseException {
  274.          Date dateStart = dateParse(dateFormat(startDate, DATE_PATTERN), DATE_PATTERN);
  275.          Date dateEnd = dateParse(dateFormat(endDate, DATE_PATTERN), DATE_PATTERN);
  276.          return (int) ((dateEnd.getTime() - dateStart.getTime())/1000/60/60/24);
  277.      }
  278.  
  279.      /**
  280.       * 获取两个日期（不含时分秒）相差的天数，包含今天
  281.       * @param startDate
  282.       * @param endDate
  283.       * @return
  284.       * @throws ParseException
  285.       */
  286.      public static int dateBetweenIncludeToday(Date startDate, Date endDate) throws ParseException {
  287.          return dateBetween(startDate, endDate) + 1;
  288.      }
  289.  
  290.      /**
  291.       * 获取日期时间的年份，如2017-02-13，返回2017
  292.       * @param date
  293.       * @return
  294.       */
  295.      public static int getYear(Date date) {
  296.          Calendar cal = Calendar.getInstance();
  297.          cal.setTime(date);
  298.          return cal.get(Calendar.YEAR);
  299.      }
  300.  
  301.      /**
  302.       * 获取日期时间的月份，如2017年2月13日，返回2
  303.       * @param date
  304.       * @return
  305.       */
  306.      public static int getMonth(Date date) {
  307.          Calendar cal = Calendar.getInstance();
  308.          cal.setTime(date);
  309.          return cal.get(Calendar.MONTH) + 1;
  310.      }
  311.  
  312.      /**
  313.       * 获取日期时间的第几天（即返回日期的dd），如2017-02-13，返回13
  314.       * @param date
  315.       * @return
  316.       */
  317.      public static int getDate(Date date) {
  318.          Calendar cal = Calendar.getInstance();
  319.          cal.setTime(date);
  320.          return cal.get(Calendar.DATE);
  321.      }
  322.  
  323.      /**
  324.       * 获取日期时间当月的总天数，如2017-02-13，返回28
  325.       * @param date
  326.       * @return
  327.       */
  328.      public static int getDaysOfMonth(Date date) {
  329.          Calendar cal = Calendar.getInstance();
  330.          cal.setTime(date);
  331.          return cal.getActualMaximum(Calendar.DATE);
  332.      }
  333.  
  334.      /**
  335.       * 获取日期时间当年的总天数，如2017-02-13，返回2017年的总天数
  336.       * @param date
  337.       * @return
  338.       */
  339.      public static int getDaysOfYear(Date date) {
  340.          Calendar cal = Calendar.getInstance();
  341.          cal.setTime(date);
  342.          return cal.getActualMaximum(Calendar.DAY_OF_YEAR);
  343.      }
  344.  
  345.      /**
  346.       * 根据时间获取当月最大的日期
  347.       * <li>2017-02-13，返回2017-02-28</li>
  348.       * <li>2016-02-13，返回2016-02-29</li>
  349.       * <li>2016-01-11，返回2016-01-31</li>
  350.       * @param date Date
  351.       * @return
  352.       * @throws Exception
  353.       */
  354.      public static Date maxDateOfMonth(Date date) throws Exception {
  355.          Calendar cal = Calendar.getInstance();
  356.          cal.setTime(date);
  357.          int value = cal.getActualMaximum(Calendar.DATE);
  358.          return dateParse(dateFormat(date, MONTH_PATTERN) + "-" + value, null);
  359.      }
  360.  
  361.      /**
  362.       * 根据时间获取当月最小的日期，也就是返回当月的1号日期对象
  363.       * @param date Date
  364.       * @return
  365.       * @throws Exception
  366.       */
  367.      public static Date minDateOfMonth(Date date) throws Exception {
  368.          Calendar cal = Calendar.getInstance();
  369.          cal.setTime(date);
  370.          int value = cal.getActualMinimum(Calendar.DATE);
  371.          return dateParse(dateFormat(date, MONTH_PATTERN) + "-" + value, null);
  372.      }
  373.  
  374.      public static void main(String[] args) throws Exception {
  375.          /*System.out.println(dateTimeToDate(new Date()));
  376.          System.out.println(dateParse("2017-02-04 14:58:20", null));
  377.          System.out.println(dateTimeToDateStringIfTimeEndZero(new Date()));
  378.          System.out.println(dateTimeToDateStringIfTimeEndZero(dateTimeToDate(new Date())));*/
  379.          //System.out.println(dateBetween(dateParse("2017-01-30", null), dateParse("2017-02-01", null)));
  380.          //System.out.println(dateBetweenIncludeToday(dateParse("2017-01-30", null), dateParse("2017-02-01", null)));
  381.          System.out.println(getDate(dateParse("2017-01-17", null)));
  382.          /*
  383.          System.out.println(getDaysOfMonth(dateParse("2017-02-01", null)));
  384.          System.out.println(getDaysOfYear(dateParse("2017-01-30", null)));*/
  385.          //System.out.println(dateFormat(dateAddMonths(dateParse("2017-02-07", StrUtils.MONTH_PATTERN), -12), StrUtils.MONTH_PATTERN));
  386.          /*System.out.println(dateFormat(maxDateOfMonth(dateParse("2016-02", "yyyy-MM")), null));
  387.          System.out.println(dateFormat(minDateOfMonth(dateParse("2016-03-31", null)), null));*/
  388.      }
  389.  
  390.  }
  391.  
  392. 原文链接https://www.cnblogs.com/fanshuyao/p/6365099.html

Java时间类（转）的更多相关文章

  1. java时间类简单总结

    java时间类(Data类) 1.Data类(没有考虑到国际化,好多方法已过时java.util.Data包中) 父类(是类不是接口含有直接子类3个):  日期格式为:年月日时分秒(不包含毫秒部分) ...

  2. Java时间类从此变得清晰明了

    Java时间类 Java时间类分为Date 日期类和Calendar 日历类,相信很多小伙伴在初学时会对这个两个类的用法.区别以及有什么联系会感到疑惑,似乎懂了,但又不能具体说清,今天再带你来清晰的再 ...

  3. java时间类Date、Calendar及用法

    对于时间类,这篇主要说明各种现实情况下如何取值,怎么定向取值,得到自己想要的时间参数.在java中时间类主要有Date.Calendar,暂时只介绍 java.util.*下的时间类,对于java.s ...

  4. Java时间类总结

    java.util.Date 包含有年月日时分秒,精确到毫秒级别. 官方解释: // The class Date represents a specific instant in time, wit ...

  5. Java 时间类

    1.System 类 2.Date 类 3.SimpleDateFormate 类 4.Calendar 类 1.System 类 得到当前的时间值.System 类不能被实例化,需要通过它的静态方法 ...

  6. Java 时间类-Calendar、Date、LocalDate/LocalTime

    1.Date 类 java.util.Date是一个"万能接口",它包含日期.时间,还有毫秒数,如果你只想用java.util.Date存储日期,或者只存储时间,那么,只有你知道哪 ...

  7. Java 时间类 Date 和 Calendar

    在项目中获取一个yyyy-MM-dd HH:mm:ss格式的时间字符串 package org.htsg.kits; import java.text.SimpleDateFormat; import ...

  8. Java中常见时间类的使用

    模拟场景针对于常用的操作API,比如流操作(字符流.字节流),时间操作等,仅仅了解概念性的定义终究是无法了解该类的用途和使用方式:这种情况在使用的时候便一脸茫然,脑海中映射不到对应的知识点.本篇博客将 ...

  9. Java Calendar类使用总结

    平时在浏览一些网站时,有些网站会显示出当前时间,如现在是xx年xx月xx日 xx时xx分xx秒,在实际的开发过程中,也会涉及到日期和时间的计算,Java中提供了一个专门的类Calendar来处理日期与 ...

随机推荐

  1. error C2065: 'IDD_DIALOG1' : undeclared identifier

    添加资源文件 #include "resource.h"

  2. asp.net DataReader DataTable 使用反射给给实体赋值

    asp.net 使用反射给给实体赋值 实体类继承此基类 using System.Reflection; using System.Data.SqlClient; using System.Data; ...

  3. ActiveMQ实战之 Queue点对点消息

    前言:ActiveMQ消息模式点对点编码 运行:先运行消费者在开启消息生产者即可接收到消息 消息生产者 /** * @摘要 测试发送单条数据的类 */ public class ZMQOneSendT ...

  4. Struts2--HelloWord

    Struts2官网 官网指南 官网下载Struts2.5-min-lib.zip解压把lib目录下jar包拷贝到web项目lib目录下 配置web.xml文件 <filter> <f ...

  5. Ubuntu Server 命令行下的默认语言改为英语en_US.UTF-8

    源文链接:http://tonychiu.blog.51cto.com/656605/393131 如果Ubuntu Server在安装过程中,选择的是中文(很多新手都会在安装时选择中文,便于上手), ...

  6. XCode中常用错误解决

    No such file or directory     解决方法(可以依次尝试,总有一种能最终解决问题):          方法1.退出Xcode,然后从finder里面进入~/Library/ ...

  7. stm32的gpio函数介绍

    一.gpio_init函数 void GPIO_Init(GPIO_TypeDef* GPIOx, GPIO_InitTypeDef* GPIO_InitStruct) 调用时的格式一般是例如 RCC ...

  8. (spfa) Highway Project (zoj 3946 )

    http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=5718   Highway Project Time Limit: 2 Seco ...

  9. noip第28课作业

    分段数列 [问题描述] 对于给定的一个长度为N的正整数数列A[i],现要将其分成连续的若干段,并且每段和不超过M(可以等于M),问最少能将其分成多少段使得满足要求. 输入格式: 输入第1行包含两个正整 ...

  10. W-TinyLFU——设计一个现代的缓存

    缓存设计是个基础架构领域里的重要话题,本号之前也有谈论过相关话题,点击原文可以看之前的介绍. 近日,HighScalability网站刊登了一篇文章,由前Google工程师发明的W-TinyLFU—— ...