关于Java中的日期与时间的相关类说明详解

﹏ヽ暗。殇╰゛Y 2023-09-24 16:42 25阅读 0赞

### 文章目录 ###

*  1.关于Java元年与时间戳
 *  2.关于Date类
 *   *  2.1常用API代码展示
 *  3.关于Calendar类
 *   *  3.1获取Calendar对象
     *  3.2创建自定义的Calendar对象
     *  3.2Calendar类的核心方法
     *  3.3Calendar与时间戳、Date
     *  3.4关于Calendar的小结
 *  4.关于SimpleDateFormat类
 *   *  4.1关于Date对象的格式化
     *  4.2关于SimpleDateFormat类
     *  4.3模式字符串
     *  4.4应用模式字符串到SimpleDateFormat对象
     *  4.5将String格式的日期转换为Date对象
     *  4.6SimpleDateFormat是多线程不安全的
 *  5.Java8中的日期与时间
 *   *  5.1原来的问题
     *  5.2 Java8的日期时间相关类
     *  LocalDate类
     *   *  5.3 创建LocalDate对象
         *  5.4LocalDate常用API
         *  5.5LocalDate小结+代码
     *  LocalTime类
     *   *  5.6 创建LocalTime对象
         *  5.7 LocalTime的常用API
         *  5.8 关于LocalTime的小结
     *  LocalDateTime类
     *   *  5.10创建LocalDateTime对象
         *  5.11 LocalDateTime的API
         *  5.12 LocalDateTime的小结
 *  6.关于DateTimeFormatter类
 *   *  6.1获取DateTimeFormatter对象
     *  6.2 格式化日期时间
     *  6.3将字符串格式的日期时间转换为对象
     *  6.4获取DateTimeFormatter对象---补充
     *  6.5DateTimeFormatter小结+代码

# 1.关于Java元年与时间戳 #

*  在Java语言中，使用1970-01-01 0:00:00 GMT作为元年
    
     *  GMT: Greenwich Mean Time，格林尼治标准时间，也称之为：世界时
     *  如果以北京时间为基准，则是1970-01-01 08:00:00
 *  从Java元年至今历时的毫秒数，就是Java**时间戳**;
 *  在Java语言中，所有获取当前时间的API都是通过Java时间戳实现的。有多种处理日期、时间的AP
 *  无论当前系统设置的哪个时区，只要是同一时间，获取得到的Java时间戳的值都是相同的。  
    `long time = System.currentTimeMillis ();`

# 2.关于Date类 #

*  Date类是简单的处理日期、时间相关数据的类
    
     *  可以创建当前时间的Date对象
     *  可以指定毫秒时间值创建Date对象
     *  可以获取Date对象的时间戳
     *  可以重新指定Date对象的毫秒值时间
     *  可以获取日期、时间中的详情值o
        
         *  例如年、月、日、小时、分钟、秒钟、星期等
         *  这些方法被声明为已过期I
     *  可以对比2个Date对象的时间先后
 *  注意:在JDK中有2个Date类，分别是java.util.Date和java.sgl.Date，本章讨论的是前者util包下的。

## 2.1常用API代码展示 ##

public class DateDemo {
        
