Java 进行时间处理的步骤

一、calendar

（1）、calender介绍

calendar的中文翻译是日历，实际上，在历史上有着许多种计时的方法。所以为了计时的统一，必需指定一个日历的选择。那现在最为普及和通用的日历就是"gregorian calendar"。也就是我们在讲述年份时常用"公元**年"。calendar 在 java 中是一个抽象类(abstract class)，gregoriancalendar 是它的一个具体实现。calendar.getinstance()中所获得的实例就是一个"greogriancalendar"对象。

（2）、简单的日期使用

calendar cal = calendar.getinstance();
system.out.println(cal.get(calendar.date));//-----------------------今天是几号
system.out.println(cal.get(calendar.day_of_month));//---------------今天是一月的第几天
system.out.println(cal.get(calendar.day_of_week));//----------------从星期天开始计算，如果今天星期二，那么返回3
system.out.println( cal.get(calendar.day_of_year));//----------------今天是一年的第几天
system.out.println( cal.get(calendar.hour));//-----------------------现在是几点     12小时制
system.out.println( cal.get(calendar.hour_of_day));//----------------现在是几点     24小时制，一般使用这个属性赋值
system.out.println(cal.get(calendar.millisecond));//----------------现在的毫秒
system.out.println( cal.get(calendar.minute));//---------------------现在是几分
system.out.println( cal.get(calendar.second));//---------------------现在是几秒
system.out.println(cal.get(calendar.week_of_month));//--------------现在是一个月中的第几周
system.out.println(cal.get(calendar.week_of_year));//----------------现在是一个年中的第几周
system.out.println(cal.get(calendar.month));//-----------------------月份获取需要 +1，那么，赋值时需要 -1

system.out.println(cal.get(calendar.month)-1);     //即可获得上个月的月份

（3）、与date之间的转换

calendar calendar = calendar.getinstance();
// 从一个calendar 对象中获取 date 对象

date date = calendar.gettime();

// 将 date 对象反应到一个 calendar 对象中，
// 先获得一个实例，然后设置 date 对象
calendar.settime(date);

月份的起始值为０而不是１，所以要设置八月时，我们用７而不是8。
calendar.set(calendar.month, 7);

计算2000-01-01是星期几

calendar.set(2000,1,1)

calendar.get(calendar.day_of_week )

当然calender是最早的时间处理，是jdk1.6的东西难免比较过时

二、apache下的dateutils

（1）、引入包

<dependency>
       <groupid>org.apache.commons</groupid>
       <artifactid>commons-lang3</artifactid>
       <version>3.9</version>
</dependency>

