Java最全Java8日期时间API，靠着这份面试题跟答案

本文链接：https://blog.csdn.net/2401_84585205/article/details/138654141

最后希望可以帮助到大家！

千千万万要记得：多刷题！！多刷题！！

之前算法是我的硬伤，后面硬啃了好长一段时间才补回来，算法才是程序员的灵魂！！！！

篇幅有限，以下只能截图分享部分的资源！！

（1）多线程（这里以多线程为代表，其实整理了一本JAVA核心架构笔记集）

（2）刷的算法题（还有左神的算法笔记）

（3）面经+真题解析+对应的相关笔记（很全面）

（4）视频学习（部分）

ps：当你觉得学不进或者累了的时候，视频是个不错的选择

在这里，最后只一句话：祝大家offer拿到手软！！

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

新的日期时间 API 是线程安全的。不仅没有 setter 方法，而且任何对实例的变更都会返回一个新的实例，保证原来的实例不变。
新的日期时间 API 提供了大量的方法，用于修改日期时间的各个部分，并返回一个新的实例。
借鉴了第三方日期时间库joda很多的优点。
在时区方面，新的日期时间 API 引入了域 ( domain ) 这个概念。

同时 Java 8 还针对原来复杂的 API 进行重新组合和拆分，分成了好多个类。

关于时间和时区

GMT和UTC

GMT，即格林尼治标准时间，也就是世界时。GMT的正午是指当太阳横穿格林尼治子午线（本初子午线）时的时间。但由于地球自转不均匀不规则，导致GMT不精确，现在已经不再作为世界标准时间使用。

UTC，即协调世界时。是经过平均太阳时(以格林威治时间 GMT 为准)、地轴运动修正后的新时标，以「秒」为单位的国际原子时所综合精算而成的时间。为确保UTC与GMT相差不会超过0.9秒，在有需要的情况下（例如 1998-12-31T23:59:60Z）会在UTC内加上正或负闰秒。协调世界时区会使用 “Z” 来表示，协调世界时也会被称为 “Zulu time”。UTC现在作为世界标准时间使用。

所以，UTC与GMT基本上等同，误差不超过0.9秒。不过日常使用中，GMT 与 UTC 的功能与精确度是没有差别的。

时区

时区作为地理概念，表示 “遵守统一时间标准的一个地区”。

使用与 UTC 的偏移来表示时区，例如：中国所在时区为 UTC+08:00（又称为 Chinese Standard Time，即 “中国标准时间”）

地球自西向东旋转，东边比西边先看到太阳，东边的时间也比西边的早。为了统一世界的时间，1884年的国际经度会议规规定将全球划分为24个时区（东、西各12个时区）。规定英国（格林尼治天文台旧址）为零时区（基准 UTC），东1-12区，西1-12区，中国北京处于东8区（UTC+08:00），那么我们的时间会领先基准-也就是我们在早上 9 点时，伦敦是早上 1 点。

Unix时间戳

计算机中的Unix时间戳，使用自 1970-01-01T00:00:00Z（Z 即表示 UTC 时间）至今的毫秒差作为表示时间的数值，并且移除期间的“闰秒”（例如 1998-12-31T23:59:60Z），这么做当然是为了简化计算机对时间操作的复杂度。Unix 时间体系中，每天固定 86400 秒，这个时间是绝对公立的，它和时区没有任何关系。

Java 中的 Unix 时间

Java 确保：每天 24 小时、每小时 60 分、每分钟 60 秒。

Java 中获取 “当前” 时间的方法，其底层实现，全部由 java.lang.System.currentTimeMillis() 提供自 UTC 1970-01-01T00:00:00 的毫秒数。java.lang.System.currentTimeMillis() 作为 native 方法，其实现与 JVM 所在的机器相关（通常使用 NTP 协议保持更新）。

LocalDate、LocalTime、LocalDateTime

java.time.LocalDate 用于表示 “本地日期”，无 “时间”。LocalDate 不承载时区信息。