        public static void main(String[] args) {
        
            //创建当前时间的Date对象
            Date date1 = new Date();
            //输出
            System.out.println("当前时间Date对象：");
            System.out.println(date1);
            System.out.println("-------------------------------");
    
            //创建指定时间的Date对象
            long time = 1000;//该值是即将创建Date对象所表示的 从Java元年到此时间经历的毫秒时间,1000ms=1s，也就是1970.1.1 8:01
            Date date2 = new Date(time);
            //输出
            System.out.println("当时用"+time+"作为构造方法参数的创建的Date对象");
            System.out.println(date2);
            System.out.println();
    
    
            //获取Date对象所表示的时间戳
            //调用getTime()方法
            long time1 = date1.getTime();
            long time2 = date2.getTime();
            System.out.println("以上第1个Date对象表示的时间戳：" + time1);
            System.out.println("以上第2个Date对象表示的时间戳：" + time2);
            System.out.println();
    
    
            //重新设置Date对象的时间戳
            //调用setTime(long) 方式
            date1.setTime(time2);
            date2.setTime(time1);
            System.out.println("通过setTime(long)方法对换了2个Date对象的时间戳：");
            System.out.println("第1个Date对象：" + date1);
            System.out.println("第2个Date对象：" + date2);
            System.out.println();
    
            //对比2个Date对象的时间先后
            //通过boolean before (Date)方法判断当前对象是否是在参数对象之前的时间
            boolean result;
            System.out.println( "通过boolean before (Date)方法判断时间先后: ");
            result = date1.before(date2);
            System.out.println("date1是在date2之前的时间:" + result);
            result = date2.before(date1);
            System.out.println("date2是在date1之前的时间: " + result) ;
            System.out.println();
    
            //通过boolean after(Date)方 法判断当前对象是否是在参数对象之后的时间
            System.out.println("通过boolean after(Date)方 法判断时间先后: ");
            result = date1.after(date2) ;
            System.out.println("date1是在date2之后的时间: " + result) ;
            result = date2.after(date1);
            System.out.println("date2是在date1之后的时间: " + result) ;
            System.out.println();
    
            //以下所有方法均被声明为已过期，但是不影响使用
            //获取日期，时间的详情值
            //通过int getYear()获取当前年
            int year = date2.getYear();
            System.out.println("通过int getYear()获取当前年：" + year);
            int fixedYear = year + 1900;//这里为什么 +1900 可以去getYear()的源代码中查看理解
            System.out.println("修正后（+1900）后的年份：" + fixedYear);
            //通过 int getMonth()获取当前月，将返回0~11
            int month = date2.getMonth();
            System.out.println("通过int getMonth()获取当前月：" + month);
            int fixedMonth = month + 1;
            System.out.println("修正（+1）后的月份：" + fixedMonth);
            //通过 int getDate()获取当前日。返回的与实际值相同，与日常认知相同
            int date = date2.getDate();
            System.out.println("通过int getDate()获取当前日(无需修正)：" + date);
            //通过 int getDay()获取当前星期几
            int day = date2.getDay();
            System.out.println("通过int getDay()获取星期几（无需修正）：" + day);
    
            //通过 int getHours()获取当前小时值
            //通过 int getMinutes()获取当前分钟值
            //通过 int getSeconds()获取当前秒
    
        }
    }

在Date类中关于获取时间详情值的方法过期，所以要获取时间详情可以使用Calendar类

# 3.关于Calendar类 #

*  Calendar是“历法”类
    
     *  也称之为“日历”类
 *  Calendar是抽象类，它只约定了作为“历法”类应该可以实现哪些操作，但具体的运算却没有实现
    
     *  例如protected abstract void computeTime()等
 *  Java提供了几种Calendar的实现(Calendar的子类) ，对应某些历法
 *  你也可以自定义类，继承自Calendar,并重写抽象方法.

## 3.1获取Calendar对象 ##

*  你可以调用public static Calendar getInstance()方法，以获取默认的Calendar的实现对象
    
     *  它将根据你的时区来决定获取哪种Ca lenda r实现对象
     *  一般来说，你获取到的会是GregorianCalendar类的对象

//获取Calendar对象
    Calendar calendar = Calendar.getInstance() ;

## 3.2创建自定义的Calendar对象 ##

你也可以直接创建自定义的Calendar对象  
注意：你应该使用Calendar来声明对象的类型，而不是自定义的类型

//创建自定义Calendar对象
    Calendar calendar = new CustomCalendar();

## 3.2Calendar类的核心方法 ##

在Calendar类中，最常用的是其设置值、获取值的方法:

*  public void set (int field， int value)
 *  public final void set (int year， int month, int date)
 *  public final void set (int year， int month, int date， int hourOfDay, int minute)
 *  public final void set (int year, int month, int date，int hourOfDay, int minute, int second)
 *  public int get (int field)
 *

**注意:所有set ()方法不会同步更新其它字段**

*  在设置值、获取值的方法中，int field参数表示你对历法对象中的哪个字段(详情值)进行操作，即你希望设置/获取的是年?还是月?还是哪个字段?你需要使用Calendar类定义的常量来表示

例如: Calendar. YEAR

![在这里插入图片描述][376c4f0fff3844fb8840751e5c62ef96.png]  
你还可以调用public void add(int field, int amount) **增加**某个字段的值，实现一些时间相关的运算

*  在调用该方法时，你可以向第2个参数int amount传递一 个负数值，以表示“减少”的意思，以将历法对象的时间设置得更早期一些
 *  该方法会同步更新其它字段
    
     *  该方法是抽象方法，当你自定义历法类时，需要注意同步更新其它字段

Calendar类也有与Date相似的before()和after()方法，用于判断2个对象在时间上的先后:

*  public boolean before (Object when)
 *  public boolean after (Object when)

虽然参数是0bject类型，但仅当传入的是Calendar类型才可以得到期望结果