（2）、没什么可说的上翻译就行

    /**
     * 以秒为标准时间的毫秒数
     */
    public static final long millis_per_second = 1000
    /**
     *以分钟为标准时间的毫秒数
     */
    public static final long millis_per_minute = 60 * millis_per_second
    /**
     *以小时为标准时间的毫秒数
     */
    public static final long millis_per_hour = 60 * millis_per_minute
    /**
     * 以天为标准时间的毫秒数
     */
    public static final long millis_per_day = 24 * millis_per_hour
    /**
     * 这个类型是半个月， 所以这可以代表日期是上还是下半个月 。
     */
    public static final int semi_month = 1001
    /**
     * 周范围， 从星期日开始 。
     */
    public static final int range_week_sunday = 1
    /**
     * 周范围，从星期一开始 。
     */
    public static final int range_week_monday = 2
    /**
     * 周范围，从关注的那天开始。
     */
    public static final int range_week_relative = 3
    /**
     * 周范围，以关注的天为中心。
     */
    public static final int range_week_center = 4
     /**
     * 月范围，从星期日开始 。
     */
    public static final int range_month_sunday = 5
    /**
     * 月范围，从星期一开始 。
     */
    public static final int range_month_monday = 6
     /**
     * 不应在标准编成构造获取实列， 而应该直接使用类中的静态方法，如：dateutils.parsedate(str) 。
     * 此构造函数意在允许需要一个javabeen实列的工具中使用 。  
     */
    public dateutils()
    /**
     * 判断两个日期时间是否是同一天 。
     *
     * @param date1  第一个日期，不可修改，非null
     * @param date2  第二个日期，不可修改，非null
     */
    public static boolean issameday(final date date1, final date date2)
    /**
     * 判断两个日历时间是否是同一天 。   
     *
     * @param cal1  第一个日历，不可修改，非null
     * @param cal2  第二个日历，不可修改，非null
     */
    public static boolean issameday(final calendar cal1, final calendar cal2)
    /**
     * 判断两个日期是否相同
     * 这种方法比较两个对象的毫秒时间 
     *
     * @param date1  第一个日期，不可修改，非null
     * @param date2  第二个日期，不可修改，非null
     */
    public static boolean issameinstant(final date date1, final date date2)
    /**
     * 判断两个日历是否相同
     * 这种方法比较两个对象的毫秒时间 
     *
     * @param cal1  第一个日历，不可修改，非null
     * @param cal2  第二个日历，不可修改，非null
     */
    public static boolean issameinstant(final calendar cal1, final calendar cal2)
    /**
     * 判断两个日历本地时间是否相同
     * 除了比较数值外两个日历对象的类型还要相同
     *
     * @param cal1  第一个日历，不可修改，非null
     * @param cal2  第二个日历，不可修改，非null
     */
    public static boolean issamelocaltime(final calendar cal1, final calendar cal2)
    /**
     * 尝试用parsepatterns中各种不同的日期格式解析代表时间的字符串str 。
     * 
     * 解析时会逐个使用parsepatterns中的格式，如果都没有匹配上， 则抛出异常parseexception 。
     * 
     * @param str  被解析的时间字符串，非null
     * @param parsepatterns  用于解析str的时间格式，有一个或几个，非null
     */
    public static date parsedate(final string str, final string... parsepatterns) throws parseexception
    /**
     * 尝试用parsepatterns中各种不同的日期格式解析代表时间的字符串str 。
     * 解析时会使用给定的日期格式符locale 。
     * 
     * 解析时会逐个使用parsepatterns中的格式，如果都没有匹配上， 则抛出异常parseexception 。
     * 
     * @param str  被解析的时间字符串，非null
     * @param locale 使用locale中的日期格式符，如果为null，则使用系统默认的locale
     * @param parsepatterns  用于解析str的时间格式，有一个或几个，非null
     */
    public static date parsedate(final string str, final locale locale, final string... parsepatterns) throws parseexception
    /**
     * 尝试用parsepatterns中各种不同的日期格式解析代表时间的字符串str 。
     *
     * 解析时会逐个使用parsepatterns中的格式，如果都没有匹配上， 则抛出异常parseexception 。
     * 解析器解析严格不允许的日期， 如："february 942, 1996" 。
     * 
     * @param str  被解析的时间字符串，非null
     * @param parsepatterns  用于解析str的时间格式，有一个或几个，非null
     */
    public static date parsedatestrictly(final string str, final string... parsepatterns) throws parseexception
    /**
     * 尝试用parsepatterns中各种不同的日期格式解析代表时间的字符串str 。
     * 解析时会使用给定的日期格式符locale 。
     *
     * 解析时会逐个使用parsepatterns中的格式，如果都没有匹配上， 则抛出异常parseexception 。
     * 解析器解析严格不允许的日期， 如："february 942, 1996" 。
     * 
     * @param str  被解析的时间字符串，非null
     * @param locale 使用locale中的日期格式符，如果为null，则使用系统默认的locale
     * @param parsepatterns  用于解析str的时间格式，有一个或几个，非null
     */
    public static date parsedatestrictly(final string str, final locale locale, final string... parsepatterns) throws parseexception
    /**
     * 在日期date上增加amount年 。
     *
     * @param date  处理的日期，非null
     * @param amount  要加的年数，可能为负数
     */
    public static date addyears(final date date, final int amount)
    /**
     * 在日期date上增加amount月 。
     *
     * @param date  处理的日期，非null
     * @param amount  要加的月数，可能为负数
     */
    public static date addmonths(final date date, final int amount)
    /**
     * 在日期date上增加amount周 。
     *
     * @param date  处理的日期，非null
     * @param amount  要加的周数，可能为负数
     */
    public static date addweeks(final date date, final int amount)
    /**
     * 在日期date上增加amount天 。
     *
     * @param date  处理的日期，非null
     * @param amount  要加的天数，可能为负数
     */
    public static date adddays(final date date, final int amount)
    /**
     * 在日期date上增加amount小时 。
     *
     * @param date  处理的日期，非null
     * @param amount  要加的小时数，可能为负数
     */
    public static date addhours(final date date, final int amount)
    /**
     * 在日期date上增加amount分钟 。
     *
     * @param date  处理的日期，非null
     * @param amount  要加的分钟数，可能为负数
     */
    public static date addminutes(final date date, final int amount)
    /**
     * 在日期date上增加amount秒 。
     *
     * @param date  处理的日期，非null
     * @param amount  要加的秒数，可能为负数
     */
    public static date addseconds(final date date, final int amount)
    /**
     * 在日期date上增加amount 毫秒 。
     *
     * @param date  处理的日期，非null
     * @param amount  要加的毫秒数，可能为负数
     */
    public static date addmilliseconds(final date date, final int amount)
     /**
     * 给日期data设置一个新的年份 。
     *
     * @param date 处理的日期，非null
     * @param amount 要设置的年份
     */
    public static date setyears(final date date, final int amount)
     /**
     * 给日期data设置一个新的月份 。
     *
     * @param date 处理的日期，非null
     * @param amount 要设置的月份
     */
    public static date setmonths(final date date, final int amount)
    /**
     * 给日期data设置一个新的天 。
     *
     * @param date 处理的日期，非null
     * @param amount 要设置的天
     */
    public static date setdays(final date date, final int amount)
    /**
     * 给日期data设置一个新的小时 。
     *
     * @param date 处理的日期，非null
     * @param amount 要设置的小时
     */
    public static date sethours(final date date, final int amount)
     /**
     * 给日期data设置一个新的分钟 。
     *
     * @param date 处理的日期，非null
     * @param amount 要设置的分钟
     */
    public static date setminutes(final date date, final int amount)
    /**
     * 给日期data设置一个新的秒 。
     *
     * @param date 处理的日期，非null
     * @param amount 要设置的秒
     */
    public static date setseconds(final date date, final int amount)
    /**
     * 给日期data设置一个新的毫秒 。
     *
     * @param date 处理的日期，非null
     * @param amount 要设置的毫秒
     */
    public static date setmilliseconds(final date date, final int amount)
    /**
     * 将一个日期放到日历中 。
     */
    public static calendar tocalendar(final date date)
    /**
     * 根据阈值field四舍五入日历date 。
     *
     * 例如， 如果你的时间是 28 mar 2002 13:45:01.231，
     * 如果field为hour，它将返回 28 mar 2002 14:00:00.000；
     * 如果field为month，它将返回 1 april 2002 0:00:00.000 。
     * 
     * @param date  处理的日期，非null
     * @param field  阈值
     */
    public static date round(final date date, final int field)
    /**
     * 根据阈值field四舍五入日历date 。
     *
     * 例如， 如果你的时间是 28 mar 2002 13:45:01.231，
     * 如果field为hour，它将返回 28 mar 2002 14:00:00.000；
     * 如果field为month，它将返回 1 april 2002 0:00:00.000 。
     * 
     * @param date  处理的日期，非null
     * @param field  阈值  
     */
    public static calendar round(final calendar date, final int field)
    /**
     * 根据阈值field四舍五入日历date 。
     *
     * 例如， 如果你的时间是 28 mar 2002 13:45:01.231，
     * 如果field为hour，它将返回 28 mar 2002 14:00:00.000；
     * 如果field为month，它将返回 1 april 2002 0:00:00.000 。
     * 
     * @param date  处理的日期，非null
     * @param field  阈值 
     */
    public static date round(final object date, final int field)
    /**
     * 根据阈值field截取日期date 。
     *
     * 例如， 如果你的时间是 28 mar 2002 13:45:01.231，
     * 如果field为hour，它将返回 28 mar 2002 13:00:00.000；
     * 如果field为month，它将返回 1 mar 2002 0:00:00.000 。
     * 
     * @param date  处理的日期，非null
     * @param field  阈值 
     */
    public static date truncate(final date date, final int field)
     /**
     * 根据阈值field截取日历date 。
     *
     * 例如， 如果你的时间是 28 mar 2002 13:45:01.231，
     * 如果field为hour，它将返回 28 mar 2002 13:00:00.000；
     * 如果field为month，它将返回 1 mar 2002 0:00:00.000 。
     * 
     * @param date  处理的日期，非null
     * @param field  阈值
     */
    public static calendar truncate(final calendar date, final int field)
    /**
     * 根据阈值field截取日期date 。
     *
     * 例如， 如果你的时间是 28 mar 2002 13:45:01.231，
     * 如果field为hour，它将返回 28 mar 2002 13:00:00.000；
     * 如果field为month，它将返回 1 mar 2002 0:00:00.000 。
     * 
     * @param date  处理的日期，非null
     * @param field  阈值
     */
    public static date truncate(final object date, final int field)
    /**
     * 根据阈值field向上舍入日期date 。
     *
     * 例如， 如果你的时间是 28 mar 2002 13:45:01.231，
     * 如果field为hour，它将返回 28 mar 2002 14:00:00.000；
     * 如果field为month，它将返回 1 apr 2002 0:00:00.000 。
     * 
     * @param date  处理的日期，非null
     * @param field  阈值
     */
    public static date ceiling(final date date, final int field)
    /**
     * 根据阈值field向上舍入日期date 。
     *
     * 例如， 如果你的时间是 28 mar 2002 13:45:01.231，
     * 如果field为hour，它将返回 28 mar 2002 14:00:00.000；
     * 如果field为month，它将返回 1 apr 2002 0:00:00.000 。
     * 
     * @param date  处理的日期，非null
     * @param field  阈值
     */
    public static calendar ceiling(final calendar date, final int field)
    /**
     * 根据阈值field向上舍入日期date 。
     *
     * 例如， 如果你的时间是 28 mar 2002 13:45:01.231，
     * 如果field为hour，它将返回 28 mar 2002 14:00:00.000；
     * 如果field为month，它将返回 1 apr 2002 0:00:00.000 。
     * 
     * @param date  处理的日期，非null
     * @param field  阈值
     */
    public static date ceiling(final object date, final int field)
    /**
     * 根据指定的时间focus和范围类型rangestyle构建一个时间范围迭代器 。
     *
     * 如传入的时间是thursday, july 4, 2002，范围类型是range_month_sunday，
     * 则返回迭代器的范围是从sunday, june 30, 2002 到 saturday, august 3, 2002
     *
     * @param focus  指定的时间
     * @param rangestyle  范围类型，值必须是如下之一：
     * dateutils.range_month_sunday， 
     * dateutils.range_month_monday，
     * dateutils.range_week_sunday，
     * dateutils.range_week_monday，
     * dateutils.range_week_relative，
     * dateutils.range_week_center
     */
    public static iterator<calendar> iterator(final date focus, final int rangestyle)
    /**
     * 根据指定的时间focus和范围类型rangestyle构建一个时间范围迭代器 。
     *
     * 如传入的时间是thursday, july 4, 2002，范围类型是range_month_sunday，
     * 则返回迭代器的范围是从sunday, june 30, 2002 到 saturday, august 3, 2002
     *
     * @param focus  指定的时间
     * @param rangestyle  范围类型，值必须是如下之一：
     * dateutils.range_month_sunday， 
     * dateutils.range_month_monday，
     * dateutils.range_week_sunday，
     * dateutils.range_week_monday，
     * dateutils.range_week_relative，
     * dateutils.range_week_center
     */
    public static iterator<calendar> iterator(final calendar focus, final int rangestyle)
    /**
     * 根据指定的时间focus和范围类型rangestyle构建一个时间范围迭代器 。
     *
     * 如传入的时间是thursday, july 4, 2002，范围类型是range_month_sunday，
     * 则返回迭代器的范围是从sunday, june 30, 2002 到 saturday, august 3, 2002
     *
     * @param focus  指定的时间
     * @param rangestyle  范围类型，值必须是iterator(calendar, int)方法注释中列出的
     */
    public static iterator<?> iterator(final object focus, final int rangestyle)
 
