12.日期与时间

真滴book理喻

已于 2024-07-31 09:57:20 修改

阅读量148

点赞数

分类专栏： # Java SE 文章标签： java servlet jvm

于 2023-01-30 16:15:18 首次发布

本文链接：https://blog.csdn.net/m0_59749089/article/details/128804186

版权

Java SE 专栏收录该内容

28 篇文章 0 订阅

订阅专栏

一.Date类

1.1 什么是Date类

java.util 包提供了 Date 类来封装系统当前的日期和时间，Date 类提供了如下所示的 2 个构造函数来实例化 Date 对象。

名称	说明
public Date()	创建一个Date对象，代表的是系统当前日期时间
public Date(long time)	把时间毫秒值转换成Date日期时间对象

构造方法使用示例如下：

//调用无参数构造函数显示的顺序为星期、月、日、小时、分、秒、时区、年
Date date1 = new Date();   
System.out.println(date1.toString()); // 输出：Wed May 18 21:24:40 CST 2016
//调用含有一个long类型参数的构造函数
Date date2 = new Date(60000);    
System.out.println(date2); // 输出：Thu Jan 0108:01:00 CST 1970

1.2 常用方法

//判断二个Date对象所代表的时间是否相等
boolean equals(Date date1, Date date2)
//返回从1970年1月1日00:00:00走到此刻的总毫秒数
public long getTime()
//设置日期对象的时间为当前毫秒值对应的时间
public long setTime(long Time)
//判断此日期是否在指定日期之后
boolean after(Date when)
//判断此日期是否在指定日期之前
boolean before(Date when)
//比较二个日期的顺序
int compareTo(Date anotherDate)
//把此Date对象按照星期、月、日、小时、分、秒、时区、年的顺序打印
String toString()

//获取当前系统时间对应的毫秒值
System.currentTimeMillis()

二.SimpleDateFormat

2.1 SimpleDateFormat概述

什么是日期格式化

日期格式化是将日期对象或日期字符串转换为特定格式的字符串的过程。在计算机编程中，日期和时间通常以特定的格式进行表示，例如 年-月-日，月/日/年，小时:分钟:秒 等。日期格式化是处理日期和时间的重要操作，在实际应用中常常用于日志记录、报表生成、数据导出等场景，以确保日期和时间的显示与用户的期望和习惯一致。

什么是SimpleDateFormat

SimpleDateFormat 类是 Java 中用于日期和时间格式化的类。它是 java.text 包下的一个类，用于将日期对象按照指定的模式格式化为字符串，或者将指定格式的日期字符串解析为日期对象。

SimpleDateFormat 类提供了一组格式化模式，用于定义日期和时间的各个部分如何显示。格式化模式使用特定的字符来表示不同的日期和时间元素，这些常用的字符有下表所示的 6 种。

yyyy	四位数的年份
MM	两位数的月份
dd	两位数的日期
HH	24小时制的小时数
mm	分钟数
ss	秒数
`-`、`/`、: 等	在日期时间中穿插的特殊符号

2.2 常用方法

1.format方法

format(Date date)：SimpleDateFormat 类提供了 format 方法，可将一个日期对象按照指定的格式化模式转换为字符串，代码如下：

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = new Date();
//将日期对象格式化为 yyyy-MM-dd HH:mm:ss 的字符串格式输出。
String formattedDate = sdf.format(date);
System.out.println(formattedDate);

2.parse方法

parse(String source)：SimpleDateFormat 类提供了 parse 方法，可将指定格式的日期字符串解析为 date 对象，代码如下：

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
String dateString = "2023-08-01";
try {
    //将 2023-08-01 的日期字符串解析为对应的日期对象输出。
    Date date = sdf.parse(dateString);
    System.out.println(date);
} catch (ParseException e) {
    e.printStackTrace();
}

3.setLenient方法

setLenient(boolean lenient)：设置解析过程是否宽松。如果设置为 true，在解析过程中会尝试修复一些非法的日期值；如果设置为 false，则会抛出 ParseException。

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
sdf.setLenient(false);
String dateString = "2022-13-32"; // 非法的日期
try {
    Date date = sdf.parse(dateString);
    System.out.println(date);
} catch (ParseException e) {
    e.printStackTrace();
}

