JAVA8时间处理类全解

已于 2023-07-04 14:55:30 修改
阅读量207 收藏
点赞数 1
分类专栏： JavaSE/EE程序 文章标签： java
于 2023-07-04 14:53:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27890899/article/details/131534909
版权

文章目录


https://docs.oracle.com/javase/8/docs/api/

LocalDate（日期）+ LocalTime(时间) = LocalDateTime

ZoneOffset(时差) + LocalDateTime(日期时间) + ZoneId(时区) = ZonedDateTime

ZoneOffset(时差) + LocalDateTime(日期时间) = OffsetDateTime

Pried(较长时间) Duration（较短时间） Instant Clock MonthDay

LocalDate

//获取当前日期
//不包含时区、时分秒信息
//输入结果为标准的yyyy-MM-dd格式
System.out.println(LocalDate.now());
//获取特定日期
System.out.println(LocalDate.of(1994,3,22));
System.out.println(LocalDate.of(1994, Month.MARCH, 22));
//获取时间分量
LocalDate now = LocalDate.now();
//年月日
int year1 = now.getYear();
int year2 = now.get(ChronoField.YEAR);
System.out.println(year2);
//year的范围 不存在公元0年 LocalDate中0表示公元-1年，-1表示公元-2年...
System.out.println(now.range(ChronoField.YEAR));
//当月的天数
System.out.println(now.range(ChronoField.DAY_OF_MONTH));
Month month = now.getMonth();
int monthValue = now.getMonthValue();
System.out.println("MONTH_OF_YEAR:" + now.get(ChronoField.MONTH_OF_YEAR));
int dayOfYear = now.getDayOfYear();
int dayOfMonth = now.getDayOfMonth();
DayOfWeek dayOfWeek = now.getDayOfWeek();
//1为每周的第一天
System.out.println(now.getDayOfWeek().getValue());
System.out.println(year1 + " " + month + " " + monthValue + " "+ dayOfYear + " " + dayOfMonth + " " +dayOfWeek);
//获取当月的天数
System.out.println(now.lengthOfMonth());
//获取当年的天数
System.out.println(now.lengthOfYear());
//判断是否为闰年
System.out.println(now.isLeapYear());
//判断是公元年前还是公元后
System.out.println(now.getEra());
//计算当日与1970-01-01相差的天数 
System.out.println(now.toEpochDay());
//计算与公元0年（公元前1年）相差的天数
System.out.println(now.getLong(ChronoField.PROLEPTIC_MONTH));
//LocalDate并不是支持所有的时间分量枚举值 可以用now.isSupported()判断
System.out.println(now.isSupported(ChronoField.PROLEPTIC_MONTH));
//时间分量的修改
//修改月份 LocalDate是不可变量 修改后需要用新的变量引用
LocalDate now1 = LocalDate.now();
LocalDate localDate = now1.withMonth(8);
System.out.println(localDate);
//修改年/月/日为指定的数字
System.out.println(now1.with(ChronoField.MONTH_OF_YEAR, 2));
//增加时间（减少也有相对应的方法）
LocalDate data = LocalDate.now();
//plusXXX()可以填正数也可以填负数 假如data为闰年2月29日，+-一年后为2月28日
System.out.println(data.plusYears(1));
System.out.println(data.plusYears(-1));
System.out.println(data.plus(1, ChronoUnit.YEARS));
//增加一段时间 比如增加1年2个月3天 Period也可以传负数
Period period = Period.of(1,2,3);
System.out.println(data.plus(period));
//时间比较
LocalDate date = LocalDate.of(2022, 3, 24);
//相同历法时间比较是否相等
System.out.println(data.equals(date));
HijrahDate hijrahDate = HijrahDate.of(1430, 6, 27);
//不同历法时间比较是否相等
System.out.println(hijrahDate.isEqual(date));
//比较日期前后关系 可以比较不同历法
System.out.println(data.isAfter(date));
System.out.println(data.isBefore(date));
//明确时间早晚是否相等compareTo() 返回值不能代表具体相差的年份/月份/天数
System.out.println(data.compareTo(date));
//计算时间差
//计算两个日期相差的天数 通过计算两个日期和1970-01-01日相差的天数 再拿天数差计算得到两个日期相差的天数
LocalDate date1 = LocalDate.now();
LocalDate date2 = LocalDate.of(2021, 1, 3);
long l1 = date1.toEpochDay();
long l2 = date2.toEpochDay();
System.out.println(l2 - l1);
//通过until(var 1, var2)方法 可以计算相差的天、年、月
System.out.println(date1.until(date2, ChronoUnit.YEARS));
System.out.println(date1.until(date2, ChronoUnit.MONTHS));
System.out.println(date1.until(date2, ChronoUnit.DAYS));
//通过until()方法 返回Period类对象 PXYXMXD 相差X年X月X天
System.out.println(date2.until(date1));
//得到两个日期相差的所有的日期 datesUntil() 存在重载方法设置步长
Stream<LocalDate> dates = date1.datesUntil(date2, Period.ofDays(2));
Object[] array = dates.toArray();
for(int i=0; i<array.length; ++i){
System.out.println((LocalDate)array[i]);
}
//月日的类 类似的类有YearMonth
MonthDay fromMD = MonthDay.from(date1);
MonthDay ofMD = MonthDay.of(date1.getMonth(), date1.getDayOfMonth());
System.out.println(fromMD.compareTo(ofMD));
//为MonthDay添加年 变为LocalDate对象
LocalDate localDate = ofMD.atYear(2022);
System.out.println(localDate);