java.time.LocalTime 用于表示 “本地时间”，无 “日期”。LocalTime 不承载时区信息。

java.time.LocalDateTime 用于表示 “本地日期与时间”。LocalDateTime 不承载时区信息。

LocalDate 实例与 LocalTime 实例能够共同构建 LocalDateTime 实例，由 LocalDateTime 实例能够获取 LocalDate 实例与 LocalTime 实例。

由于 LocalDateTime 不承载时区信息，因此，其不能与 Instant 相互转换，必须提供时区信息。

获取对象的方法

获取对象的方法：

通过静态方法 ：now()（获取的时间是系统当前的时间）
通过静态方法：of()（方法参数可以指定时间）

@Test

public void test01() {

/* 通过静态方法 now() 返回该类的实例 */

//获取当前的日期时分秒

LocalDateTime now = LocalDateTime.now();

System.out.println(now);

//获取当前的日期

LocalDate now1 = LocalDate.now();

System.out.println(now1);

//获取当前的时分秒

LocalTime now2 = LocalTime.now();

System.out.println(now2);

System.out.println(“=========================================”);

/* 静态方法 of() 返回该类的实例 */

//指定日期时分秒

LocalDateTime localDateTime = LocalDateTime.of(2048, 11, 25, 12, 00, 30);

System.out.println(localDateTime);

//指定日期

LocalDate date = LocalDate.of(2020, 12, 12);

System.out.println(date);

//指定时分秒

LocalTime time = LocalTime.of(14, 20, 30);

System.out.println(time);

}

输出结果

2020-12-12T16:02:30.502

2020-12-12

16:02:30.502

=========================================

2048-11-25T12:00:30

2020-12-12

14:20:30

常用方法

与获取相关的方法(get系类的方法)

getYear()：获取年
getHour()：获取小时
getMinute()：获取分钟
getSecond()：获取秒值
getDayOfMonth()：获得月份天数(1-31)
getDayOfYear()：获得年份天数(1-366)
getDayOfWeek()：获得星期几(返回一个 DayOfWeek枚举值)
getMonth()：获得月份(返回一个 Month 枚举值)
getMonthValue()：获得月份(1-12)
getYear()：获得年份

@Test

public void test02() {

//获取日期时分秒

LocalDateTime now = LocalDateTime.now();

//获取年份

int year = now.getYear();

System.out.println(year);

//获取月份枚举

//Month 枚举类，定义了十二个月份

Month month = now.getMonth();

System.out.println(month);

//获取月份的数值

int monthValue = now.getMonthValue();

System.out.println(monthValue);

//获取当天在本月的第几天

int dayOfMonth = now.getDayOfMonth();

System.out.println(dayOfMonth);

//获取小时

int hour = now.getHour();

System.out.println(hour);

//获取分钟

int minute = now.getMinute();

System.out.println(minute);

//获取秒值

int second = now.getSecond();

System.out.println(second);

}

输出结果

2020

DECEMBER

转换的方法

toLocalDate()：将LocalDateTime转换为相应的LocalDate对象
toLocalTime()：将LocalDateTime转换为相应的LocalTime对象

@Test

public void test04() {

//获取当前年月日，时分秒

LocalDateTime now = LocalDateTime.now();

System.out.println(now);

//将LocalDateTime转换为相应的LocalDate对象

LocalDate localDate = now.toLocalDate();

System.out.println(localDate);

//将LocalDateTime转换为相应的LocalTime对象

LocalTime localTime = now.toLocalTime();

System.out.println(localTime);

}

输出结果

2020-12-12T16:07:23.045

2020-12-12

16:07:23.045

判断的方法

isAfter()：判断一个日期是否在指定日期之后
isBefore()：判断一个日期是否在指定日期之前
isEqual()：判断两个日期是否相同
isLeapYear()：判断是否是闰年（注意是LocalDate类和 LocalDateTime类特有的方法）

@Test

