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

没反应说说说

已于 2023-02-12 22:05:11 修改

阅读量898

点赞数 1

分类专栏： Java 文章标签： java jvm 开发语言

于 2023-02-06 16:24:43 首次发布

本文链接：https://blog.csdn.net/mfysss/article/details/128891183

版权

Java 专栏收录该内容

51 篇文章 0 订阅

订阅专栏

本文详细介绍了Java中处理日期和时间的各种类，包括Date类的使用，如创建、获取时间戳、对比时间先后；Calendar类的获取、设置、转换以及与时间戳、Date的交互；SimpleDateFormat类的日期格式化及线程安全问题；Java8引入的新类LocalDate、LocalTime、LocalDateTime的创建、API使用，以及DateTimeFormatter的线程安全格式化功能。

摘要由CSDN通过智能技术生成

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

在这里插入图片描述
你还可以调用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月

模式字符串表
在这里插入图片描述
一般，会这样定义模式字符串

//设计模式字符串
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设置时间值，可能有多个线程同时执行这条语句，导致当前线程的时间值被其他线程修改：
在这里插入图片描述
线程不安全的解决方案

不要将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()方法创建当前日期时间的对象时，本质上最终执行了以下方法:
在这里插入图片描述

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实现的

在这里插入图片描述
还可以从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 ()方法实现的，例如:
在这里插入图片描述

6.4获取DateTimeFormatter对象—补充

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

6.5DateTimeFormatter小结+代码

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