forked from kangjianwei/LearningJDK
-
Notifications
You must be signed in to change notification settings - Fork 0
/
ZonedDateTime.java
3201 lines (2967 loc) · 151 KB
/
ZonedDateTime.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*
* Copyright (c) 2012, 2018, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* This file is available under and governed by the GNU General Public
* License version 2 only, as published by the Free Software Foundation.
* However, the following notice accompanied the original version of this
* file:
*
* Copyright (c) 2007-2012, Stephen Colebourne & Michael Nascimento Santos
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* * Neither the name of JSR-310 nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package java.time;
import java.io.DataOutput;
import java.io.IOException;
import java.io.InvalidObjectException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.Serializable;
import java.time.chrono.ChronoZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.time.temporal.ChronoField;
import java.time.temporal.ChronoUnit;
import java.time.temporal.Temporal;
import java.time.temporal.TemporalAccessor;
import java.time.temporal.TemporalAdjuster;
import java.time.temporal.TemporalAmount;
import java.time.temporal.TemporalField;
import java.time.temporal.TemporalQueries;
import java.time.temporal.TemporalQuery;
import java.time.temporal.TemporalUnit;
import java.time.temporal.UnsupportedTemporalTypeException;
import java.time.temporal.ValueRange;
import java.time.zone.ZoneOffsetTransition;
import java.time.zone.ZoneRules;
import java.util.List;
import java.util.Objects;
import static java.time.temporal.ChronoField.INSTANT_SECONDS;
import static java.time.temporal.ChronoField.NANO_OF_SECOND;
import static java.time.temporal.ChronoField.OFFSET_SECONDS;
/**
* A date-time with a time-zone in the ISO-8601 calendar system,
* such as {@code 2007-12-03T10:15:30+01:00 Europe/Paris}.
* <p>
* {@code ZonedDateTime} is an immutable representation of a date-time with a time-zone.
* This class stores all date and time fields, to a precision of nanoseconds,
* and a time-zone, with a zone offset used to handle ambiguous local date-times.
* For example, the value
* "2nd October 2007 at 13:45.30.123456789 +02:00 in the Europe/Paris time-zone"
* can be stored in a {@code ZonedDateTime}.
* <p>
* This class handles conversion from the local time-line of {@code LocalDateTime}
* to the instant time-line of {@code Instant}.
* The difference between the two time-lines is the offset from UTC/Greenwich,
* represented by a {@code ZoneOffset}.
* <p>
* Converting between the two time-lines involves calculating the offset using the
* {@link ZoneRules rules} accessed from the {@code ZoneId}.
* Obtaining the offset for an instant is simple, as there is exactly one valid
* offset for each instant. By contrast, obtaining the offset for a local date-time
* is not straightforward. There are three cases:
* <ul>
* <li>Normal, with one valid offset. For the vast majority of the year, the normal
* case applies, where there is a single valid offset for the local date-time.</li>
* <li>Gap, with zero valid offsets. This is when clocks jump forward typically
* due to the spring daylight savings change from "winter" to "summer".
* In a gap there are local date-time values with no valid offset.</li>
* <li>Overlap, with two valid offsets. This is when clocks are set back typically
* due to the autumn daylight savings change from "summer" to "winter".
* In an overlap there are local date-time values with two valid offsets.</li>
* </ul>
* <p>
* Any method that converts directly or implicitly from a local date-time to an
* instant by obtaining the offset has the potential to be complicated.
* <p>
* For Gaps, the general strategy is that if the local date-time falls in the
* middle of a Gap, then the resulting zoned date-time will have a local date-time
* shifted forwards by the length of the Gap, resulting in a date-time in the later
* offset, typically "summer" time.
* <p>
* For Overlaps, the general strategy is that if the local date-time falls in the
* middle of an Overlap, then the previous offset will be retained. If there is no
* previous offset, or the previous offset is invalid, then the earlier offset is
* used, typically "summer" time.. Two additional methods,
* {@link #withEarlierOffsetAtOverlap()} and {@link #withLaterOffsetAtOverlap()},
* help manage the case of an overlap.
* <p>
* In terms of design, this class should be viewed primarily as the combination
* of a {@code LocalDateTime} and a {@code ZoneId}. The {@code ZoneOffset} is
* a vital, but secondary, piece of information, used to ensure that the class
* represents an instant, especially during a daylight savings overlap.
*
* <p>
* This is a <a href="{@docRoot}/java.base/java/lang/doc-files/ValueBased.html">value-based</a>
* class; use of identity-sensitive operations (including reference equality
* ({@code ==}), identity hash code, or synchronization) on instances of
* {@code ZonedDateTime} may have unpredictable results and should be avoided.
* The {@code equals} method should be used for comparisons.
*
* @implSpec A {@code ZonedDateTime} holds state equivalent to three separate objects,
* a {@code LocalDateTime}, a {@code ZoneId} and the resolved {@code ZoneOffset}.
* The offset and local date-time are used to define an instant when necessary.
* The zone ID is used to obtain the rules for how and when the offset changes.
* The offset cannot be freely set, as the zone controls which offsets are valid.
* <p>
* This class is immutable and thread-safe.
* @since 1.8
*/
/*
* "本地日期-时间","时间"[关联]了所属的时区ID,"日期"基于[ISO]历法系统。
*
* 注:这里关联的时区ID可能是基于时间偏移的,也可能是基于地理时区的。
*/
public final class ZonedDateTime implements Temporal, ChronoZonedDateTime<LocalDate>, Serializable {
/**
* The local date-time.
*/
/*
* 本地日期-时间
*
* 注:这个时间点反映的是zone/offset时区的时间点。
*/
private final LocalDateTime dateTime;
/**
* The time-zone.
*/
/*
* 时区ID,用来指示当前"本地日期-时间"所处的时区
*
* 这可能是[基于时间偏移的时区ID],也可能是[基于地理时区的时区ID]
*/
private final ZoneId zone;
/**
* The offset from UTC/Greenwich.
*/
/*
* 基于时间偏移的时区ID,用来指示当前"本地日期-时间"所处的时区
*
* 如果zone是[基于时间偏移的时区ID],则offset的值与zone的值相等;
* 如果zone是[基于地理时区的时区ID],则需要根据其对应的时区规则集,计算出当前时刻该时区的时间偏移。
*/
private final ZoneOffset offset;
/*▼ 构造器 ████████████████████████████████████████████████████████████████████████████████┓ */
/**
* Constructor.
*
* @param dateTime the date-time, validated as not null
* @param offset the zone offset, validated as not null
* @param zone the time-zone, validated as not null
*/
private ZonedDateTime(LocalDateTime dateTime, ZoneOffset offset, ZoneId zone) {
this.dateTime = dateTime;
this.offset = offset;
this.zone = zone;
}
/*▲ 构造器 ████████████████████████████████████████████████████████████████████████████████┛ */
/*▼ 工厂方法 ████████████████████████████████████████████████████████████████████████████████┓ */
/**
* Obtains the current date-time from the system clock in the default time-zone.
* <p>
* This will query the {@link Clock#systemDefaultZone() system clock} in the default
* time-zone to obtain the current date-time.
* The zone and offset will be set based on the time-zone in the clock.
* <p>
* Using this method will prevent the ability to use an alternate clock for testing
* because the clock is hard-coded.
*
* @return the current date-time using the system clock, not null
*/
// 构造属于系统默认时区的"本地日期-时间"(时区偏移时间准确)
public static ZonedDateTime now() {
// 获取一个系统时钟,其预设的时区ID为系统默认的时区ID
Clock clock = Clock.systemDefaultZone();
return now(clock);
}
/**
* Obtains the current date-time from the system clock in the specified time-zone.
* <p>
* This will query the {@link Clock#system(ZoneId) system clock} to obtain the current date-time.
* Specifying the time-zone avoids dependence on the default time-zone.
* The offset will be calculated from the specified time-zone.
* <p>
* Using this method will prevent the ability to use an alternate clock for testing
* because the clock is hard-coded.
*
* @param zone the zone ID to use, not null
*
* @return the current date-time using the system clock, not null
*/
// 使用指定的时钟构造属于zone时区的"本地日期-时间"(时区偏移时间准确)
public static ZonedDateTime now(ZoneId zone) {
// 获取一个系统时钟,其预设的时区ID为zone
Clock clock = Clock.system(zone);
return now(clock);
}
/**
* Obtains the current date-time from the specified clock.
* <p>
* This will query the specified clock to obtain the current date-time.
* The zone and offset will be set based on the time-zone in the clock.
* <p>
* Using this method allows the use of an alternate clock for testing.
* The alternate clock may be introduced using {@link Clock dependency injection}.
*
* @param clock the clock to use, not null
*
* @return the current date-time, not null
*/
// 使用指定的时钟构造"本地日期-时间"(时区偏移时间准确)
public static ZonedDateTime now(Clock clock) {
Objects.requireNonNull(clock, "clock");
// 获取clock时钟提供的时间戳
final Instant instant = clock.instant();
// 获取clock时钟提供的时区ID
ZoneId zoneId = clock.getZone();
// 使用时间戳和时区ID构造一个属于zoneId时区的"本地日期-时间"(时区偏移时间准确)
return ofInstant(instant, zoneId);
}
/**
* Obtains an instance of {@code ZonedDateTime} from a local date and time.
* <p>
* This creates a zoned date-time matching the input local date and time as closely as possible.
* Time-zone rules, such as daylight savings, mean that not every local date-time
* is valid for the specified zone, thus the local date-time may be adjusted.
* <p>
* The local date time and first combined to form a local date-time.
* The local date-time is then resolved to a single instant on the time-line.
* This is achieved by finding a valid offset from UTC/Greenwich for the local
* date-time as defined by the {@link ZoneRules rules} of the zone ID.
* <p>
* In most cases, there is only one valid offset for a local date-time.
* In the case of an overlap, when clocks are set back, there are two valid offsets.
* This method uses the earlier offset typically corresponding to "summer".
* <p>
* In the case of a gap, when clocks jump forward, there is no valid offset.
* Instead, the local date-time is adjusted to be later by the length of the gap.
* For a typical one hour daylight savings change, the local date-time will be
* moved one hour later into the offset typically corresponding to "summer".
*
* @param date the local date, not null
* @param time the local time, not null
* @param zone the time-zone, not null
*
* @return the offset date-time, not null
*/
/*
* 使用给定的"本地日期"部件和"本地时间"部件构造属于zone的"本地日期-时间"对象。
* 如果zone不是ZoneOffset类型,则时区偏移时间可能会不准确。
*/
public static ZonedDateTime of(LocalDate date, LocalTime time, ZoneId zone) {
LocalDateTime dateTime = LocalDateTime.of(date, time);
return of(dateTime, zone);
}
/**
* Obtains an instance of {@code ZonedDateTime} from a local date-time.
* <p>
* This creates a zoned date-time matching the input local date-time as closely as possible.
* Time-zone rules, such as daylight savings, mean that not every local date-time
* is valid for the specified zone, thus the local date-time may be adjusted.
* <p>
* The local date-time is resolved to a single instant on the time-line.
* This is achieved by finding a valid offset from UTC/Greenwich for the local
* date-time as defined by the {@link ZoneRules rules} of the zone ID.
* <p>
* In most cases, there is only one valid offset for a local date-time.
* In the case of an overlap, when clocks are set back, there are two valid offsets.
* This method uses the earlier offset typically corresponding to "summer".
* <p>
* In the case of a gap, when clocks jump forward, there is no valid offset.
* Instead, the local date-time is adjusted to be later by the length of the gap.
* For a typical one hour daylight savings change, the local date-time will be
* moved one hour later into the offset typically corresponding to "summer".
*
* @param localDateTime the local date-time, not null
* @param zone the time-zone, not null
*
* @return the zoned date-time, not null
*/
/*
* 使用localDateTime构造属于zone的"本地日期-时间"对象。
* 如果zone不是ZoneOffset类型,则时区偏移时间可能会不准确。
*/
public static ZonedDateTime of(LocalDateTime localDateTime, ZoneId zone) {
return ofLocal(localDateTime, zone, null);
}
/**
* Obtains an instance of {@code ZonedDateTime} from a year, month, day,
* hour, minute, second, nanosecond and time-zone.
* <p>
* This creates a zoned date-time matching the local date-time of the seven
* specified fields as closely as possible.
* Time-zone rules, such as daylight savings, mean that not every local date-time
* is valid for the specified zone, thus the local date-time may be adjusted.
* <p>
* The local date-time is resolved to a single instant on the time-line.
* This is achieved by finding a valid offset from UTC/Greenwich for the local
* date-time as defined by the {@link ZoneRules rules} of the zone ID.
* <p>
* In most cases, there is only one valid offset for a local date-time.
* In the case of an overlap, when clocks are set back, there are two valid offsets.
* This method uses the earlier offset typically corresponding to "summer".
* <p>
* In the case of a gap, when clocks jump forward, there is no valid offset.
* Instead, the local date-time is adjusted to be later by the length of the gap.
* For a typical one hour daylight savings change, the local date-time will be
* moved one hour later into the offset typically corresponding to "summer".
* <p>
* This method exists primarily for writing test cases.
* Non test-code will typically use other methods to create an offset time.
* {@code LocalDateTime} has five additional convenience variants of the
* equivalent factory method taking fewer arguments.
* They are not provided here to reduce the footprint of the API.
*
* @param year the year to represent, from MIN_YEAR to MAX_YEAR
* @param month the month-of-year to represent, from 1 (January) to 12 (December)
* @param dayOfMonth the day-of-month to represent, from 1 to 31
* @param hour the hour-of-day to represent, from 0 to 23
* @param minute the minute-of-hour to represent, from 0 to 59
* @param second the second-of-minute to represent, from 0 to 59
* @param nanoOfSecond the nano-of-second to represent, from 0 to 999,999,999
* @param zone the time-zone, not null
*
* @return the offset date-time, not null
*
* @throws DateTimeException if the value of any field is out of range, or
* if the day-of-month is invalid for the month-year
*/
/*
* 使用给定的日期部件和时间部件构造属于zone的"本地日期-时间"对象
* 如果zone不是ZoneOffset类型,则时区偏移时间可能会不准确。
*/
public static ZonedDateTime of(int year, int month, int dayOfMonth, int hour, int minute, int second, int nanoOfSecond, ZoneId zone) {
LocalDateTime dt = LocalDateTime.of(year, month, dayOfMonth, hour, minute, second, nanoOfSecond);
return ofLocal(dt, zone, null);
}
/**
* Obtains an instance of {@code ZonedDateTime} from a local date-time
* using the preferred offset if possible.
* <p>
* The local date-time is resolved to a single instant on the time-line.
* This is achieved by finding a valid offset from UTC/Greenwich for the local
* date-time as defined by the {@link ZoneRules rules} of the zone ID.
* <p>
* In most cases, there is only one valid offset for a local date-time.
* In the case of an overlap, where clocks are set back, there are two valid offsets.
* If the preferred offset is one of the valid offsets then it is used.
* Otherwise the earlier valid offset is used, typically corresponding to "summer".
* <p>
* In the case of a gap, where clocks jump forward, there is no valid offset.
* Instead, the local date-time is adjusted to be later by the length of the gap.
* For a typical one hour daylight savings change, the local date-time will be
* moved one hour later into the offset typically corresponding to "summer".
*
* @param localDateTime the local date-time, not null
* @param zone the time-zone, not null
* @param preferredOffset the zone offset, null if no preference
*
* @return the zoned date-time, not null
*/
/*
* 使用基于zone的localDateTime来构造ZonedDateTime。
* 如果zone不是ZoneOffset类型,则时区偏移时间可能会不准确。
*
* 如果localDateTime处于"正常时间"或"夏令时时间"中,则offset字段可以使用zone时区中唯一的有效偏移。
* 如果localDateTime处于"间隙时间"中,则将该时间调到间隙后。
* 如果localDateTime处于"重叠时间"中,则如果preferredOffset有效,则offset字段可以直接使用它,否则,默认使用首个时区偏移。
*
* localDateTime : 基于zone的"本地日期-时间"
* zone : 新生成的"本地日期-时间"的时区ID
* preferredOffset: 当localDateTime位于zone的"重叠时间"中时,使用该参数指定localDateTime应当使用的时区偏移。
*
* 示例:
* LocalDateTime localDateTime = LocalDateTime.of(2020, 11, 1, 1, 30);
* ZoneId zone = ZoneId.of("America/Los_Angeles");
* ZoneOffset preferredOffset = ZoneOffset.of("-7");
* ZonedDateTime zonedDateTime = ZonedDateTime.ofLocal(localDateTime, zone, preferredOffset);
*
* 洛杉矶地区在2020年11月1日1时30分会进入一个"重叠时间",即在这个时间点,可能有两个时区偏移,
* 可以是位于夏令时中的"-7"小时偏移,也可以是结束夏令时后的"-8"偏移,
* 此时,就应该设置一个preferredOffset指示接下来该使用哪个偏移。
* 如果不指定preferredOffset,或者设置了preferredOffset,但是超出了有效范围(超出了-7或-8这个范围)
* 那么系统默认使用偏移列表中的第一个有效偏移,即"-7"。
*/
public static ZonedDateTime ofLocal(LocalDateTime localDateTime, ZoneId zone, ZoneOffset preferredOffset) {
Objects.requireNonNull(localDateTime, "localDateTime");
Objects.requireNonNull(zone, "zone");
// 直接构造
if(zone instanceof ZoneOffset) {
return new ZonedDateTime(localDateTime, (ZoneOffset) zone, zone);
}
// 获取与zone对应的"时区规则集"
ZoneRules rules = zone.getRules();
/*
* 获取zone时区在localDateTime时刻的"有效偏移"。
*
* 在"间隙时间"中,没有有效的偏移;
* 在"重叠时间"中,存在两个有效偏移;
* 在"正常时间"或"夏令时时间"中,存在一个有效偏移。
*
* localDateTime: 视为zone时区的一个本地时间。
*/
List<ZoneOffset> validOffsets = rules.getValidOffsets(localDateTime);
ZoneOffset offset;
// 处于"正常时间"或"夏令时时间"中
if(validOffsets.size() == 1) {
// 直接使用此时获取到的那个有效偏移
offset = validOffsets.get(0);
// 处于"间隙时间"中,则将该时间调到间隙后
} else if(validOffsets.size() == 0) {
/*
* 获取zone时区在localDateTime时刻的偏移转换规则,该规则用来指示如何切换时区的时间偏移。
*
* 只有在"间隙时间"和"重叠时间"中,需要用到偏移转换规则。
* 在正常时间和夏令时时间内,无需用到偏移转换规则。
*
* localDateTime: 视为zone时区的一个本地时间。
*/
ZoneOffsetTransition trans = rules.getTransition(localDateTime);
// 间隙后的偏移 - 间隙前的偏移,通常指进入夏令时前后相差的时间
long duration = trans.getDuration().getSeconds();
// 在localDateTime的值上累加seconds秒
localDateTime = localDateTime.plusSeconds(duration);
// 获取间隙后的偏移
offset = trans.getOffsetAfter();
// 处于"重叠时间"中
} else {
/*
* 如果预设了一个可以使用的有效偏移,则直接使用该偏移量.
* 这里预设了偏移,相当于指定了该本地时间是作为夏令时时间还是非夏令时时间。
*/
if(preferredOffset != null && validOffsets.contains(preferredOffset)) {
offset = preferredOffset;
/*
* 如果没有预设有效偏移,或者预设的有效偏移无效(不在"重叠时间"的有效偏移中),
* 此时,我们默认选择"重叠时间"的有效偏移列表中的第一个有效偏移。
* 通常来说,这个偏移是仍处于夏令时的偏移。
*/
} else {
offset = Objects.requireNonNull(validOffsets.get(0), "offset"); // protect against bad ZoneRules
}
}
return new ZonedDateTime(localDateTime, offset, zone);
}
/**
* Obtains an instance of {@code ZonedDateTime} from an {@code Instant}.
* <p>
* This creates a zoned date-time with the same instant as that specified.
* Calling {@link #toInstant()} will return an instant equal to the one used here.
* <p>
* Converting an instant to a zoned date-time is simple as there is only one valid
* offset for each instant.
*
* @param instant the instant to create the date-time from, not null
* @param zone the time-zone, not null
*
* @return the zoned date-time, not null
*
* @throws DateTimeException if the result exceeds the supported range
*/
// 使用时间戳和时区ID构造一个属于zone时区的"本地日期-时间"(时区偏移时间准确)
public static ZonedDateTime ofInstant(Instant instant, ZoneId zone) {
Objects.requireNonNull(instant, "instant");
Objects.requireNonNull(zone, "zone");
// 使用UTC时区的纪元秒、纳秒偏移以及时区ID构造一个属于zone时区的"本地日期-时间"(时区偏移时间准确)
return create(instant.getEpochSecond(), instant.getNano(), zone);
}
/**
* Obtains an instance of {@code ZonedDateTime} from the instant formed by combining
* the local date-time and offset.
* <p>
* This creates a zoned date-time by {@link LocalDateTime#toInstant(ZoneOffset) combining}
* the {@code LocalDateTime} and {@code ZoneOffset}.
* This combination uniquely specifies an instant without ambiguity.
* <p>
* Converting an instant to a zoned date-time is simple as there is only one valid
* offset for each instant. If the valid offset is different to the offset specified,
* then the date-time and offset of the zoned date-time will differ from those specified.
* <p>
* If the {@code ZoneId} to be used is a {@code ZoneOffset}, this method is equivalent
* to {@link #of(LocalDateTime, ZoneId)}.
*
* @param localDateTime the local date-time, not null
* @param offset the zone offset, not null
* @param zone the time-zone, not null
*
* @return the zoned date-time, not null
*/
/*
* 使用基于offset的localDateTime,构造处于zone的ZonedDateTime(时区偏移时间准确)。
*
* 如果offset属于zone时区下的"有效偏移",则可以直接构造ZonedDateTime对象。
* 否则,需要先将这个基于offset的"本地日期-时间"调回到UTC处,然后再结合zone构造ZonedDateTime对象。
*
* localDateTime: 基于offset的"本地日期-时间"
* offset : localDateTime的时区偏移
* zone : 新生成的"本地日期-时间"的时区ID
*/
public static ZonedDateTime ofInstant(LocalDateTime localDateTime, ZoneOffset offset, ZoneId zone) {
Objects.requireNonNull(localDateTime, "localDateTime");
Objects.requireNonNull(offset, "offset");
Objects.requireNonNull(zone, "zone");
// 获取与zone对应的"时区规则集"
ZoneRules rules = zone.getRules();
// 如果offset属于rules中的"有效偏移",则可以直接构造新对象
if(rules.isValidOffset(localDateTime, offset)) {
return new ZonedDateTime(localDateTime, offset, zone);
}
// 将offset时区与当前"本地日期-时间"捆绑为一个"时间点",然后计算该本地时间点下,UTC时区的纪元秒
long epochSecond = localDateTime.toEpochSecond(offset);
// 返回"纳秒"部件
int nano = localDateTime.getNano();
// 使用UTC时区的纪元秒、纳秒偏移以及时区ID构造一个属于zone时区的"本地日期-时间"(时区偏移时间准确)。
return create(epochSecond, nano, zone);
}
/**
* Obtains an instance of {@code ZonedDateTime} strictly validating the
* combination of local date-time, offset and zone ID.
* <p>
* This creates a zoned date-time ensuring that the offset is valid for the
* local date-time according to the rules of the specified zone.
* If the offset is invalid, an exception is thrown.
*
* @param localDateTime the local date-time, not null
* @param offset the zone offset, not null
* @param zone the time-zone, not null
*
* @return the zoned date-time, not null
*
* @throws DateTimeException if the combination of arguments is invalid
*/
/*
* 使用基于offset的localDateTime,构造处于zone的ZonedDateTime。
*
* 只有offset属于zone时区下的"有效偏移",才可以直接构造ZonedDateTime对象;否则会抛异常。
*
* localDateTime: 基于offset的"本地日期-时间"
* offset : localDateTime的时区偏移
* zone : 新生成的"本地日期-时间"的时区ID
*/
public static ZonedDateTime ofStrict(LocalDateTime localDateTime, ZoneOffset offset, ZoneId zone) {
Objects.requireNonNull(localDateTime, "localDateTime");
Objects.requireNonNull(offset, "offset");
Objects.requireNonNull(zone, "zone");
// 获取与zone对应的"时区规则集"
ZoneRules rules = zone.getRules();
// 如果offset属于rules中的"有效偏移",则可以直接构造新对象
if(rules.isValidOffset(localDateTime, offset)) {
return new ZonedDateTime(localDateTime, offset, zone);
}
/*
* 获取zone时区在localDateTime时刻的偏移转换规则,该规则用来指示如何切换时区的时间偏移。
*
* 只有在"间隙时间"和"重叠时间"中,需要用到偏移转换规则。
* 在正常时间和夏令时时间内,无需用到偏移转换规则。
*
* localDateTime: 视为zone时区的一个本地时间。
*/
ZoneOffsetTransition trans = rules.getTransition(localDateTime);
// 处于"间隙时间"时的异常信息
if(trans != null && trans.isGap()) {
// error message says daylight savings for simplicity even though there are other kinds of gaps
throw new DateTimeException("LocalDateTime '" + localDateTime + "' does not exist in zone '" + zone + "' due to a gap in the local time-line, typically caused by daylight savings");
}
// 处于非"间隙"时间时的异常信息
throw new DateTimeException("ZoneOffset '" + offset + "' is not valid for LocalDateTime '" + localDateTime + "' in zone '" + zone + "'");
}
/**
* Obtains an instance of {@code ZonedDateTime} from a temporal object.
* <p>
* This obtains a zoned date-time based on the specified temporal.
* A {@code TemporalAccessor} represents an arbitrary set of date and time information,
* which this factory converts to an instance of {@code ZonedDateTime}.
* <p>
* The conversion will first obtain a {@code ZoneId} from the temporal object,
* falling back to a {@code ZoneOffset} if necessary. It will then try to obtain
* an {@code Instant}, falling back to a {@code LocalDateTime} if necessary.
* The result will be either the combination of {@code ZoneId} or {@code ZoneOffset}
* with {@code Instant} or {@code LocalDateTime}.
* Implementations are permitted to perform optimizations such as accessing
* those fields that are equivalent to the relevant objects.
* <p>
* This method matches the signature of the functional interface {@link TemporalQuery}
* allowing it to be used as a query via method reference, {@code ZonedDateTime::from}.
*
* @param temporal the temporal object to convert, not null
*
* @return the zoned date-time, not null
*
* @throws DateTimeException if unable to convert to an {@code ZonedDateTime}
*/
// 从temporal中获取/构造ZonedDateTime部件
public static ZonedDateTime from(TemporalAccessor temporal) {
if(temporal instanceof ZonedDateTime) {
return (ZonedDateTime) temporal;
}
try {
// 从temporal中查询ZoneId部件的信息(宽松模式,如果在时间量中无法直接查找到ZoneId属性,则回退为查找ZoneOffset属性)
ZoneId zone = ZoneId.from(temporal);
if(temporal.isSupported(INSTANT_SECONDS)) {
// 获取temporal的"纪元秒"部件
long epochSecond = temporal.getLong(INSTANT_SECONDS);
// 获取temporal的"纳秒偏移"部件
int nanoOfSecond = temporal.get(NANO_OF_SECOND);
// 使用UTC时区的纪元秒、纳秒偏移以及时区ID构造一个属于zone时区的"本地日期-时间"(时区偏移时间准确)
return create(epochSecond, nanoOfSecond, zone);
} else {
// 从temporal中查询LocalDate部件
LocalDate date = LocalDate.from(temporal);
// 从temporal中查询LocalTime部件
LocalTime time = LocalTime.from(temporal);
/*
* 使用给定的"本地日期"部件和"本地时间"部件构造属于zone的"本地日期-时间"对象。
* 如果zone不是ZoneOffset类型,则时区偏移时间可能会不准确。
*/
return of(date, time, zone);
}
} catch(DateTimeException ex) {
throw new DateTimeException("Unable to obtain ZonedDateTime from TemporalAccessor: " + temporal + " of type " + temporal.getClass().getName(), ex);
}
}
/**
* Obtains an instance of {@code ZonedDateTime} from a text string such as
* {@code 2007-12-03T10:15:30+01:00[Europe/Paris]}.
* <p>
* The string must represent a valid date-time and is parsed using
* {@link java.time.format.DateTimeFormatter#ISO_ZONED_DATE_TIME}.
*
* @param text the text to parse such as "2007-12-03T10:15:30+01:00[Europe/Paris]", not null
*
* @return the parsed zoned date-time, not null
*
* @throws DateTimeParseException if the text cannot be parsed
*/
// 从指定的文本中解析出ZonedDateTime信息,要求该文本符合ISO规范,即类似:2020-01-15T08:20:53+08:00[Asia/Shanghai]
public static ZonedDateTime parse(CharSequence text) {
return parse(text, DateTimeFormatter.ISO_ZONED_DATE_TIME);
}
/**
* Obtains an instance of {@code ZonedDateTime} from a text string using a specific formatter.
* <p>
* The text is parsed using the formatter, returning a date-time.
*
* @param text the text to parse, not null
* @param formatter the formatter to use, not null
*
* @return the parsed zoned date-time, not null
*
* @throws DateTimeParseException if the text cannot be parsed
*/
// 从指定的文本中解析出ZonedDateTime信息,要求该文本符合指定的格式规范
public static ZonedDateTime parse(CharSequence text, DateTimeFormatter formatter) {
Objects.requireNonNull(formatter, "formatter");
return formatter.parse(text, ZonedDateTime::from);
}
/*▲ 工厂方法 ████████████████████████████████████████████████████████████████████████████████┛ */
/*▼ 转换 ████████████████████████████████████████████████████████████████████████████████┓ */
/**
* Converts this date-time to an {@code OffsetDateTime}.
* <p>
* This creates an offset date-time using the local date-time and offset.
* The zone ID is ignored.
*
* @return an offset date-time representing the same local date-time and offset, not null
*/
// 将ZonedDateTime转换为OffsetDateTime后返回
public OffsetDateTime toOffsetDateTime() {
return OffsetDateTime.of(dateTime, offset);
}
/*▲ 转换 ████████████████████████████████████████████████████████████████████████████████┛ */
/*▼ 部件 ████████████████████████████████████████████████████████████████████████████████┓ */
/**
* Gets the time-zone, such as 'Europe/Paris'.
* <p>
* This returns the zone ID. This identifies the time-zone {@link ZoneRules rules}
* that determine when and how the offset from UTC/Greenwich changes.
* <p>
* The zone ID may be same as the {@linkplain #getOffset() offset}.
* If this is true, then any future calculations, such as addition or subtraction,
* have no complex edge cases due to time-zone rules.
* See also {@link #withFixedOffsetZone()}.
*
* @return the time-zone, not null
*/
// 返回"时区ID"部件
@Override
public ZoneId getZone() {
return zone;
}
/**
* Gets the zone offset, such as '+01:00'.
* <p>
* This is the offset of the local date-time from UTC/Greenwich.
*
* @return the zone offset, not null
*/
// 返回基于时间偏移的"时区ID"部件
@Override
public ZoneOffset getOffset() {
return offset;
}
/**
* Gets the {@code LocalDateTime} part of this date-time.
* <p>
* This returns a {@code LocalDateTime} with the same year, month, day and time
* as this date-time.
*
* @return the local date-time part of this date-time, not null
*/
// 返回"本地日期-时间"组件
@Override
public LocalDateTime toLocalDateTime() {
return dateTime;
}
/**
* Gets the {@code LocalDate} part of this date-time.
* <p>
* This returns a {@code LocalDate} with the same year, month and day
* as this date-time.
*
* @return the date part of this date-time, not null
*/
// 返回"本地日期"组件
@Override
public LocalDate toLocalDate() {
return dateTime.toLocalDate();
}
/**
* Gets the {@code LocalTime} part of this date-time.
* <p>
* This returns a {@code LocalTime} with the same hour, minute, second and
* nanosecond as this date-time.
*
* @return the time part of this date-time, not null
*/
// 返回"本地时间"组件
@Override
public LocalTime toLocalTime() {
return dateTime.toLocalTime();
}
/**
* Gets the year field.
* <p>
* This method returns the primitive {@code int} value for the year.
* <p>
* The year returned by this method is proleptic as per {@code get(YEAR)}.
* To obtain the year-of-era, use {@code get(YEAR_OF_ERA)}.
*
* @return the year, from MIN_YEAR to MAX_YEAR
*/
// (哪年)返回"年份"部件[-999999999, 999999999],由"本地日期"部件计算而来
public int getYear() {
return dateTime.getYear();
}
/**
* Gets the month-of-year field from 1 to 12.
* <p>
* This method returns the month as an {@code int} from 1 to 12.
* Application code is frequently clearer if the enum {@link Month}
* is used by calling {@link #getMonth()}.
*
* @return the month-of-year, from 1 to 12
*
* @see #getMonth()
*/
// (哪月)返回"月份"部件[1, 12],由"本地日期"部件计算而来
public int getMonthValue() {
return dateTime.getMonthValue();
}
/**
* Gets the month-of-year field using the {@code Month} enum.
* <p>
* This method returns the enum {@link Month} for the month.
* This avoids confusion as to what {@code int} values mean.
* If you need access to the primitive {@code int} value then the enum
* provides the {@link Month#getValue() int value}.
*
* @return the month-of-year, not null
*
* @see #getMonthValue()
*/
// (哪月)以Month形式返回"月份"部件,由"本地日期"部件计算而来
public Month getMonth() {
return dateTime.getMonth();
}
/**
* Gets the day-of-month field.
* <p>
* This method returns the primitive {@code int} value for the day-of-month.
*
* @return the day-of-month, from 1 to 31
*/
// (哪日)返回"天"部件[1, 28/31]
public int getDayOfMonth() {
return dateTime.getDayOfMonth();
}
/**
* Gets the day-of-week field, which is an enum {@code DayOfWeek}.
* <p>
* This method returns the enum {@link DayOfWeek} for the day-of-week.
* This avoids confusion as to what {@code int} values mean.
* If you need access to the primitive {@code int} value then the enum
* provides the {@link DayOfWeek#getValue() int value}.
* <p>
* Additional information can be obtained from the {@code DayOfWeek}.
* This includes textual names of the values.
*
* @return the day-of-week, not null
*/
// (周几)返回当前"本地日期-时间"是所在周的第几天
public DayOfWeek getDayOfWeek() {
return dateTime.getDayOfWeek();
}
/**
* Gets the day-of-year field.
* <p>
* This method returns the primitive {@code int} value for the day-of-year.
*
* @return the day-of-year, from 1 to 365, or 366 in a leap year
*/
// 返回当前"本地日期-时间"是所在年份的第几天
public int getDayOfYear() {
return dateTime.getDayOfYear();
}
/**
* Gets the hour-of-day field.
*
* @return the hour-of-day, from 0 to 23
*/
// (几时)返回"小时"部件[0, 23],由"本地时间"部件计算而来
public int getHour() {
return dateTime.getHour();
}
/**
* Gets the minute-of-hour field.
*
* @return the minute-of-hour, from 0 to 59
*/
// (几分)返回"分钟"部件[0, 59],由"本地时间"部件计算而来
public int getMinute() {
return dateTime.getMinute();
}
/**
* Gets the second-of-minute field.
*
* @return the second-of-minute, from 0 to 59
*/
// (几秒)返回"秒"部件[0, 59],由"本地时间"部件计算而来
public int getSecond() {
return dateTime.getSecond();
}
/**
* Gets the nano-of-second field.
*
* @return the nano-of-second, from 0 to 999,999,999
*/
// (几纳秒)返回"纳秒"部件[0, 999999999],由"本地时间"部件计算而来
public int getNano() {
return dateTime.getNano();
}
/*▲ 部件 ████████████████████████████████████████████████████████████████████████████████┛ */
/*▼ 增加 ████████████████████████████████████████████████████████████████████████████████┓ */
/**
* Returns a copy of this date-time with the specified amount added.
* <p>
* This returns a {@code ZonedDateTime}, based on this one, with the specified amount added.
* The amount is typically {@link Period} or {@link Duration} but may be