## 3.3Calendar与时间戳、Date ##

Calenda r中还有与时间戳、Date进行转换的方法:

*  public final Date getTime ( )
 *  public final void setTime (Date date)
 *  public long getTimeInMillis ()
 *  public void setTimeInMillis (long millis)

public class CalendarDemo {
        
        public static void main(String[] args) {
        
            //通过Calendar的静态方法获取Calendar实例（对象）
            Calendar calendar = Calendar.getInstance();
            System.out.println(calendar);//输出会有很多参数，每个参数都是当前日期的某个值
    
    
            //修改字段值
            //期望值 2022-3-1
            //注意：Calendar处理月份时，使用的是0~11，所以3月份设置值应该是（3-1）即2
            calendar.set(2022,2,1);//查看字段,YEAR=2023,MONTH=1，DAY_OF_WEEK_IN_MONTH=1
            System.out.println(calendar);
            System.out.println();
    
            //修改字段值
            //期望值：小时 --> 21
            calendar.set(Calendar.HOUR_OF_DAY, 21);
            System.out.println(calendar);//查看字段：HOUR_OF_DAY=21
            System.out.println();
    
            //获取值
            int year = calendar.get(Calendar.YEAR);
            System.out.println("当前Calendar对象表示的【年份】" + year);
            int month = calendar.get(Calendar.MONTH);
            System.out.println("当前Calendar对象表示的【月份】" + month);
            int dayOfMonth = calendar.get(Calendar.DAY_OF_MONTH);
            System.out.println("当前Calendar对象表示的【当月的第几天】" + dayOfMonth);
            int hourOfDay = calendar.get(Calendar.HOUR_OF_DAY);
            System.out.println("当前Calendar对象表示的【当天的第几小时】" + hourOfDay);
            int minute = calendar.get(Calendar.MINUTE);
            System.out.println("当前Calendar对象表示的【分钟】" + minute);
            int second = calendar.get(Calendar.SECOND);
            System.out.println("当前Calendar对象表示的【秒钟】" + second);
            System.out.println();
    
            //增加某字段的值
            //期望：天+1
            calendar.add(Calendar.DAY_OF_MONTH, 1);
            System.out.println(calendar);
            System.out.println();
    
            //增加天数后，Calendar会在必要的时候更新月、年
            //期望目标：在2015-12-30基础上增加5天，目标将至2016-1-4
            System.out.println("本次已将日期先调整为2015-12-30，并增加5天");
            calendar.set(2015,11,30);
            calendar.add(Calendar.DAY_OF_MONTH ,5);
            System.out.println(calendar);
            System.out.println();
    
            //调用add方法时，第2个参数amount值为负数
            System.out.println("将DAY_OF_MONTH的增量设置为-6");
            calendar.add(Calendar.DAY_OF_MONTH, -6);
            System.out.println(calendar);
            System.out.println();
    
            //对比两个Calendar对象的时间先后
            //第一个Calendar的时间为：2000-5-6 12:34:56
            //第二个Calendar的时间为：2021-8-16 11:33:22
            Calendar calendar1 = Calendar.getInstance();
            calendar1.set(2000,5,6,12,34,56);
            Calendar calendar2 = Calendar.getInstance();
            calendar2.set(2021,8,16,11,33,22);
            System.out.println("Calendar1的时间为：2000-5-6 12:34:56");
            System.out.println("Calendar2的时间为：2021-8-16 11:33:22");
            boolean result;
            result = calendar1.before(calendar2);
            System.out.println(result);
            System.out.println();
    
    
    
        }
    }

## 3.4关于Calendar的小结 ##

*  **Calendar是用于解决Date类无法作用于不同历法的问题**
    
     *  Calendar只是一个抽象类，针对不同历法，可以有不同的子类，但各子类的API操作可以是相同的
 *  Calendar对象中包含丰富的字段，可以通过get ()方法获取
 *  通过set ()方法可以设置某个字段的值
 *  通过add()方法可以对某个字段增加或减去一定的值
 *  通过before ()和after()方法可以与另一个Calendar对象对比时间的先后

# 4.关于SimpleDateFormat类 #

## 4.1关于Date对象的格式化 ##

如果直接输出Date对象，得到的结果可能不符合需求

*  例如: Thu Jan 01 08:00:00 CST 1970
 *  各详情值的先后、语种、格式不符合需求（星期几，月份，日期，时间，时区，年份）
 *  你希望的格式可能是这样的:
    
     *  1970/1/1 8:00:00
     *  1970/01/01 08:00:00
     *  1970年01月01日08时00分00秒.