4.setTimeZone

setTimeZone(TimeZone zone)：设置时区。

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
sdf.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
Date date = new Date();
String formattedDate = sdf.format(date);
System.out.println(formattedDate);

5.toPattern

toPattern()：获取当前格式化模式。

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
String pattern = sdf.toPattern();
System.out.println(pattern);

三.Calendar

3.1 Calendar概述

Calendar 是来自 Java.util 包下的抽象类，是用来操作日历的类。日历字段包含YEAR、MONTH、DAY_OF_MONTH、HOUR 等，它们都是 Calendar 类的静态常量。

3.2 常用方法

1.创建实例对象

创建实例对象如下，默认当前日期。

Calendar calendar = Calendar.getInstance();
System.out.println(cal.getTime());//Mon Jun 28 19:30:31 CST 2021

2.Calendar类中的常量

//指示年
Calendar.YEAR      
//指示月份
Calendar.MONTH      
//指示当前时间为多少号（日历式的多少号）
Calendar.DATE      
//指示小时（12小时制）
Calendar.HOUR      
//指示小时（24小时制）
Calendar.HOUR_OF_DAY   
//指示分钟数
Calendar.MINUTE    
//指示秒数
Calendar.SECOND    
//指示毫秒
Calendar.MILLISECOND   
//当前时间是所在当前月的第几个星期(日历式的第几周)
Calendar.WEEK_OF_MONTH 
//当前时间是所在当前年的第几个星期
Calendar.WEEK_OF_YEAR 
//当前时间是所在当前月的第几个星期,以月份天数为标准,一个月的1号为第一周,8号为第二周
Calendar.DAY_OF_WEEK_IN_MONTH 
//一周7天当中,当前时间是星期几
Calendar.DAY_OF_WEEK     
//指示一年中的第几天
Calendar.DAY_OF_YEAR   
//指示一月中的第几天,结果等同于Calendar.DATE
Calendar.DAY_OF_MONTH     
//指示上午还是下午
Calendar.AM_PM 
//周天
Calendar.SUNDAY   
//周一
Calendar.MONDAY   
//周二
Calendar.TUESDAY 
//周三
Calendar.WEDNESDAY
//周四
Calendar.THURSDAY  
//周五
Calendar.FRIDAY  
//周六
Calendar.SATURDAY

3.取日历的值

//获得年、月、日、时、分、秒、毫秒
ca.get(Calendar.YEAR);
ca.get(Calendar.MONTH);
ca.get(Calendar.DATE);
ca.get(Calendar.HOUR_OF_DAY);
ca.get(Calendar.MINUTE);
ca.get(Calendar.SECOND);
ca.get(Calendar.MILLISECOND);

//当前时间是所在当前月的第几个星期(日历式的第几周)
ca.get(Calendar.WEEK_OF_MONTH); 
//当前时间是所在当前年的第几个星期(日历式的第几周)
ca.get(Calendar.WEEK_OF_YEAR)); 
//当前时间是所在当前月的第几个星期,以月份天数为标准,一个月的1号为第一周,8号为第二周
ca.get(Calendar.DAY_OF_WEEK_IN_MONTH);
//一周7天当中,当前时间是星期几, 返回结果为1-7
ca.get(Calendar.DAY_OF_WEEK);

//一年中的第几天
ca.get(Calendar.DAY_OF_YEAR);

//判断当前时间是AM,还是PM,若是AM返回结果为0,若是PM返回结果为1
ca.get(Calendar.AM_PM);

4.设置日历字段的值

set(int field, int value);
set(int year, int month, int day);
set(int year, int month, int day, int hour, int minute);
set(int year, int month, int day, int hour, int minute, int second);
设置年、月、日、时、分、秒、毫秒
月份的正常值范围为0-11，0表示一月，以此类推。日期的正常值范围为1-31，结尾数字视月份而定。
//2021-06-28 00:00:00
Calendar ca = Calendar.getInstance();
ca.set(Calendar.YEAR,2021);
ca.set(Calendar.MONTH,06); 
ca.set(Calendar.DATE,28);
ca.set(Calendar.HOUR_OF_DAY,0);
ca.set(Calendar.MINUTE,0);
ca.set(Calendar.SECOND,0);