LocalTime

//LocaleTime可以记录时分秒纳秒 不包含时区
//创建一个LocalTime对象 默认精确到毫秒
System.out.println(LocalTime.now());//09:09:36.742
//of()方法有四个参数 时、分、秒、纳秒 没有毫秒
System.out.println(LocalTime.of(7, 15));//07:15
//按照一天当中第多少秒创建时间 同样的方法有ofNanoOfDay()
System.out.println(LocalTime.ofSecondOfDay(10000));//02:46:40
//静态属性 NOON表示正午时间 类似属性MIN MAX MIDNIGHT
System.out.println(LocalTime.NOON);//12:00
//获得LocalTime时间分量
LocalTime localTime = LocalTime.now();
//获得小时
System.out.println(localTime.getHour());
//获得分钟
System.out.println(localTime.getMinute());
//获得秒钟
System.out.println(localTime.getSecond());
//获得一天当中现在的秒数
System.out.println(localTime.toSecondOfDay());
//获得纳秒
System.out.println(localTime.getNano());
//获得一天当中现在的纳秒数
System.out.println(localTime.toNanoOfDay());
//获得现在的毫秒数
System.out.println(localTime.get(ChronoField.MILLI_OF_SECOND));
 /**
 * 其他的枚举值：
 * AMPM_OF_DAY 前半天还是后半天。0-11点位前半天，显示为0；12-23为后半天，显示1。
 * HOUR_OF_AMPM 把24小时为周期的点数转换为12小时为周期，比如16点，就会表示为4（范围为0-11）
 * CLOCK_HOUR_OF_AMPM 把24小时为周期的点数转换为12小时为周期，比如16点，就会表示为4（范围为1-12）
 * HOUR_OF_DAY 以24小时为周期的小时数（范围0-23）
 * CLOCK_HOUR_OF_DAY 以24小时为周期的小时数（范围为1-24）
 */
 //修改时间分量类比LocalDate
 //抹去零头
 System.out.println(localTime.truncatedTo(ChronoUnit.SECONDS));//11:34:57
 System.out.println(localTime.truncatedTo(ChronoUnit.MINUTES));//11:35
 //时间的比较
 /**
 * 类比LocalDate类
 * equals():比较两个日期是否是同一天,LocalTime没有isEqual()方法。
 * isBefore():判断参数对象是否早于自身出现
 * isAfter():判断参数对象是否晚于自身出现
 * compareTo():确定两个对象之间的早晚关系（仅有-1、0、1三个返回值）
 * 计算两个LocalTime之间的时间差
 * 使用until()方法，由第2个参数指定时间差的表示单位。
 */