将Date对象转换为指定格式，即为:格式化

*  Calendar可以转换为Date

## 4.2关于SimpleDateFormat类 ##

\-SimpleDateFormat类是专门处理Date与字符串转换的工具类.

*  你可以将Date转换为特定格式的字符串
 *  你也可以将字符串表示的日期时间转换为Date

## 4.3模式字符串 ##

你需要掌握模式字符串的写法  
模式字符串：用于指定日期时间格式的字符串，可以在其中使用特定的字母表示特定的意义

*  例如y表示年份，你使用\_ yyyy年时，可以格式化为： 2021年 (当Date表示的年份是2021年时)
 *  在模式字符串中，严格区分特定的字母的大小写
    
     *  例如M表示月份，m表示分钟
 *  同一个字母，你可能需要写多个
 *  使用M月时，当Date对象的时间是1月份时，将格式为: 1月
    
     *  如果月份为10、11、12,会自动使用2位数字表示
 *  使用MM月时，当Date对象的时间是1月份时，将格式为: 01月

模式字符串表  
![在这里插入图片描述][54651451c1b743baa96ef4e0579fb5bc.png]  
一般，会这样定义模式字符串

//设计模式字符串
    String pattern = "yyyy-MM-dd HH:mm:ss";
    
    //设计模式字符串
    String pattern = "yyyy年MM月dd日 HH:mm:ss"
    
    //设计模式字符串
    String pattern = "yyyy/MM/dd HH:mm:ss";

你可以先写好模式字符串，作为创建SimpleDateForma t对象时构造方法的参数,然后调用该对象的String format (Date)方法即可得到格式化后的字符串结果。

//创建当前时间对象
    Date now = new Date();
    //设计模式字符串
    String pattern = "yyyy-MM-dd HH:mm:ss";
    //创建格式化工具对象，应用模式字符串
    SimpleDateFormat sdf = new SimpleDateFoemat(pattern);
    //执行格式化，并获取结果
    String result = sdf.format(now);
    //输出结果
    System.out.println(result);

## 4.4应用模式字符串到SimpleDateFormat对象 ##

你可以使用void applyPattern (String)方法，将模式字符串应用到已存在的SimpleDateFormat对象

*  也许你创建s impleDateFormat对象时，没有在构造方法里添加模式字符串作为参数
 *  也许你需要使用新的模式字符串

String pattern = "yyyy-MM-dd HH :mm:ss";
    sdf.applyPattern (pattern) ;

## 4.5将String格式的日期转换为Date对象 ##

你还可以调用Date parse (String source) throws ParseException方法将字符串格式的日期转换为Date对象

*  该方法是继承自其父类DateFormat的方法
 *  如果字符串表示的日期的格式不符合模式字符串的格式，当尝试转换时，将拋出ParseException异常

## 4.6SimpleDateFormat是多线程不安全的 ##

SimpleDateFormat在执行format()方法内部使用Calendar设置时间值，可能有多个线程同时执行这条语句，导致当前线程的时间值被其他线程修改：  
![在这里插入图片描述][22d41175e87440f98fa29c034c25c824.png]  
线程不安全的解决方案

*  不要将SimpleDateFormat声明为全局变量
    
     *  局部变量不存在线程安全问题
 *  使用synchronized互斥锁
 *  使用ThreadLocal类，则各线程使用独立的s impleDateFormat对象
 *  使用替代类，例如DateTimeFormatter

public class SimpleDateFormatDemo {
        
        public static void main(String[] args) throws ParseException {
        
            //准备Date对象，用于格式化
            Date now = new Date();
            System.out.println("格式化前当前时间：" + now);
    
            System.out.println("应用新的模式字符串 yyyy-MM-dd HH:mm:ss");
            //创建模式字符串
            String pattern = "yyyy-MM-dd HH:mm:ss";
            //创建SimpleDateFormat对象
            SimpleDateFormat sdf = new SimpleDateFormat(pattern);
            //执行格式化，并获取结果
            String result = sdf.format(now);
            //输出结果
            System.out.println("格式化后："+result);
            System.out.println();
    
            //应用新的模式字符串
            System.out.println("应用新的模式字符串 yyyy年MM月dd日");
            pattern = "yyyy年MM月dd日";
            sdf.applyPattern(pattern);
            result = sdf.format(now);
            System.out.println("格式化后："+result);
            System.out.println();
    
    
            //将字符串格式的日期转换为Date对象
            String dateString = "2018-6-22 13:52:16";//我们自定义的日期格式字符串
            pattern = "yyyy-MM-dd HH:mm:ss";
            sdf.applyPattern(pattern);
            sdf.parse(dateString);
            Date date = sdf.parse(dateString);
            System.out.println("将【" + dateString + "】转换为Date对象：" + date);
            System.out.println();
    
    
        }
    }