public void test05() {

//获取当前的日期

LocalDate now = LocalDate.now();

//指定的日期

LocalDate of = LocalDate.of(2015, 12, 12);

//判断一个日期是否在另一个日期之前

boolean before = of.isBefore(now);

System.out.println(before);

//判断一个日期是否在另一个日期之后

boolean after = of.isAfter(now);

System.out.println(after);

//判断这两个日期是否相等

boolean after1 = now.equals(of);

System.out.println(after1);

//判断闰年

boolean leapYear = of.isLeapYear();

System.out.println(leapYear);

}

输出结果

true

false

增减年月日时分秒的方法（plus/minus系列的方法）

增加相关的方法

plusYears(int offset)：增加指定年份
plusMonths(int offset)：增加指定月份
plusWeeks(int offset)：增加指定周
plusDates(int offset)：增加指定日
plusHours(int offset)：增加指定时
plusMinuets(int offset)：增加指定分
plusSeconds(int offset)：增加指定秒
plusNanos(int offset)：增加指定纳秒

减少相关的方法

minusYears(int offset)：减少指定年
minusMonths(int offset)：减少指定月
minusWeeks(int offset)：减少指定周
minusDates(int offset)：减少指定日
minusHours(int offset)：减少指定时
minusMinuets(int offset)：减少指定分
minusSeconds(int offset)：减少指定秒
minusNanos(int offset)：减少指定纳秒

@Test

public void test07() {

//增加时间量的方法 plusXXX系类的方法返回的是一个新的日期对象

LocalDateTime now = LocalDateTime.now();

System.out.println(now);

//可以给当前的日期增加时间量

LocalDateTime newDate = now.plusYears(1);

int year = newDate.getYear();

System.out.println(year);

System.out.println(“================================”);

//减去时间量的方法minusXXX 系列的方法返回的是一个新的日期对象

LocalDate now1 = LocalDate.now();

System.out.println(now1);

LocalDate newDate2 = now1.minusDays(10);

int dayOfMonth = newDate2.getDayOfMonth();

System.out.println(dayOfMonth);

}

输出结果

2020-12-12T16:12:43.228

2021

================================

2020-12-12

指定年月日时分秒的方法

with(TemporalAdjuster adjuster):指定特殊时间
withYear(int year):指定年
withDayOfYear(int dayOfYear):指定日
withMonth(int month):指定月
withDayOfMonth(int dayOfMonth):指定日

@Test

public void test08() {

//指定某个日期的方法 with()方法

LocalDate now2 = LocalDate.now();

System.out.println(now2);

LocalDate localDate = now2.withYear(2014);

System.out.println(localDate);

// TemporalAdjusters工具类，提供了一些获取特殊日期的方法

LocalDate with = now2.with(TemporalAdjusters.firstDayOfMonth());

System.out.println(with);

LocalDate with1 = now2.with(TemporalAdjusters.firstDayOfNextMonth());

System.out.println(with1);

//获取这个月的第几个星期几是几号,比如 TemporalAdjusters.dayOfWeekInMonth(2, DayOfWeek.FRIDAY)

// 代表的意思是这个月的第二个星期五是几号

LocalDate with2 = now2.with(TemporalAdjusters.dayOfWeekInMonth(2, DayOfWeek.FRIDAY));

System.out.println(with2);

}

输出结果

2020-12-12

2014-12-12

2020-12-01

2021-01-01

2020-12-11

将日期格式化为字符串的方法

format()：格式化字符串

@Test

public void test03() {

//获取当前日期时分秒

LocalDateTime now = LocalDateTime.now();

//默认格式年-月-日T时:分:秒

System.out.println(now);

//指定格式

DateTimeFormatter ofPattern = DateTimeFormatter.ofPattern(“yyyy年MM月dd日 HH时mm分ss秒”);

//传入格式

String dateStr = now.format(ofPattern);

System.out.println(dateStr);

}

输出结果

2020-12-12T16:06:12.705