LocalDateTime

//LocalDate + LocatTime = LocalDateTime
//创建对象now() of()
LocalDate ld = LocalDate.now();
LocalTime lt = LocalTime.now();
LocalDateTime localDateTime = LocalDateTime.of(ld, lt);
System.out.println(localDateTime);//2022-09-23T13:55:26.429
//获得时间分量 参考LocalDate和LocalTime
//LocalDateTime类中定义了toLocalDate()和toLocalTime()两个方法，
//这两个方法分别用来获得一个LocalDateTime对象的日期部分和时间部分
//比较两个时间 参考LocalDate和LocalTime
//计算两个参数的时差until() 该方法的第1个参数可以是LocalDateTime类对象，
//也可以是ZonedDateTime类对象

Period

表示以年月日为计时单位的时间段

//以构造的方式创建对象
/**
* 以构造方式创建出的Period对象，除了星期会被自动转换为天以外，
* 年月日之间不会自动完成转换操作。
* 无法计算出一个Period对象具体有多少天。
*/
Period period1 = Period.of(1, 2, 3);
System.out.println(period1);//P1Y2M3D
Period period2 = Period.ofWeeks(3);
System.out.println(period2);//P21D
//以计算的方式计算Period对象
LocalDate l1 = LocalDate.of(2022, 8, 23);
LocalDate l2 = LocalDate.now();
//until()
Period between = Period.between(l1, l2);
System.out.println(between);
//获得Period的所有计数器
List<TemporalUnit> units = between.getUnits();
for(int i=0; i<units.size(); ++i){
System.out.println(units.get(i));//Years Months Days
}
//获得相差时期中的年
System.out.println(between.get(ChronoUnit.YEARS));//2
//获得相差的总月数
System.out.println(between.toTotalMonths());//25
//Period类常用方法
/**
* withYears()/withMonths()/withDays() 修改年/月/日计数器上的值
* plusYears()/plusMonths()/plusDays()/plus() 增加年/月/日计数器上的值
* minusYears()/minusMonths()/minusDays()/minus() 减少年/月/日计数器上的值
* normalized() 规范化时间段格式
* negated() 反转各计数器的值
* multipliedBy() 各个计数器的值倍增
* addTo() 以某个日期为基础向后推一段时间
* subtractFrom() 以某个日期为基础向前推一段时间
* equals() 判断两个Period对象是否相等
* isZero() 判断Period对象是否为0
* isNegative() 判断Period对象是否为负
*/
Period p1 = Period.of(3, 34, 12);
Period p2 = Period.of(3, -34, 12);
System.out.println(p1.normalized());//P5Y10M12D
System.out.println(p2.normalized());//P2M12D
System.out.println(p1.negated());//P-3Y-34M-12D
System.out.println(p2.multipliedBy(2));//P6Y-68M24D

Duration

表示以秒和纳秒为计时单位的时间段，相对于Period来讲，它更加精确。

Duration类中内置了秒和纳秒两个计数器，其中纳秒计数器的合法数值范围是0-999999999，不能为负数。

虽然纳秒计数器上的值不能为负数，但是在使用of()方法创建Duration对象的时候，却可以给表示纳秒的参数传递负数，在实际创建对象过程中，虚拟机会从秒计数器上借1秒修正纳秒计数器上的值为正值。

虽然Duration类只有秒和纳秒两个计数器，但其对象被打印出来却是以“时分秒”的格式来展现的。