# 5.Java8中的日期与时间 #

## 5.1原来的问题 ##

在Java8之前，与日期时间相关的类存在的问题。

*  Date类的默认输出格式可能不直观
    
     *  例如: Thu Jan 01 08:00:00 CST 1970
 *  使用simpleDateFormat需要考虑线程安全问题
    
     *  可声明为局部变量，可避免出现线程安全问题，每次调用方法都会创建新的对象并在方法运行结束后销毁
     *  但是，它本身只是一个工具，工具理应可以复用 (创建1个工具，多处使用)，即声明为全局变量

## 5.2 Java8的日期时间相关类 ##

Java 8添加了一些新的类，用于处理日期、时间数据：

*  LocalDate
    
     *  只关注日期，即:年、月、日、星期等
 *  LocalTime
    
     *  只关注时间，即:小时、分钟、秒钟等
 *  LocalDateTime
    
     *  关心日期与时间
     *  本质上它是基于LocalDate和LocalTime这2个对象所创建出来的新对象
 *  日期时间格式化的工具类

## LocalDate类 ##

### 5.3 创建LocalDate对象 ###

你可以通过静态的now()方法创建当前时间对应的LocalDate对象，例如:  
`LocalDate localDate = LocalDate.now() ;`

你也可以通过年、月、日的数值来创建LocalDate对象，例如:  
`LocalDate localDate = LocalDate.of(2021，8，16);`

LocalDate还提供了parse()方法，你也可以按照 yyyy-MM-dd 模式的字符串来创建LocalDate对象

*  你必须严格按照该模式使用，例如8月，你只能使用08而不能使用8来表示
 *  LocalDate类重载了parse()方法，你可以指定格式化参数，从而使用其它格式的日期字符串
    
     *  你需要学习DateTimeEormatter类  
        `LocalDate localDate = LocalDate.parse("2021-08-16");`

### 5.4LocalDate常用API ###

你可以轻松获取各详情值，并且，这些返回值都是符合你的日常习惯的:

*  public int getYear ()
 *  public int getMonthValue ()
 *  public int getDayOfMonth ()
 *  public int getDayOfYear ()
 *  public DayOfWeek getDayOfWeek ()
    
     *  通过DayOfWee k的getValue ()可获取星期的数值
 *  public boolean isLeapYear () //是否是闰年
 *  public int lengthOfMonth ()
 *  public int lengthOfYear ()

你可以直接修改某个详情值:

*  public LocalDate withYear (int year)
 *  public LocalDate withMonth (int month)
 *  public LocalDate withDayOfMonth (int dayOfMonth)
 *  public LocalDate withDayOfYear (int dayOfYear)

注意: LocalDate对象不可变，以上API均返回新的对象

你可以很方便的实现年、月、日的增加或减去:

*  public LocalDate plusYears (long yearsToAdd)
 *  public LocalDate minusYears (long yearsToSubtract)
 *  public LocalDate plusMonths ( long monthsToAdd)
 *  public LocalDate minusMonths (long monthsToSubtract)
 *  public LocalDate plusWeeks (long weeksToAdd)
 *  public LocalDate minusWeeks (long weeksToSubtract)
 *  public LocalDate plusDays (long daysToAdd)  
    public LocalDate minusDays (long daysToSubtract)

这些API会保证增加或减去的日期是准确的  
\---- 例如在1月31日的基础上增加1天，将得到2月1日的LocalDate对象  
注意: LocalDate对象不可变，以上API均返回新的对象

你还可以通过with()方法结合TemporalAdjuster的方法得到相关日期

*  publiC LocalDate with (TemporalAdjuster adjuster)  
    TemporalAdjuster是一个接口，LocalDate实现了该接口，但一般使用它的实现类**TemporalAdjusters**

关于TemporalAdjusters类中你可能使用到的方法:

*  public static TemporalAdjuster firstDayIOfMonth ()
 *  public static Temporal Adjuster lastDayOfMonth ()
 *  public static TemporalAdjuster firstDayOfNextMonth ()
 *  public static TemporalAdjuster firstDayOfYear ()
 *  public static Temporal Adjuster lastDayOfYear ()
 *  public static TemporalAdjuster firstDayOfNextYear ()