2020年12月12日 16时06分12秒

解析字符串为日期时间的方法

paser(String str)：将一个日期字符串解析成日期对象,注意字符串日期的写法的格式要正确,否则解析失败
paser(String str, DateTimeFormatter formatter)：将字符串按照参数传入的格式进行解析

@Test

public void test06() {

//给出一个符合默认格式要求的日期字符串

String dateStr = “2020-01-01”;

//把日期字符串解析成日期对象如果日期字符串时年月日解析时用 LocalDate

LocalDate parse = LocalDate.parse(dateStr);

System.out.println(parse);

System.out.println(“===========================================”);

//给出一个符合默认格式要求的时分秒字符串

String dateTimeStr = “14:20:30”;

//把时分秒字符串解析成时分秒对象

LocalTime parse1 = LocalTime.parse(dateTimeStr);

System.out.println(parse1);

System.out.println(“=========================================”);

//给出一个符合默认格式要求的日期时分秒字符串

String str = “2018-12-12T14:20:30”;

//把日期时分秒字符串解析成时分秒对象

LocalDateTime parse2 = LocalDateTime.parse(str);

System.out.println(parse2);

System.out.println(“========================================”);

//给出一个自定义日期时分秒格式字符串

String dateStr2 = “2020年12月12日 12:13:14”;

//给出一个自定义解析格式

DateTimeFormatter formatter = DateTimeFormatter.ofPattern(“yyyy年MM月dd日 HH:mm:ss”);

//按照指定的格式去解析

LocalDateTime parse3 = LocalDateTime.parse(dateStr2, formatter);

System.out.println(parse3);

}

输出结果

2020-01-01

===========================================

14:20:30

=========================================

2018-12-12T14:20:30

========================================

2020-12-12T12:13:14

TemporalAdjuster接口 - 时间调节器

前面看到的所有日期操作都是相对比较直接的。有的时候，你需要进行一些更加灵活复杂的操作，比如，将日期调整到下个周日、下个工作日，或者是本月的最后一天。这时，就需要时间调节器 TemporalAdjuster，可以更加灵活地处理日期。TemporalAdjusters 工具提供了一些通用的功能，并且你还可以新增你自己的功能。

@Test