//以构造方式创建Duration对象
Duration duration = Duration.ofSeconds(3, -2000);
System.out.println(duration);//PT2.999998S
System.out.println(duration.getNano());//999998000
Duration d1 = Duration.ofSeconds(300000, -2000);
System.out.println(d1);//PT83H19M59.999998S
//以计算方式创建Duration对象
LocalTime lt1 = LocalTime.of(1, 13);
LocalTime lt2 = LocalTime.of(2, 16);
Duration between = Duration.between(lt1, lt2);
System.out.println(between);//PT1H3M
/**
* Duration类常用方法
* getNano() 获得纳秒计数器的值
* getSeconds() 获得秒计数器的值
* get(TemporalUnit unit)获得指定计数器的值，获得不存在计数器的值将会抛出异常。
* toDays() 计算时间段中包含多少天
* toDaysPart() 以天为单位计算时间段零头部分,因为在Duration类中不存在比Day更大的时间单位，
* 所以该方法和toDays()方法一样。
* toHours() 计算时间段中包含多少小时
* toHoursPart() 以小时为单位计算时间段零头部分
* truncatedTo() 抹去零头
* ......
*/
/**
* Duration类在调用toXXX()方法时，如果计算秒或者比秒更大的时间单位，忽略纳秒计数器上的值，
* 而计算比秒更小的时间单位时，纳秒计数器上的值也要参与运算。
*/
/**
* 修改时间分量
* withSeconds() 直接修改对象秒计数器的值
* withNanos() 直接修改对象纳秒计数器的值（范围0-999999999）
* plusDays()/minusDays() 给时间段增加/减少指定的天数
* plusHours()/minusHours() 给时间段增加/减少指定的小时数
* plusMinutes()/minusMinutes() 给时间段增加/减少指定的分钟数
* plusSeconds()/minusSeconds() 给时间段增加/减少指定的秒数
* plusMillis()/minusMillis() 给时间段增加/减少指定的毫秒数
* ......
*/

ZoneId与ZoneOffset

ZoneId:

1.既可以表示时区，也可以表示时差。

2.是一个抽象类，有两个子类分别是ZoneRegion和ZoneOffset,ZoneRegion表示城市或地区，并以城市或地区反映“时区”。

//通过systemDefault()创建
ZoneId zoneId1 = ZoneId.systemDefault();
System.out.println(zoneId1.getClass());//class java.time.ZoneRegion
System.out.println(zoneId1);//Asia/Shanghai
System.out.println(zoneId1.normalized());//Asia/Shanghai
System.out.println(zoneId1.getRules());//ZoneRules[currentStandardOffset=+08:00]
//通过静态方法of()创建
ZoneId zoneId2 = ZoneId.of("Asia/Shanghai");
System.out.println(zoneId2);
//所有的代表时区的地区
for(String s : ZoneId.getAvailableZoneIds()){
System.out.println(s);
}
ZoneId ctt = ZoneId.of("CTT", ZoneId.SHORT_IDS);
System.out.println(ctt);

ZoneOffset:

1.时差，特指与格林尼治时间的偏差。

ZoneId zoneId = ZoneId.of("UTC+08:00");
ZoneId zoneId = ZoneId.of("+08:00");
System.out.println(zoneId.getClass());//class java.time.ZoneOffset
System.out.println(zoneId);//+08:00
ZoneId zoneId1 = ZoneId.of("+08:23");
System.out.println(zoneId1);//+08:23
//中时区/零时区
ZoneId zoneId2 = ZoneId.of("+00:00");
System.out.println(zoneId2);//Z
/**
* GMT
* 1.全称为Greenwich Mean Time,意为格林尼治时间
* 2.格林尼治天文台所在的那个时区的时间
* 3.由格林尼治天文台根据观测地球自转所确定的时间系统
* UTC
* 1.中文译为协调世界时，又称世界统一时间。
* 2.UTC是以原子时秒长为基础，在时刻上尽量接近于世界时的一种时间计量系统。
* Java8新日期时间系统中，GMT与UTC并无数值上的差别。
* 闰秒：UTC和GMT相差1秒，调整UTC与GMT相等。
*/
//不可以加UTC/GMT
ZoneOffset zoneOffset = ZoneOffset.of("+08:00");
System.out.println(zoneOffset);//+08:00
//三个属性的正负值必须保持一致
ZoneOffset zoneOffset1 = ZoneOffset.ofHoursMinutesSeconds(3, 12, 1);
System.out.println(zoneOffset1);//+03:12:01
System.out.println(zoneOffset1.getTotalSeconds());//11521
System.out.println(zoneOffset1.get(ChronoField.OFFSET_SECONDS));//11521
System.out.println(ZoneOffset.ofHours(8));//+08:00