你还可以根据LocalDate来创建LocalDateTime对象

*  public LocalDateTime atStartOfDay ()
 *  public LocalDateTime atTime (int hour, int minute)
 *  public LocalDateTime atTime (int hour, int minute,int second)
 *  public LocalDateTime atTime (int hour, int minute， int second, int nanoOfSecond) //nanoOfSecond 纳秒

### 5.5LocalDate小结+代码 ###

你可以直接获取当前时间对应的LocalDate对象，也可以通过年、月、日的数值，或通过符合yyyy-mm-dd 模式的字符串来创建LocalDate对象  
通过**get前缀**的方法可以获取各详情值，还可以判断是否闰年、月份的天数、年份的天数  
通过**with前缀**的方法可以修改详情值中的某个值，将得到新的LocalDate对象  
通过**with()方法**可以获取某些相关LocalDate对象.  
通过**plus / minus前缀**的方法可以对某个详情值进行增加/减去的操作，将得到新的LocalDate对象  
通过**at前缀**的方法可以在当前LocalDate对象的基础.上设置时间相关数据，将得到LocalDateTime对象

public class LocalDateDemo {
        
        public static void main(String[] args) {
        
            //获取当前时间对应的LocalDate
            LocalDate localDate1 = LocalDate.now();
    
            //输出的格式为： yyyy-MM-dd
            System.out.println(localDate1);
            System.out.println();
    
            //获取指定日期对应的LocalDate对象
            System.out.println("通过2015,3,26这3个数值来创建LocalDate对象");
            LocalDate localDate2 = LocalDate.of(2015, 3, 26);
            System.out.println(localDate2);
            System.out.println();
    
            //通过字符串的日期获取对应的LocalDate对象
            System.out.println("通过2003-07-11字符串获取对应的LocalDate对象");
    //        LocalDate localDate3 = LocalDate.parse("2003-7-11");
            LocalDate localDate3 = LocalDate.parse("2003-07-11");
            System.out.println(localDate3);
            System.out.println();
    
            //获取时间各详情值的API
            System.out.println("获取LocalDate1 (" + localDate1 + ") 的详情值");
            int year = localDate1.getYear();
            System.out.println("getYear() --> " + year);
            int monthValue = localDate1. getMonthValue() ;
            System.out.println("getMonthValue() --> " + monthValue);
            int dayOfMonth = localDate1.getDayOfMonth();
            System. out. println("getDay0fMonth() --> " + dayOfMonth);
            int dayOfYear = localDate1. getDayOfYear() ;
            System.out. println("getDayOfYear() --> " + dayOfYear);
            int dayOfWeekValue = localDate1.getDayOfWeek().getValue();
            System.out.println("getDay0fWeek() .getValue() -->"+ dayOfWeekValue);
            boolean isLeapYear = localDate1.isLeapYear();//判断是否是闰年
            System.out.println("isLeapYear() --> " + isLeapYear);
            int lengthOfMonth = localDate1.lengthOfMonth() ;
            System.out.println("lengthOfMonth() --> " + lengthOfMonth);
            int lengthOfYear = localDate1.lengthOfYear();
            System.out.println("lengthOfYear() -->"+ lengthOfYear);
            System.out.println();
    
    
            //调用with前缀方法修改某些字段的值
            //原对象：LocalDate3（2003-07-15）
            //期望值：年份改为2009
            LocalDate result;
            result = localDate3.withYear(2009);
            System.out.println("将localDate3（"+ localDate3 +"）的【年份】改为 2009："+result);
            //期望值：月份改为5
            result = localDate3.withMonth(5);
            System.out.println("将localDate3（"+ localDate3 +"）的【月份】改为 5："+result);
            //期望值：当月的第几天23
            result = localDate3.withDayOfMonth(23);
            System.out.println("将localDate3（"+ localDate3 +"）的【当月的第几天】改为 23："+result);
            //期望值：全年的第几天25
            result = localDate3.withDayOfYear(25);
            System.out.println("将localDate3（"+ localDate3 +"）的【全年的第几天】改为 35："+result);
            System.out.println();
    
            //通过plus和minus前缀的方法增加和减少某些字段的值
            System.out.println("通过plus和minus前缀的方法增加和减少某些字段的值");
            result = localDate3.plusYears(2);
            System.out.println("将localDate3（"+localDate3+")的【年份】【增加】 2："+result);
            System.out.println();
    
            //通过with()方法的得到相关的LocalDate对象
            System.out.println("通过with()方法得到相关的LocalDate对象");
            result = localDate2.with(TemporalAdjusters.firstDayOfMonth());
            System.out.println("获取localDate2（"+localDate2+")的相关【该月的第1天 / firstDayOfMonth】:"+result);
            System.out.println();
    
            //基于当前LocalDate对象创建LocalDateTime对象
            LocalDateTime localDateTime;
            localDateTime = localDate2.atStartOfDay();
            System.out.println("基于localDate2（"+localDate2+"）使用atStartOfDay()【一天的开始】得到localDateTime对象："+localDateTime);
            localDateTime = localDate2.atTime(9, 54);
            System.out.println("基于localDate2（"+localDate2+"）atTime(9,54)得到localDateTime对象："+localDateTime);
    
            
        }
    }