四.Java8新增日期类

4.1 Java8日期类概述

1.Java8 之前日期类所存在的问题

在 Java8 之前通常会使用 Date 结合 SimpleDateFormat、Calender 来处理时间和日期的相关需求。但是这些 API 也存在明显的缺点：

可读性差、易用性差、使用起来冗余繁琐
java.util.Date 是非线程安全的
java.util.Date 存在千年虫问题、并且不支持国际化和时区、故大部分方法被声明为过时、不建议再使用
java.util 和 java.sql 两包中都有 Date 类，设计上并不合理。

而 java8 在 java.time 包下重新实现了日期相关类。每个类功能明确清晰、类之间协作简单、API 定义清晰、功能强大无需借助外部工具类，并且线程安全。

2.Java8 新增日期类

Java8 新增的日期类主要有三个：

LocalDate：表示日期，也就是年月日
LocalTime ：表示时间，也就是时分秒
LocalDateTime：表示时间+ 日期，也就是年月日时分秒，是 java8 最常用的日期类

这些类使用了 final 来修饰，使得这些类是不可变的，一旦实例化，值就固定了，有点类似于String类。因此它们都是线程安全的。

4.2 LocalDate

4.2.1 常用API

方法	描述
static LocalDate now()	获取默认时区的当前日期对象
static LocalDate now(Clock clock)	从指定时钟获取当前日期对象
static LocalDate now(ZoneId zone)	获取指定时区的当前日期对象
of	根据指定年月日创建 LocalDate 对象
getYear	获得年份
getMonthValue	获得月份（1-12）
getMonth	获得月份枚举值
getDayOfMonth	获得月份中的第几天（1-31）
getDayOfWeek	获得星期几
getDayOfYear	获得年份中的第几天（1-366）
lengthOfYear	获得当年总天数
lengthOfMonth	获得当月总天数
toEpochDay	与时间纪元（1970年1月1日）相差的天数
plusDays	加天
plusWeeks	加周
plusMonths	加月
plusYears	加年
minusDays	减年
minusWeeks	减周
minusMonths	减月
minusYears	减年
withYear	替换年份
withMonth	替换月份
withDayOfMonth	替换月份中的第几天（1-31）
withDayOfYear	替换年份中的第几天（1-366）
isBefore	是否日期在之前
isAfter	是否日期在之后
isEqual	是否是当前日期
isleapYear	是否是闰年

4.1.2 使用示例

1.创建方法

LocalDate now1 = LocalDate.now();							// 当前日期 
LocalDate now2 = LocalDate.now(ZoneId.of("Asia/Shanghai"));	// 当前日期 (指定时区)
LocalDate now3 = LocalDate.now(Clock.systemDefaultZone());	// 当前日期 (指定时钟)
LocalDate localDate = LocalDate.of(2023, 1, 1);				// 指定日期 2023-01-01

2.获取方法

LocalDate now = LocalDate.now();
int year = now.getYear();						// 获取年份
int month = now.getMonthValue();				// 获取月份（1-12）
Month monthEnum = now.getMonth();				// 获取月份的枚举值
int dayOfMonth = now.getDayOfMonth();			// 获取月份中的第几天（1-31）
int dayOfYear = now.getDayOfYear();				// 获取一年中的第几天（1-366）
DayOfWeek dayOfWeek = now.getDayOfWeek();		// 获取现在是星期几
int dayOfYear = now.getDayOfYear();				// 获取一年中的第几天（1-366）
int lengthOfYear = now.lengthOfYear();			// 获得当年总天数
int lengthOfMonth = now.lengthOfMonth();		// 获得当月总天数
long epochDay = now.toEpochDay();				// 与时间纪元（1970年1月1日）相差的天数

3.运算方法