ZonedDateTime与OffsetDateTime

ZonedDateTime

LocalDateTime localDateTime = LocalDateTime.now();
ZoneId zoneId = ZoneId.of("Asia/Tokyo");
ZoneOffset zoneOffset = ZoneOffset.ofHours(8);
//此时时区为系统设置的时区
ZonedDateTime zonedDateTime = ZonedDateTime.now();
System.out.println(zonedDateTime);//2022-09-23T20:14:43.776+08:00[Asia/Shanghai]
//of()方法只组合不转换 时间不会转换成指定时区的时间 还是系统的LocalDateTime
ZonedDateTime zonedDateTime1 = ZonedDateTime.of(localDateTime, zoneId);
System.out.println(zonedDateTime1);//2022-09-23T20:18:03.987+09:00[Asia/Tokyo]
Instant instant = Instant.now();
System.out.println(instant);//2022-09-24T03:08:11.849Z
//组合转换 转向ZoneId
ZonedDateTime zonedDateTime2 = ZonedDateTime.ofInstant(instant, zoneId);
System.out.println(zonedDateTime2);//2022-09-24T12:08:11.849+09:00[Asia/Tokyo]
ZoneOffset zoneOffset1 = ZoneOffset.of("+06:00");
ZonedDateTime zonedDateTime3 = ZonedDateTime.ofInstant(localDateTime, zoneOffset1, zoneId);//2022-09-24T14:14:14.663+09:00[Asia/Tokyo]
System.out.println(zonedDateTime3);
//ofStrict() ZoneOffset与ZoneId必须严格一致 只组合不转换
System.out.println(ZonedDateTime.ofStrict(localDateTime, ZoneOffset.of("+08:00"), ZoneId.of("Asia/Shanghai")));//2022-09-24T11:18:47.899+08:00[Asia/Shanghai]

OffsetDateTime

//now方法创建
OffsetDateTime offsetDateTime = OffsetDateTime.now();
System.out.println(offsetDateTime);//2022-09-24T11:23:41.488+08:00
//of()方法创建
LocalDateTime localDateTime = LocalDateTime.now();
ZoneOffset zoneOffset = ZoneOffset.of("+09:00");
OffsetDateTime offsetDateTime1 = OffsetDateTime.of(localDateTime, zoneOffset);
//只组合不转换
System.out.println(offsetDateTime1);//2022-09-24T11:26:39.355+09:00
//ofInstant() 转向ZoneId
Instant instant = Instant.now();
ZoneId zoneId = ZoneId.of("Asia/Tokyo");
OffsetDateTime offsetDateTime2 = OffsetDateTime.ofInstant(instant, zoneId);
System.out.println(offsetDateTime2);//2022-09-24T12:30:21.634+09:00

ZonedDateTime与OffsetDateTime计算