/**
     * 返回指定分段内的毫秒数 。 所有大于分段的datefields将被忽略 。
     *
     * 请求任何日期毫秒，将返回当前秒的毫秒数 (返回一个数字在0和999之间) 。
     * 有效的分段值是： calendar.year、calendar.month、calendar.day_of_year、
     * calendar.date、calendar.hour_of_day、calendar.minute、
     * calendar.second 和 calendar.millisecond
     * 分段值小于或等于millisecond，将返回0 。
     * 
     *  january 1, 2008 7:15:10.538 with calendar.second as fragment will return 538
     *  january 6, 2008 7:15:10.538 with calendar.second as fragment will return 538
     *  january 6, 2008 7:15:10.538 with calendar.minute as fragment will return 10538
     *  january 16, 2008 7:15:10.538 with calendar.millisecond as fragment will return 0
     *   (a millisecond cannot be split in milliseconds)
     * 
     * @param calendar 获取值得日历对象，非null
     * @param fragment 分段值
     */
  public static long getfragmentinmilliseconds(final calendar calendar, final int fragment)
    /**
     * 返回指定分段内的秒数 。 所有大于分段的datefields将被忽略 。
     *
     * 请求任何日期秒，将返回当前的分钟的秒数 (返回一个数字在0和59之间) 。
     * 有效的分段值是： calendar.year、calendar.month、calendar.day_of_year、
     * calendar.date、calendar.hour_of_day、calendar.minute、
     * calendar.second 和 calendar.millisecond
     * 分段值小于或等于second，将返回0 。
     * 
     *  january 1, 2008 7:15:10.538 with calendar.minute as fragment will return 10
     *  january 6, 2008 7:15:10.538 with calendar.minute as fragment will return 10
     *  january 6, 2008 7:15:10.538 with calendar.day_of_year as fragment will return 26110
     *   (7*3600 + 15*60 + 10)</li>
     *  january 16, 2008 7:15:10.538 with calendar.millisecond as fragment will return 0
     * 
     * @param calendar 获取值得日历对象，非null
     * @param fragment 分段值
     */
    public static long getfragmentinseconds(final calendar calendar, final int fragment)
    /**
     * 返回指定分段内的分钟数 。 所有大于分段的datefields将被忽略 。
     *
     * 请求任何日期分钟，将返回当前的小时的分钟数 (返回一个数字在0和59之间)
     * 有效的分段值是： calendar.year、calendar.month、calendar.day_of_year、
     * calendar.date、calendar.hour_of_day、calendar.minute、
     * calendar.second 和 calendar.millisecond
     * 分段值小于或等于minute，将返回0 。
     * 
     *  january 1, 2008 7:15:10.538 with calendar.hour_of_day as fragment will return 15
     *  january 6, 2008 7:15:10.538 with calendar.hour_of_day as fragment will return 15
     *  january 1, 2008 7:15:10.538 with calendar.month as fragment will return 15
     *  january 6, 2008 7:15:10.538 with calendar.month as fragment will return 435 (7*60 + 15)
     *  january 16, 2008 7:15:10.538 with calendar.millisecond as fragment will return 0
     * 
     * @param calendar 获取值得日历对象，非null
     * @param fragment 分段值
     */
    public static long getfragmentinminutes(final calendar calendar, final int fragment)
    /**
     * 返回指定分段内的小时数 。 所有大于分段的datefields将被忽略 。
     *
     * 请求任何日期小时，将返回当前的天的小时数 (返回一个数字在0和23之间) 。
     * 有效的分段值是： calendar.year、calendar.month、calendar.day_of_year、
     * calendar.date、calendar.hour_of_day、calendar.minute、
     * calendar.second 和 calendar.millisecond
     * 分段值小于或等于hour_of_day，将返回0 。
     *  
     *  january 1, 2008 7:15:10.538 with calendar.day_of_year as fragment will return 7
     *  january 6, 2008 7:15:10.538 with calendar.day_of_year as fragment will return 7
     *  january 1, 2008 7:15:10.538 with calendar.month as fragment will return 7
     *  january 6, 2008 7:15:10.538 with calendar.month as fragment will return 127 (5*24 + 7)
     *  january 16, 2008 7:15:10.538 with calendar.millisecond as fragment will return 0
     *  
     * @param calendar 获取值得日历对象，非null
     * @param fragment 分段值
     */
    public static long getfragmentinhours(final calendar calendar, final int fragment)
    /**
     * 返回指定分段内的天数 。 所有大于分段的datefields将被忽略 。
     *
     * 请求任何日期天数，将返回当前的月的天数 (返回一个数字在1和31之间) 。
     * 有效的分段值是： calendar.year、calendar.month、calendar.day_of_year、
     * calendar.date、calendar.hour_of_day、calendar.minute、
     * calendar.second 和 calendar.millisecond
     * 分段值小于或等于date，将返回0 。
     * 
     *  january 28, 2008 with calendar.month as fragment will return 28
     *  february 28, 2008 with calendar.month as fragment will return 28
     *  january 28, 2008 with calendar.year as fragment will return 28
     *  february 28, 2008 with calendar.year as fragment will return 59
     *  january 28, 2008 with calendar.millisecond as fragment will return 0
     * 
     * @param calendar 获取值得日历对象，非null
     * @param fragment 分段值
     */
    public static long getfragmentindays(final calendar calendar, final int fragment)
    /**
     * 截取比较两个日历对象的field处的值是否相同 。
     * 
     * @param cal1 第一个日历对象，非null
     * @param cal2 第二个日历对象，非null
     * @param field calendar中的阈值
     */
    public static boolean truncatedequals(final calendar cal1, final calendar cal2, final int field)
    /**
     * 截取比较两个日期对象的field处的值是否相同 。
     * 
     * @param date1 第一个日期对象，非null
     * @param date2 第二个日期对象，非null
     * @param field calendar中的阈值
     */
    public static boolean truncatedequals(final date date1, final date date2, final int field)
    /**
     * 截取比较两个日历对象的field处的值 。
     * 如果第一个日历小于、等于、大于第二个，则对应返回负整数、0、正整数
     * 
     * @param cal1 第一个日历对象，非null
     * @param cal2 第二个日历对象，非null
     * @param field calendar中的阈值
     */
    public static int truncatedcompareto(final calendar cal1, final calendar cal2, final int field)
    /**
     * 截取比较断两个日期对象的field处的值 。
     * 如果第一个日期小于、等于、大于第二个，则对应返回负整数、0、正整数
     * 
     * @param date1 第一个日期对象，非null
     * @param date2 第二个日期对象，非null
     * @param field calendar中的阈值
     */
    public static int truncatedcompareto(final date date1, final date date2, final int field)
	
	
	//简单举例
	system.out.println(dateutils.adddays(new date(), 1));//-----------------当前日期。天数加1如果想建议填负数即可
    system.out.println(dateutils.addhours(new date(), 0));//----------------当前日期
    date date = dateutils.adddays(new date(), 1);