LocalDate now = LocalDate.now();
LocalDate localDate1 = now.plusDays(1);			// 给当前时间加一天
LocalDate localDate2 = now.plusDays(1);			// 给当前时间加一周
LocalDate localDate3 = now.plusMonths(1);		// 给当前时间加一月
LocalDate localDate4 = now.plusYears(1);		// 给当前时间加一年
LocalDate localDate5 = now.minusDays(1);		// 给当前时间减一天
LocalDate localDate6 = now.minusWeeks(1);		// 给当前时间减一周
LocalDate localDate7 = now.minusMonths(1);		// 给当前时间减一月
LocalDate localDate8 = now.minusYears(1);		// 给当前时间减一年

4.修改方法

LocalDate now = LocalDate.now();
LocalDate localDate1 = now.withYear(2020);		// 修改日期对象年份为2020
LocalDate localDate2 = now.withMonth(1);		// 修改日期对象月份为1
LocalDate localDate3 = now.withDayOfMonth(1);	// 修改日期对象的日期(一月中的第几天)
LocalDate localDate4 = now.withDayOfYear(1);	// 修改日期对象的日期(一年中的第几天)

5.比较方法

LocalDate now = LocalDate.now();
LocalDate localDate = LocalDate.of(2023, 1, 1)
    
boolean isBefore = localDate.isBefore(now);		// localDate是否在当天之前
boolean isAfter = localDate.isAfter(now);		// localDate是否在当天之后
boolean isEqual = localDate.isEqual(now);		// localDate是否在当天
boolean isLeapYear = localDate.isLeapYear();	// localDate是否是闰年

6.LocalDate 与 Date之间的转换

/**
 * LocalDate转Date
 * @param localDate
 * @return
 */
public static Date toDate(LocalDate localDate) {
    return Date.from(localDate.atStartOfDay().atZone(ZoneId.systemDefault()).toInstant());
}

/**
 * Date转LocalDate
 * @param Date
 * @return
 */
public static Date toLocalDate(Date date) {
    return date.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
}

7.LocalDate与String之间的转换

/**
  * String转LocalDate
  * @param dateStr 	   日期的字符串
  * @param pattern 	   格式示例： yyyy-MM-dd
  * @return
  */
public static LocalDate toLocalDate(String dateStr, String pattern) {
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
    return LocalDate.parse(dateStr, formatter);
}

/**
  * LocalDate转String
  * @param localDate   localDate对象
  * @param pattern 	   格式示例： yyyy-MM-dd
  * @return
  */
public static String LocalDatetoStr(LocalDate localDate, String pattern) {
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
    return localDate.format(formatter);
}

4.3 LocalTime

4.3.1 常用API

方法	描述
static LocalTime now()	获取默认时区的当前时间
static LocalTime now(ZoneId zone)	获取指定时区的当前时间
static LocalTime now(Clock clock)	从指定时钟获取当前时间
of	根据指定的时、分、秒获取LocalTime 实例
getHour	获取小时
getMinute	获取分钟
getSecond	获取秒
getNano	获取纳秒
plusHours	增加小时数
plusMinutes	增加分钟数
plusSeconds	增加秒数
plusNanos	增加纳秒数
minusHours	减少小时数
minusMinutes	减少分钟数
minusSeconds	减少秒数
minusNanos	减少纳秒数
withHour	替换小时
withMinute	替换分钟
withSecond	替换秒钟
withNano	替换纳秒
compareTo	时间与另一个时间比较
isAfter	检查时间是否在指定时间之后
isBefore	检查时间是否在指定时间之前

4.3.2 使用示例

1.创建方法

LocalTime now1 = LocalTime.now();							// 当前时间 
LocalTime now2 = LocalTime.now(ZoneId.of("Asia/Shanghai"));	// 当前时间 (指定时区)
LocalTime now3 = LocalTime.now(Clock.systemDefaultZone());	// 当前时间 (指定时钟)
LocalTime localTime = LocalTime.of(9, 9, 9);				// 指定时间 09:09:09

2.获取方法