//获得时间分量
ZonedDateTime zonedDateTime = ZonedDateTime.now();
OffsetDateTime offsetDateTime3 = OffsetDateTime.now();
ZoneOffset offset = zonedDateTime.getOffset();
System.out.println(offset);
//与格林尼治时区相差的总秒数
System.out.println(offset.getTotalSeconds());
System.out.println(zonedDateTime.get(ChronoField.OFFSET_SECONDS));
//当前系统时间与时间源点（1970-01-01 00:00:00）相差的总秒数
System.out.println(zonedDateTime.getLong(ChronoField.INSTANT_SECONDS));
System.out.println(offsetDateTime3.toEpochSecond());
System.out.println(zonedDateTime.toEpochSecond());
//query()
ZonedDateTime zonedDateTime1 = ZonedDateTime.now();
LocalDate query = zonedDateTime1.query(TemporalQueries.localDate());//2022-09-26
System.out.println(query);
LocalTime query1 = zonedDateTime1.query(TemporalQueries.localTime());//08:46:17.405
System.out.println(query1);
//时差
ZoneOffset query2 = zonedDateTime1.query(TemporalQueries.offset());
System.out.println(query2);//+08:00
ZoneId query3 = zonedDateTime1.query(TemporalQueries.zoneId());
System.out.println(query3);//Asia/Shanghai
//获得纪年方式
Chronology query4 = zonedDateTime1.query(TemporalQueries.chronology());
System.out.println(query4);//ISO
//对象最高精度的计时单位
TemporalUnit query5 = zonedDateTime1.query(TemporalQueries.precision());
System.out.println(query5);//Nanos
//修改时差信息
ZonedDateTime zonedDateTime2 = ZonedDateTime.now();
OffsetDateTime offsetDateTime4 = OffsetDateTime.now();
ZoneId zoneId1 = ZoneId.of("Asia/Tokyo");
System.out.println(zonedDateTime2);//2022-09-26T09:14:57.025+08:00[Asia/Shanghai]
//修改时区 日期时间不变
System.out.println(zonedDateTime2.withZoneSameLocal(zoneId1));//2022-09-26T09:21:32.398+09:00[Asia/Tokyo]
//修改时区和时间
System.out.println(zonedDateTime2.withZoneSameInstant(zoneId1));//2022-09-26T10:22:48.353+09:00[Asia/Tokyo]
System.out.println(zonedDateTime2.withFixedOffsetZone());//2022-09-26T09:28:39.251+08:00
//日期时间比较
LocalDateTime localDateTime1 = LocalDateTime.now();
ZoneId zoneId2 = ZoneId.of("Asia/Shanghai");
ZoneId zoneId3 = ZoneId.of("+08:00");
ZonedDateTime zonedDateTime3 = ZonedDateTime.of(localDateTime1, zoneId2);
ZonedDateTime zonedDateTime4 = ZonedDateTime.of(localDateTime1, zoneId3);
System.out.println(zonedDateTime3.equals(zonedDateTime4));//false
System.out.println(zonedDateTime3.isEqual(zonedDateTime4));//true
//ZonedDateTime和OffsetDateTime比较需要转化为同一个类型
//不能用ZonedDateTime和OffsetDateTime的compareTo()方法比较两个时间在时间轴上的前后关系
//可以使用OffsetDateTime.timeLineOrder.compare()来比较 只能比较OffsetDateTime对象 比较ZonedDateTime需要转化
//计算时间差until()方法

格式化日期时间DateTimeFormatter

ZonedDateTime zonedDateTime5 = ZonedDateTime.now();
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日");
String format = zonedDateTime5.format(dateTimeFormatter);
System.out.println(format);//2022年09月26日
DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("yyyy年MM月dd日 EEEE");
String format1 = zonedDateTime5.format(dateTimeFormatter1);
System.out.println(format1);//2022年09月26日 星期一
DateTimeFormatter dateTimeFormatter2 = DateTimeFormatter.ofPattern("yyyy年MM月dd日 xxx");
String format2 = zonedDateTime5.format(dateTimeFormatter2);
System.out.println(format2);//2022年09月26日 +08:00
//DateTimeFormatter也提供了很多静态格式
String str = "2022年09月26日";
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy年MM月dd日");
LocalDate ld = LocalDate.parse(str, dtf);
System.out.println(ld);//2022-09-26

Clock

当前时刻

1.抽象类，用于获取当前时间，可以代替System.currentTimeMillis()和TimeZone.getDefault()。Clock类对象记录当前时间时，并没有记录具体的年月日和时分秒，而是记录了当前时间距离时间原点的毫秒数，同时还记录了一个时区信息，这样就能把Clock对象转换成各种日期时间类的对象。

2.该抽象类的主要目的是允许在需要时插入备用时钟，所有时间类都有一个now()工厂方法，该方法使用默认时区中的系统时钟，最佳实践是将Clock传递给任何需要当前时间的方法。

3.保证线程安全

4.忽略闰秒

5.继承的类要声明Serializable