## LocalTime类 ##

### 5.6 创建LocalTime对象 ###

创建LocalTime对象的方式与创建LocalDate非常相似，例如:

*  LocalTime localTime = LocalTime.now() ;
 *  LocalTime localTime = LocalTime.of(10，15，30) ;
 *  LocalTime localTime = LocalTime.parse(“10:15:30”) ;

### 5.7 LocalTime的常用API ###

修改各详情值

*  public LocalTime withHour (int hour)
 *  public LocalTime withMinute (int minute)
 *  public LocalTime withSecond(int second)
 *  public LocalTime withNano (int nanoOfSecond) **//纳秒**

注意: LocalTime对象不可变，以上API均返回新的对象

对各详情值进行增加、减去

*  public LocalTime plusHours (long hour sToAdd)
 *  public LocalTime minusHours (long hour sToSubtract)
 *  public LocalTime plusMinutes (long minutesToAdd)
 *  public LocalTime minusMinutes (long mi nutesToSubtract)
 *  public LocalTime plusSeconds (long secondsToAdd)
 *  public LocalTime minusSeconds (long secondsToSubtract)
 *  public LocalTime plusNanos (long nanosToAdd)
 *  public LocalTime minusNanos (long nanosToSubtract)

注意: LocalTime对象不可变，以上API均返回新的对象

结合LocalDate创建LocalDateTime对象

*  public LocalDateTime atDate (LocalDate date)

### 5.8 关于LocalTime的小结 ###

*  你可以直接获取当前时间对应的LocalTime对象，也可以通过时、分、秒的数值，或通过符合HH:mm:ss模式的字符串来创建LocalTime对象
 *  通过get前缀的方法可以获取各详情值
 *  通过with前缀的方法可以修改详情值中的某个值，将得到新的LocalTime对象
 *  通过with()方法可以获取某些相关LocalTime对象
 *  通过plus /minus前缀的方法可以对某个详情值进行增加/减去的操作，将得到新的LocalTime对象
 *  通过atDate ()方法可以结合LocalDate对象以创建LocalDateTime对象

## LocalDateTime类 ##

Local DateTime本质上是**基于LocalDate和LocalTime这2个对象所创建出来的新对象**，例如，当调用now()方法创建当前日期时间的对象时，本质上最终执行了以下方法:  
![在这里插入图片描述][889a7d71117c4fdebbe3a25a90f85fe8.png]

### 5.10创建LocalDateTime对象 ###

创建LocalDateTime对象的方式与LocalDate / LocalTime非常相似，例如:  
`LocalDateTime localDateTime = LocalDateTime.now() ;`  
`LocalDateTime localDateTime = LocalDateTime.of(2021，8，16，10， 15，30) ;`  
`LocalDateTime localDateTime = LocalDateTime.parse("2021-08-16T10:15:30") ;`

### 5.11 LocalDateTime的API ###

LocalDate、LocalTime 可实现的功能，LocalDateTime均可以实现

*  在LocalDateTime内部，有LocalDate和LocalTime这2个对象
 *  相关API是直接调用LocalDate / LocalTime的APl实现的

![在这里插入图片描述][8ac8e954eabf4bf4809a5a8266ec2268.png]  
还可以从LocalDateTime中获取LocalDate、LocalTime的对象:

*  public LocalDate toLocalDate ()
 *  public LocalTime toLocalTime ()

将LocalDateTime转换为时间戳的操作略复杂一些，你必须先设置时区信息,才可以获取long类型的时间戳，例如:  
`long time = LocalDateTime.now ().toInstant (ZoneOffset.of ("+8") ) . toEpochMilli () ;`

### 5.12 LocalDateTime的小结 ###

*  LocalDateTime是通过LocalDate和LocalTime实现的，它可以实现LocalDate和LocalTime中已实现的所有操作
 *  先熟练掌握LocalDate和LocalTime的使用，再学习LocalDateTime,则可以“无师自通”