LocalTime now = LocalTime.now();
int hour = now.getHour();						// 获取小时
int minute = now.getMinute();					// 获取小时
int second = now.getSecond();					// 获取秒
int nano = now.getNano();						// 获取纳秒

3.运算方法

LocalTime now = LocalTime.now();
LocalTime localTime1 = now.plusHours(1);		// 给当前时间加一小时	
LocalTime localTime2 = now.plusMinutes(1);		// 给当前时间加一分钟	
LocalTime localTime3 = now.plusSeconds(1);		// 给当前时间加一秒
LocalTime localTime4 = now.plusNanos(1);		// 给当前时间加一纳秒
LocalTime localTime1 = now.minusHours(1);		// 给当前时间减一小时
LocalTime localTime2 = now.minusMinutes(1);		// 给当前时间减一分钟	
LocalTime localTime3 = now.minusSeconds(1);		// 给当前时间减一秒
LocalTime localTime4 = now.minusNanos(1);		// 给当前时间减一纳秒

4.修改方法

LocalTime now = LocalTime.now();
LocalDate localTime1 = now.withHour(1);			// 修改时间对象小时为1
LocalDate localTime2 = now.withMinute(1);		// 修改时间对象分钟为1
LocalDate localTime3 = now.withSecond(1);		// 修改时间对象秒钟为1
LocalDate localTime4 = now.withNano(1);			// 修改时间对象纳秒为1

5.比较方法

LocalTime now = LocalTime.now();
LocalTime localTime = LocalTime.of(9, 9, 9);
int compare = localTime.compareTo(now);		// localTime和当前时间比较--0(相等)正数(大)负数(小)
boolean after = localTime.isAfter(now);		// localTime是否在当前时间之后
boolean before = localTime.isBefore(now);	// localTime是否在当前时间之前

6.LocalTime与String之间的转换

/**
  * String转LocalTime
  * @param timeStr 	   日期的字符串
  * @param pattern 	   格式示例： HH:mm:ss
  * @return
  */
public static LocalTime toLocalTime(String timeStr, String pattern) {
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
    return LocalTime.parse(timeStr, formatter);
}

/**
  * LocalTime转String
  * @param localTime   localTime对象
  * @param pattern 	   格式示例： HH:mm:ss
  * @return
  */
public static LocalTime localTimeToStr(LocalTime localTime, String pattern) {
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
    return localTime.format(formatter);
}

LocalTime 是无法转换为Date的，因为它值包含了时间部分，而没有日期部分

4.4 LocalDateTime

4.4.1 常用API

方法	描述
static LocalDateTime now()	获取默认时区的当前日期时间
static LocalDateTime now(Clock clock)	从指定时钟获取当前日期时间
static LocalDateTime now(ZoneId zone)	获取指定时区的当前日期时间
static LocalDateTime of(LocalDate date, LocalTime time)	根据日期和时间对象获取 LocalDateTime 对象
static LocalDateTime of(int year, Month month, int dayOfMonth, int hour, int minute, int second)	根据指定的年、月、日、时、分、秒获取 LocalDateTime 实例
getYear	获取年份
getMonth	使用月份枚举类获取月份
getDayOfMonth	获取日期在该月是第几天
getDayOfWeek	获取日期是星期几
getDayOfYear	获取日期在该年是第几天
getHour	获取小时
getMinute	获取分钟
getSecond	获取秒
getNano	获取纳秒
plusYears	增加年
plusMonths	增加月
plusWeeks	增加周
plusDays	增加天
plusHours	增加小时
plusMinutes	增加分
plusSeconds	增加秒
plusNanos	增加纳秒
minusYears	减少年
minusMonths	减少月
meminusWeeks	减少周
minusDays	减少天
minusHours	减少小时
minusMinutes	减少分
minusSeconds	减少秒
minusNanos	减少纳秒
withYear	替换年份
withMonth	替换月份
withDayOfMonth	替换月份中的第几天（1-31）
withDayOfYear	替换年份中的第几天（1-366）
withHour	替换小时
withMinute	替换分钟
withSecond	替换秒钟
withNano	替换纳秒
isEqual	判断日期时间是否相等
isBefore	检查是否在指定日期时间之前
isAfter	检查是否在指定日期时间之后