Clock clock = Clock.systemDefaultZone();
System.out.println(clock);//SystemClock[Asia/Shanghai]
ZoneId zoneId = ZoneId.of("Asia/Tokyo");
Clock system = Clock.system(zoneId);
System.out.println(system);//SystemClock[Asia/Tokyo]
Clock systemUTC = Clock.systemUTC();
System.out.println(systemUTC);//SystemClock[Z]
//当前时间与时间原点相差的毫秒数
System.out.println(systemUTC.millis());//1664158760710
System.out.println(clock.getZone());//Asia/Shanghai
//修改时区
Clock clock1 = clock.withZone(zoneId);
System.out.println(clock1);//SystemClock[Asia/Tokyo]
//给当前时间增加一段时间
Clock offset = Clock.offset(clock, Duration.ofHours(24));
/**
* tickSeconds()方法的作用：创建一个表示当前时刻的Clock对象，
* 但该对象计时只能精确到秒
*/
//以5个小时为精度
Clock tick = Clock.tick(clock, Duration.ofHours(5));

Instant

1.表示时间轴上的任意一个时间点

2.没有时区信息

3.记录时间最小可精确到纳秒

4.Instant对象中并不能直接得到年月日时分秒的数值，它靠秒计数器和纳秒计数器来记录与时间原点的距离

Instant now = Instant.now();
System.out.println(now);//2022-09-26T02:34:15.034Z
//创建距离创建时间原点123456789毫秒的时间
Instant instant = Instant.ofEpochMilli(123456789);
System.out.println(instant);//1970-01-02T10:17:36.789Z
//修改时间分量 plus() minus()
System.out.println(now.plus((Period.ofDays(3))));//2022-09-29T02:47:21.628Z
/**
* LocalDate仅可接受Period对象
* LocalTime仅可接受Duration对象
* LocalDateTime/ZonedDateTime/OffsetDateTime既可接受Period对象又可接受Duration对象
* Instant可以完全接受Duration对象，在Period对象年和月计数器值为0的情况下，也可以接收Period对象作为参数。
*/
System.out.println(now.plus(1, ChronoUnit.DAYS));//2022-09-27T02:53:23.827Z
Instant instant1 = Instant.ofEpochMilli(0);
//赋值now
System.out.println(instant1.with(now));
/**
* 常用的方法
* equals() isBefore() isAfter() compareTo() until()
*/

now()方法详解

/**
* now()方法：1.无参 2.Clock对象 3.ZoneId
* now()方法所创建的日期时间对象实际取决于Clock参数
*/

ChronoField.XXX

代表时间分量

ChronoUnit.XXX

代表时长

对象直接互相转化

加法型 减法型 平行转换型 部分转换型