# 6.关于DateTimeFormatter类 #

DateTimeFormatter是Java 8新增的用于对日期、时间进行格式化的类  
Da teTimeFormatter是线程安全的

*  不建议再使用SimpleDateFormat处理日期时间与字符串的转换

## 6.1获取DateTimeFormatter对象 ##

DateTimeFormatter仅有1个默认权限的构造方法，则我们**无法使用构造方法创建对象;**  
调用DateTimeFormatter的ofPattern()静态方法可以应用模式字符串，并创建DateTimeFormatter对象  
`DateTimeFormatter formatter = DateTimeFormatter.ofPattern ("yyyy-MM-dd HH:mm:ss") ;`

## 6.2 格式化日期时间 ##

调用DateTimeFormatter的**format ()方法**即可对日期、时间进行格式化

*  public String format (TemporalAccessor temporal)
 *  该方法的参数类型是TemporalAccessor, LocalDateTime、 LocalDate、LocalTime均实现了TemporalAccessor的子级接口 Temporal

也就是说，在DateTimeFormatter、LocalDateTime、 LocalDate、LocalTime这4个类中都有**format ()方法**

*  在DateTimeFormatter的format ()方法中，参数可以是LocalDateTime、LocalDate、LocalTime对象
 *  在LocalDateTime、LocalDate、 LocalTime的format()方法中，参数是DateTimeFormatter对象

## 6.3将字符串格式的日期时间转换为对象 ##

与**SimpleDateFormat**可实现的功能一样， DateTimeFormatter也可以将字符串格式的日期、时间转换为对象

*  public TemporalAccessor parse (CharSequence text)
 *  不建议使用，处理结果比较复杂 这个方法就是介绍一下，但是用起来很复杂不建议用

建议将将字符串格式的日期时间转换为对象时使用下面这种方法  
此前使用LocalDateTime、 LocalDate、 LocalTime时，通过静态的parse () 方法创建对象也是基于DateTimeFormatter的parse ()方法实现的，例如:  
![在这里插入图片描述][145549ff52ba40cb9e615b0565c0cce4.png]

## 6.4获取DateTimeFormatter对象—补充 ##

DateTimeFormatter提供了一些静态属性，本身就是DateTimeFormatter对象，已应用特定的模式字符串，但不一定符合你的需求:  
![在这里插入图片描述][1cc39a1bb29c46ba95911c3591abb6d6.png]

## 6.5DateTimeFormatter小结+代码 ##

*  DateTimeFormatter是Java 8新增的类，用于实现日期时间与字符串的转换, 它是线程安全的  
    \-你可以把它声明为全局变量，甚至使用stati c修饰
 *  你可以使用DateTimeFormatter的静态属性得到对象，但这些对象的模式字符串格式不一定符合你的需求，你也可以通过ofPattern()方法定义模式字符串并得到DateTimeFormatter对象
 *  调用format ()方法可以将日期时间转换为字符串
    
     *  你还也可以调LocalDateTime、LocalDate、 LocalTime的format ()方法
 *  调用parse ()方法可以将字符串转换为日期时间的对象，不推荐
    
     *  推荐使用LocalDateTime、LocalDate、 LocalTime对象时使用的parse ()方法，更加简便，也是基于DateTimeFormatter的parse ()方法实现的

[376c4f0fff3844fb8840751e5c62ef96.png]: https://img-blog.csdnimg.cn/376c4f0fff3844fb8840751e5c62ef96.png
[54651451c1b743baa96ef4e0579fb5bc.png]: https://img-blog.csdnimg.cn/54651451c1b743baa96ef4e0579fb5bc.png
[22d41175e87440f98fa29c034c25c824.png]: https://img-blog.csdnimg.cn/22d41175e87440f98fa29c034c25c824.png
[889a7d71117c4fdebbe3a25a90f85fe8.png]: https://img-blog.csdnimg.cn/889a7d71117c4fdebbe3a25a90f85fe8.png
[8ac8e954eabf4bf4809a5a8266ec2268.png]: https://img-blog.csdnimg.cn/8ac8e954eabf4bf4809a5a8266ec2268.png
[145549ff52ba40cb9e615b0565c0cce4.png]: https://img-blog.csdnimg.cn/145549ff52ba40cb9e615b0565c0cce4.png
[1cc39a1bb29c46ba95911c3591abb6d6.png]: https://img-blog.csdnimg.cn/1cc39a1bb29c46ba95911c3591abb6d6.png