4.4.2 使用示例

1.创建方法

// 1.当前日期
LocalDateTime now1 = LocalDateTime.now();
// 2.当前日期 (指定时区)
LocalDateTime now2 = LocalDateTime.now(ZoneId.of("Asia/Shanghai"));
// 3.当前日期 (指定时钟)
LocalDateTime now3 = LocalDateTime.now(Clock.systemDefaultZone());
// 4.指定日期 2023-01-01 01:01:00
LocalDateTime localDateTime1 = LocalDateTime.of(2023, 1, 1, 1, 1);
// 4.使用LocalDate和LocalTime对象创建LocalDateTime对象
LocalDate localDate = LocalDate.now();
LocalTime localTime = LocalTime.now();
LocalDateTime localDateTime2 = LocalDateTime.of(localDate, localTime);

2.获取方法

LocalDateTime now = LocalDateTime.now();
int year = now.getYear();                   	// 获取年份
Month month = now.getMonth();               	// 使用月份枚举值
int dayOfMonth = now.getDayOfMonth();       	// 获取日期在该月是第几天
DayOfWeek dayOfWeek = now.getDayOfWeek();  		// 获取日期是星期几
int dayOfYear = now.getDayOfYear();         	// 获取日期在该年是第几天
int hour = now.getHour();                   	// 获取小时
int minute = now.getMinute();               	// 获取分钟
int second = now.getSecond();               	// 获取秒钟
int nano = now.getNano();                   	// 获取纳秒

3.运算方法

LocalDateTime now = LocalDateTime.now();
LocalDateTime localDateTime1 = now.plusDays(1);			// 给当前时间加一天
LocalDateTime localDateTime2 = now.plusDays(1);			// 给当前时间加一周
LocalDateTime localDateTime3 = now.plusMonths(1);		// 给当前时间加一月
LocalDateTime localDateTime4 = now.plusYears(1);		// 给当前时间加一年
LocalDateTime localDateTime5 = now.plusHours(1);		// 给当前时间加一小时
LocalDateTime localDateTime6 = now.plusMinutes(1);		// 给当前时间加一分钟
LocalDateTime localDateTime7 = now.plusSeconds(1);		// 给当前时间加一秒
LocalDateTime localDateTime8 = now.plusNanos(1);		// 给当前时间加一纳秒
LocalDateTime localDateTime9 = now.minusDays(1);		// 给当前时间减一天
LocalDateTime localDateTime10 = now.minusWeeks(1);		// 给当前时间减一周
LocalDateTime localDateTime11 = now.minusMonths(1);		// 给当前时间减一月
LocalDateTime localDateTime12 = now.minusYears(1);		// 给当前时间减一年
LocalDateTime localDateTime13 = now.minusHours(1);		// 给当前时间减一小时
LocalDateTime localDateTime14 = now.minusMinutes(1);	// 给当前时间减一分钟
LocalDateTime localDateTime15 = now.minusSeconds(1);	// 给当前时间减一秒
LocalDateTime localDateTime16 = now.minusNanos(1);		// 给当前时间减一纳秒

4.修改方法

LocalDateTime now = LocalDateTime.now();
LocalDateTime localDate1 = now.withYear(2020);		    // 修改日期对象年份为2020
LocalDateTime localDate2 = now.withMonth(1);		    // 修改日期对象月份为1
LocalDateTime localDate3 = now.withDayOfMonth(1);	    // 修改日期对象的日期(一月中的第几天)
LocalDateTime localDate4 = now.withDayOfYear(1);	    // 修改日期对象的日期(一年中的第几天)
LocalDateTime localTime1 = now.withHour(1);			    // 修改时间对象小时为1
LocalDateTime localTime2 = now.withMinute(1);		    // 修改时间对象分钟为1
LocalDateTime localTime3 = now.withSecond(1);		    // 修改时间对象秒钟为1
LocalDateTime localTime4 = now.withNano(1);				// 修改时间对象纳秒为1

5.比较方法