倔强的初学者
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
JAVA时间日期处理类实例
09-03
主要介绍了JAVA时间日期处理类,可实现遍历两个日期之间的每一天的功能,涉及针对日期的常见操作技巧,需要的朋友可以参考下
java时间处理类
02-08
提供友好的时间处理接口，方便处理java时间相关问题
Java计算时间差，距结束还有几天几小时几分钟
llg___的博客
11-22 1045
上面的toHours()方法返回的是时间差全部换算为小时的数值，而不时去掉整天以后的整小时，想获得后者，应该调用toHoursPart()方法
关于java的API的部分使用
monkey__K的博客
11-11 22
主要为了方便子类可以自己指定相等的比较规则。.totalMemory()/1024.0/1024.0 //返回Java虚拟机中的内存总量。.freeMemory()/1024.0/1024.0 //回Java虚拟机中的可用内存量。.exec("软件启动路径路径")//或程序中编辑好的路径直接输入名如.exec("QQ");object是所有子类中的父类，所以父类toString的意义是为了让子类重写以便返回内容。使用它拼接字符串的时候，不仅高效，而且代码的编写更加的方便。
Java8 日期时间类整理
Shawn的个人博客
10-18 5176
目录一、Date类型存在的问题二、Java8新的日期时间类1、LocalDate2、LocalTime3、LocalDateTime4、Instant三、日期时间的修改与计算1、时间修改2、格式化日期(常用)四、LocalDateTime在SpringBoot中的应用1、将LocalDateTime字段以时间戳的方式返回给前端 添加日期转化类2、将LocalDateTime字段以指定格式化日期的方式返回给前端3、对前端传入的日期进行格式化4、前后端日期时间转化问题 当我们开始使⽤Java操作⽇期和时间的时
【Java】Java8中时间类的使用
nlcwdl的博客
09-04 257
描述了java8常见日期时间类的区别与用法
java时间方法_java.time.OffsetDateTime of()方法
weixin_39806413的博客
02-22 368
java.time.OffsetDateTime of()方法java.time.OffsetDateTime.of(LocalDateTime date，ZoneOffset offset)方法从日期时间和偏移量获取OffsetDateTime的实例。1 语法public static OffsetDateTime of(LocalDateTime date, ZoneOffset offset...
java8新的时间日期库及使用示例
MISS_duan的博客
05-14 198
java8引入了一套全新的时间日期API，本篇随笔将说明学习java8的这套API。 java。time包中的是类是不可变且线程安全的。新的时间及日期API位于java.time中，下面是一些关键类 ●Instant——它代表的是时间戳 ●LocalDate——不包含具体时间的日期，比如2014-01-14。它可以用来存储生日，周年纪念日，入职日期等。 ●LocalTime——它代表的是不含日期的时间 ●LocalDateTime——它包含了日期及时间，不过还是没有偏移信息或者说时区。 ●...
java8新日期
蒯厅博客
05-02 827
简介 伴随 lambda表达式、streams 以及一系列小优化，Java 8 推出了全新的日期时间API。 Java处理日期、日历和时间的不足之处：将 java.util.Date 设定为可变类型，以及 SimpleDateFormat 的非线程安全使其应用非常受限。然后就在 java8 上面增加新的特性。 全新API的众多好处之一就是，明确了日期时间概念，例如：瞬时（instant）、 长短（...
时间各种处理类
01-22
时间的处理各种方式 java8 技术 对时间处理的各种方式
Java注释全解文档.zip
03-02
Spring注释全解文档，Java注解.pdf，Spring注解.doc，Struts2注解.doc
Java最新面试题全解
02-10
Java最新面试题全解，面试必备指南
Java8 新特性，18 种日期处理方式
IAHEAD的博客
09-30 850
Java 8日期时间API
Java8日期时间类
小宋自学java
12-16 879
Java8日期时间类
java8 日期比较_JavaSE基础:扩展Java 8 日期操作
weixin_39644750的博客
01-22 274
Java 8 推出了全新的日期时间API，在教程中我们将通过一些简单的实例来学习如何使用新API。Java处理日期、日历和时间的方式一直为社区所诟病，将 java.util.Date设定为可变类型，以及SimpleDateFormat的非线程安全使其应用非常受限。新API基于ISO标准日历系统，java.time包下的所有类都是不可变类型而且线程安全。示例1:Java 8中获取今天的日期Java ...
Java 8 - 日期和时间类
学无止境
06-04 179
【代码】Java 8 - 日期和时间类。
java offestdatetime_java.time.OffsetDateTime of()方法
weixin_39864682的博客
02-26 68
java.time.OffsetDateTime of()方法java.time.OffsetDateTime.of(int year，int month，int dayOfMonth，int hour，int minute，int second，int nanoOfSecond，ZoneOffset offset)方法从年，月，日，小时，分钟 ，秒，纳秒和偏移量获取OffsetDateTime的...
OffsetDateTime使用详解
qq_43657722的博客
11-29 3855
OffsetDateTime使用详解
mybatisPlus使用MetaObjectHandler对字段进行更新
最新发布
m0_56356631的博客
04-23 416
都是符合我们的预期的。
java自定义异常处理类
06-10
自定义异常处理类通常需要继承自Java中的Exception类或其子类，可以通过定义自己的异常来实现程序的可控性和健壮性。 以下是一个自定义异常处理类的示例代码： ``` public class MyException extends Exception { ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

倔强的初学者

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值