dateutils返回的就是date不需要转换，当然也是很早的东西了，只是诞生在calender基础之上而已

三、jdk1.8新增的日期api localdate | localtime | localdatetime

新的日期api都是不可变的，更使用于多线程的使用环境中(从默认时区的系统时钟获取当前的日期时间。不用考虑时区差)
优点：

1、之前使用的java.util.date月份从0开始，我们一般会+1使用，很不方便，java.time.localdate月份和星期都改成了enum

2、java.util.date和simpledateformat都不是线程安全的，而localdate和localtime和最基本的string一样，是不变类型，不但线程安全，而且不能修改。

3、java.util.date是一个“万能接口”，它包含日期、时间，还有毫秒数，更加明确需求取舍

4、新接口更好用的原因是考虑到了日期时间的操作，经常发生往前推或往后推几天的情况。用java.util.date配合calendar要写好多代码，而且一般的开发人员还不一定能写对。

（1）、localdatetime（年月日时分秒）

localdatetime date = localdatetime.now();
        //2021-03-26t10:24:14.009784900
        system.out.println(date);

		//获取年月日时分秒操作
        system.out.println(date.getyear());
        system.out.println(date.getmonthvalue());
        system.out.println(date.getdayofmonth());
        system.out.println(date.gethour());
        system.out.println(date.getminute());
        system.out.println(date.getsecond());
        system.out.println(date.getnano());
		
		//当然你也可以获取最近任意的一段时间
		 system.out.println(date.getsecond()+1);           ||        system.out.println(date.getsecond()-1);
		

        // 手动创建一个localdatetime实例
        localdatetime date2 = localdatetime.of(2017, 12, 17, 9, 31, 31, 31);
        system.out.println(date2);
        // 进行加操作，得到新的日期实例
        localdatetime date3 = date2.plusdays(12);
        system.out.println(date3);
        // 进行减操作，得到新的日期实例
        localdatetime date4 = date3.minusyears(2);
        system.out.println(date4);
		
		isafter()判断一个日期是否在指定日期之后  返回boolean 类型
		system.out.println(localdatetime.isbefore(localdatetime.now()));//---------返回false
		
		isbefore()判断一个日期是否在指定日期之前   返回boolean 类型
		system.out.println(localdatetime.isafter(localdatetime.now()));//---------返回false
	
		isleapyear()判断是否是闰年(这个是localdate类中的方法)  返回boolean类型
		system.out.println(localdatetime.isequal(localdatetime.now()));//---------返回true