LocalDateTime now = LocalDateTime.now();
LocalDateTime localDateTime = LocalDateTime.of(2023, 1, 1, 1, 1);
boolean isBefore = localDateTime.isBefore(now);			// localDateTime是否在当天之前
boolean isAfter = localDateTime.isAfter(now);		    // localDateTime是否在当天之后
boolean isEqual = localDateTime.isEqual(now);		    // localDateTime是否在当天

6.从LocalDateTime获取LocalDate或者LocalTime

LocalDateTime localDateTime = LocalDateTime.now();
LocalDate localDate = localDateTime.toLocalDate();    // 从LocalDateTime获取LocalDate对象
LocalTime localTime = localDateTime.toLocalTime();    // 从LocalDateTime获取LocalTime对象

7.LocalDateTime 与 String之间的转换

/**
  * String转LocalDateTime
  * @param dateTimeStr 日期的字符串
  * @param pattern 	   格式示例： yyyy-MM-dd HH:mm:ss
  * @return
  */
public static LocalDateTime toLocalDateTime(String dateTimeStr, String pattern) {
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
    return LocalDateTime.parse(dateTimeStr, formatter);
}

/**
  * LocalDateTime转String
  * @param localDateTime 日期时间对象
  * @param pattern 	   	 格式示例： yyyy-MM-dd HH:mm:ss
  * @return
  */
public static String LocalDateTimetoStr(LocalDateTime localDateTime, String pattern) {
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
    return localDateTime.format(formatter);
}

9.LocalDateTime 与 Date之间的转换

/**
  * Date转LocalDateTime
  * @param date          jdk6 日期对象
  * @param zoneId        时区id
  * @return
  */
public static LocalDateTime toLocalDateTime(Date date, ZoneId zoneId) {
    // toInstant()：将Date对象转换成为Instant(瞬时)对象
    // ofInstant(): 将瞬时对象转换成为LocalDateTime对象
    Instant instant = date.toInstant();
    if (zoneId == null) {
        zoneId = ZoneId.systemDefault();
    }
    return LocalDateTime.ofInstant(instant, zoneId);
}

/**
  * LocalDateTime转Date
  * @param localDateTime  日期时间对象
  * @return
  */
public static Date LocalDateTimetoDate(LocalDateTime localDateTime, ZoneId zoneId) {
    if (zoneId == null) {
        zoneId = ZoneId.systemDefault();
    }
    ZonedDateTime zonedDateTime = localDateTime.atZone(zoneId);
    Instant instant = zonedDateTime.toInstant();
    return Date.from(instant);
}

4.5 .DateTimeFormatter

1.什么是DateTimeFormatter

使用旧的Date对象时，我们用SimpleDateFormat进行格式化显示。在 JDK8 中，引入了一个新的日期与时间格式器 DateTimeFormatter，用来格式化 JDK8 的新日期类，比如：LocalDateTime、LocalDate、LocalTime。和 SimpleDateFormat相比，DateTimeFormatter 是线程安全的。

2.使用步骤

LocalDate 转换

//解析日期
String dateStr= "2016年10月25日";
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日");

//LocalDate练习
LocalDate date= LocalDate.parse(dateStr, formatter);
System.out.println(date);//2016-10-25

String format1 = date.format(formatter);
System.out.println(format1);//2016年10月25日

LocalDateTime 的转换

//LocalDateTime练习
String dateTimeStr= "2016-10-25 12:00:00";
DateTimeFormatter formatter02 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

LocalDateTime localDateTime=LocalDateTime.parse(dateTimeStr,formatter02);
System.out.println(localDateTime);//2016-10-25T12:00

String format = localDateTime.format(formatter02);
System.out.println(format);//2016-10-25 12:00:00