public void testTemporalAdjuster() {

LocalDate now = LocalDate.now();

//指定日期

//对于一些特殊的日期，可以通过一个工具类TemporalAdjusters 来指定

//见名知意，本月第一天

TemporalAdjuster temporalAdjuster = TemporalAdjusters.firstDayOfMonth();

LocalDate with = now.with(temporalAdjuster);

System.out.println(with);

//下周周末

TemporalAdjuster next = TemporalAdjusters.next(DayOfWeek.SUNDAY);

LocalDate with1 = now.with(next);

System.out.println(with1);

System.out.println(“===================================”);

LocalDate now1 = LocalDate.now();

//自定义日期 - 下一个工作日

LocalDate with2 = now1.with(new TemporalAdjuster() {

@Override

//参数 nowDate 当前的日期对象

public Temporal adjustInto(Temporal nowDate) {

//向下转型

LocalDate date = (LocalDate) nowDate;

if (date.getDayOfWeek().equals(DayOfWeek.FRIDAY)) {

LocalDate localDate = date.plusDays(3);

return localDate;

} else if (date.getDayOfWeek().equals(DayOfWeek.SATURDAY)) {

LocalDate localDate = date.plusDays(2);

return localDate;

} else {

LocalDate localDate = date.plusDays(1);

return localDate;

}

});

System.out.println(“下一个工作日是：” + with2);

}

输出结果

2020-12-01

2020-12-13

===================================

下一个工作日是：2020-12-14

Duration类 - 用于计算两个“时间”间隔的类

Duration 表示一个时间段，Duration 包含两部分：seconds 表示秒，nanos 表示纳秒，它们的组合表达了时间长度。

因为 Duration 表示时间段，所以 Duration 类中不包含 now() 静态方法。注意，Duration 不包含毫秒这个属性。

Duration只能处理两个LocalTime, LocalDateTime, ZonedDateTime; 如果传入的是LocalDate，将会抛出异常

常用API：

静态方法 between()：计算两个时间的间隔，默认是秒
toDays()：将时间转换为以天为单位的
toHours()：将时间转换为以时为单位的
toMinutes()：将时间转换为以分钟为单位的
toMillis()：将时间转换为以毫秒为单位的
toNanos()：将时间转换为以纳秒为单位的

@Test

public void test10() {

//计算时间的间隔

Instant start = Instant.now();

for (int i = 0; i < 100000; i++) {

// System.out.println(i);

}

Instant end = Instant.now();

Duration duration = Duration.between(start, end);

long l = duration.toNanos();

//间隔的时间

System.out.println(“循环耗时：” + l + “纳秒”);

}

输出结果

循环耗时：1000000纳秒

Period类 - 用于计算两个“日期”间隔的类

Period 在概念上和 Duration 类似，区别在于 Period 是以年月日来衡量一个时间段。Duration 用于计算两个时间间隔，Period 用于计算两个日期间隔，所以 between() 方法只能接收 LocalDate 类型的参数。

静态方法 between()：计算两个日期之间的间隔
getYears()：获取年份
getMonths()：获取月份
getDays()：获取天数

@Test

public void test11() {

//计算两个日期的间隔

LocalDate birthday = LocalDate.of(2012, 12, 12);

LocalDate now = LocalDate.now();

//我从出生到现在，有多少岁，零几个月，几天

//计算两个日期的间隔

Period between = Period.between(birthday, now);

int years = between.getYears();

int months = between.getMonths();

int days = between.getDays();

System.out.println(“玛雅人的地球都消灭了” + years + “年” + months + “月” + days + “天了…”);

}

输出结果

玛雅人的地球都消灭了8年0月0天了…

Instant 时间戳类

java.time.Instant 时间线上的一个瞬时点，承载纳秒级精度的 Unix 时间戳，其 String toString() 方法基于 ISO-8601 进行格式化。Instant 不承载时区信息。

获取对象的方法：now()：注意默认获取出来的是默认时区，和我们相差八个小时（因为我们在东八时区）

设置偏移量的方法：atOffset()

获取系统默认时区时间的方法：atZone()：方法的参数是要一个时区的编号(可以通过时区编号类获取ZonedDateTime类的对象)

get系列的方法

getEpochSecond()：获取从1970-01-01 00:00:00到当前时间的秒值
toEpochMilli()：获取从1970-01-01 00:00:00到当前时间的毫秒值
getNano()：把获取到的当前时间的秒数 换算成纳秒

ofEpoch系列方法

ofEpochSecond()：给计算机元年增加秒数
ofEpochMilli()：给计算机元年增加毫秒数

@Test

public void test09() {

// Instant 时间戳类从1970 -01 - 01 00:00:00 截止到当前时间的毫秒值

Instant now = Instant.now();

System.out.println(now); //获取的是默认时区，获取的不是中国的时区

//获取当前时区的，我们可以添加偏移量,返回偏移过后的日期

OffsetDateTime offsetDateTime = now.atOffset(ZoneOffset.ofHours(8));

System.out.println(offsetDateTime);

System.out.println(“===========================”);

//从1970 - 01 - 01 00:00:00 截止到当前时间的毫秒值

long l = System.currentTimeMillis();

System.out.println(l);

long time = new Date().getTime();

System.out.println(time);

//JDK1.8 Instant 时间戳类从1970 -01 - 01 00:00:00 截止到当前时间的毫秒值

Instant now1 = Instant.now();

//toEpochMilli():从1970 -01 - 01 00:00:00 截止到当前时间间隔的毫秒值

long l1 = now1.toEpochMilli();

System.out.println(l1);

//获取从1970 -01 - 01 00:00:00 截止到当前时间间隔的秒值

long epochSecond = now1.getEpochSecond();

System.out.println(epochSecond);

System.out.println(“==========================”);

//给计算机元年增加相应的时间量

Date date = new Date(1000 * 60 * 60 * 24);

System.out.println(date);

//现在给计算机元年增加相应的时间量

//5. ofEpochSecond() 方法给计算机元年增加秒数

//ofEpochMilli() 给计算机元年增加毫秒数

Instant instant = Instant.ofEpochMilli(1000 * 60 * 60 * 24);

System.out.println(instant);

//ofEpochSecond() 方法给计算机元年增加秒数

Instant instant1 = Instant.ofEpochSecond(60 * 60 * 24);

System.out.println(instant1);

}

输出结果

2020-12-12T08:48:46.480Z

2020-12-12T16:48:46.480+08:00

===========================

1607762926539

1607762926540

1607762926

==========================

Fri Jan 02 08:00:00 CST 1970

1970-01-02T00:00:00Z

Clock - 时钟系统

Clock 是时钟系统，用于查找当前时刻。你可以用它来获取某个时区下当前的日期或者时间。可以用 Clock 来替代旧的 System.currentTimeInMillis() 与 TimeZone.getDefault() 方法。

@Test

public void testClock() {

//系统默认时间

Clock clock = Clock.systemDefaultZone();

System.out.println(clock.instant().toString());

//世界协调时UTC

Clock clock1 = Clock.systemUTC();

//通过Clock获取当前时刻

System.out.println(“当前时刻为：” + clock1.instant());

//获取clock对应的毫秒数，与System.currentTimeMillis()输出相同

System.out.println(clock1.millis());

System.out.println(System.currentTimeMillis());

System.out.println(new Date(System.currentTimeMillis()).toString());

//在clock基础上增加6000秒，返回新的Clock

Clock clock2 = Clock.offset(clock1, Duration.ofSeconds(6000));

Docker步步实践

目录文档：

①Docker简介

②基本概念

③安装Docker

④使用镜像：

⑤操作容器：

⑥访问仓库：

⑦数据管理：

⑧使用网络：

⑨高级网络配置：

⑩安全：

⑪底层实现：

⑫其他项目：

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

.println(clock.instant().toString());

//世界协调时UTC

Clock clock1 = Clock.systemUTC();

//通过Clock获取当前时刻

System.out.println(“当前时刻为：” + clock1.instant());

//获取clock对应的毫秒数，与System.currentTimeMillis()输出相同

System.out.println(clock1.millis());

System.out.println(System.currentTimeMillis());

System.out.println(new Date(System.currentTimeMillis()).toString());

//在clock基础上增加6000秒，返回新的Clock

Clock clock2 = Clock.offset(clock1, Duration.ofSeconds(6000));

Docker步步实践

目录文档：

[外链图片转存中…(img-Y3xmqR2E-1715307758004)]

[外链图片转存中…(img-hCpGaAVV-1715307758005)]

①Docker简介

②基本概念

③安装Docker

[外链图片转存中…(img-1nVk9zk9-1715307758005)]

④使用镜像：

[外链图片转存中…(img-VLzMNBsz-1715307758006)]

⑤操作容器：

[外链图片转存中…(img-8AfPGV4b-1715307758006)]

⑥访问仓库：

[外链图片转存中…(img-e1IXogdN-1715307758006)]

⑦数据管理：

[外链图片转存中…(img-QCbMODSX-1715307758007)]

⑧使用网络：

[外链图片转存中…(img-EluAPZN8-1715307758007)]

⑨高级网络配置：

[外链图片转存中…(img-kLcWOcbW-1715307758008)]

⑩安全：

[外链图片转存中…(img-CkA23dGr-1715307758008)]

⑪底层实现：

[外链图片转存中…(img-7ZAnoPbw-1715307758009)]

⑫其他项目：

[外链图片转存中…(img-GDFxed2P-1715307758009)]

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取