（2）、localdatetime与date之间的转换

date to localdatetime

date todaydate = new date();

localdatetime ldt = instant.ofepochmilli( todaydate.gettime() )
        .atzone( zoneid.systemdefault() )
        .tolocaldatetime();

system.out.println(ldt);

localdatetime to date

localdatetime localdatetime = localdatetime.now();

date date = date.from( localdatetime.atzone( zoneid.systemdefault()).toinstant());

system.out.println(date);

当然还有很多好玩的东西，localdate(年月日) localtime(时分秒)和localdatetime(年月日时分秒)都大差不差，所以讲一个即可

四、hutool（java工具类库）

一个比较好玩的java工具类库，包含很多好玩的工具类，简单便捷。

（1）、安装

maven

<dependency>
    <groupid>cn.hutool</groupid>
    <artifactid>hutool-all</artifactid>
    <version>5.6.1</version>
</dependency>

gradle

compile 'cn.hutool:hutool-all:5.6.1'

maven*仓库
hutool 5.x支持jdk8+，对android平台没有测试，不能保证所有工具类或工具方法可用。 如果你的项目使用jdk7，请使用hutool 4.x版本

（2）、使用

	//该工具类时间都是格式化好的
	system.out.println(dateutil.now());//------------------------------取当前时间
	
	这也没啥好说的下载源码看中文注释即可，就不一一举例了，，，简简单单。

总结

总之好玩的工具类一大坨，不管是jdk原生还是别人封装的工具类，如果你想也可以自己通过jdk1.8的日期api自己封装属于自己的日期工具类，网上的日期工具类太多了，不要重复造*~~~~~~~~~~今天也是元气满满的一天

以上就是java 进行时间处理的步骤的详细内容，更多关于java 时间处理的资料请关注其它相关文章！