3.常见的时间格式

    /** 默认的时间格式为"yyyy-MM-dd HH:mm:ss"，若后续有其他需求，则可以另行添加 */
	static final String DEFAULT_DATE_FORMAT = "yyyy-MM-dd HH:mm:ss";
	
	/** 格式 "yyyy/MM/dd HH:mm:ss" */
	static final String DEFAULT_DATE_FORMAT_2 = "yyyy/MM/dd HH:mm:ss";
	
	/** 格式 "yyyy-MM-dd" */
	static final String DATE_FORMAT = "yyyy-MM-dd";
	
	static final String DATE_FORMAT_2 = "yyyy/MM/dd";
	
	/** 格式 "yyyy-MM" */
	static final String MONTH_FORMAT = "yyyy-MM";
	
	static final String MONTH_FORMAT_2 = "yyyy/MM";
	
	// 默认的时间格式为"yyyy/MM/dd HH:mm:ss"，若后续有其他需求，则可以另行添加
	static DateTimeFormatter defaultFormatter =       
    DateTimeFormat.forPattern(DEFAULT_DATE_FORMAT);
	
	// 当前日期标签，很多类似日志文件需要打时间标签
	static final String DATE_MARK = "yyyyMMdd";
	
	// 默认的时间格式
	//private static final String DEFAULT_TIME_FORMAT = "HH:mm:ss";
	static final String HOUR_MINUTE = "HH:mm";

	/**
	 * 默认的stringbuffer 长度，
	 * stringbuffer 的默认长度是16，
	 * 增长策略是每次增加16字节，
	 * so可以一次性申请100个字节，提交效率
	 */
	int DEFAULT_STRINGBUFFER_LENGTH = 100;

	/** 响应状态: STATUS_OK = 1 */
	static final int DB_INSERT_OK = 1;
	/** 星期一  1 */
	int MONDAY = 1;
	int TUESDAY =2;
	int WEDNESDAY = 3;
	int THURSDAY = 4;
	int FRIDAY = 5;
	int ALLWEEK = 0;
	
	// 公司名称
	static final String COMPANY_NAME = "XXXXX";

五.Instant

5.1 Instant是什么

Instant 是时间戳的意思，时间戳包含日期和时间。可以通过 Instant 类的 now() 返回当前时间戳。

Instant instant = Instant.now();
System.out.println("当前时间戳是：" + instant);

5.3 Instant和Date的转换

Instant转为Date

Date date = Date.from(instant);
System.out.println("当前时间戳是：" + date);

Date转为Instant

instant = date.toInstant();
System.out.println(instant);

六.时间工具类

6.1 Period

在Java8中，我们可以使用java.time包下的Period类来计算日期间隔差异。主要用到 Period 类的方法 getYears()，getMonths() 和 getDays() 来计算，只能精确到年月日。用于 LocalDate 之间的比较。

6.2 Duration

在 Java8 中，我们可以使用 java.time 包下的 Duration 类来计算时间间隔差异，既可用于 LocalDateTime 之间的比较，也可用于 Instant 之间的比较。

6.3 CHronoUnit

ChronoUnit 类可用于在单个时间单位内测量一段时间，这个工具类是最全的了，可以用于比较所有的时间单位。

七.时区

什么是时区

时区是地球上用于标准化时间的地理区域。地球被划分为24个时区，每个时区大约覆盖经度15度。这24个时区的设定是基于地球每24小时内完整的自转一圈，而这一圈被均分为24段。

划分时区的目的

时区的设定是为了解决随着地理位置的改变，地方时间的不同的问题。例如，当在某地是中午12点太阳正当中时，其他地方可能由于地理位置的差异，太阳可能刚升起或者已经落下。

时区参考的标准时间

每个时区都有一个参考的标准时间，通常是以格林尼治天文台所在地的时间，称为格林尼治标准时间，或者叫做格林尼治平均时间（Universal Time Coordinated, UTC）作为基准，然后向东增加小时数，向西减少小时数，要注意时间上是早加晚减，也就是说向东增加一个小时，就是早一个小时。为了简化起见，许多时区都会选择一个城市的名字来代表，比如东八区（UTC+8）通常被称为北京时间，表示比UTC时间早 8 小时。

注意事项

需要注意的是，由于历史、政治等原因，实际的时区边界可能会与理论上的经度线有所偏差。比如，中国虽然地理范围上覆盖了5个时区，但是全国统一使用北京时间。