Repository navigation
Expand file tree
/
Copy pathDateFormat.java
More file actions
1152 lines (1076 loc) · 44.8 KB
/
Copy pathDateFormat.java
File metadata and controls
1152 lines (1076 loc) · 44.8 KB
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) 1996, 2025, 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.
*/
/*
* (C) Copyright Taligent, Inc. 1996 - All Rights Reserved
* (C) Copyright IBM Corp. 1996 - All Rights Reserved
*
* The original version of this source code and documentation is copyrighted
* and owned by Taligent, Inc., a wholly-owned subsidiary of IBM. These
* materials are provided under terms of a License Agreement between Taligent
* and Sun. This technology is protected by multiple US and International
* patents. This notice and attribution to Taligent may not be removed.
* Taligent is a registered trademark of Taligent, Inc.
*
*/
package java.text;
import java.io.InvalidObjectException;
import java.text.spi.DateFormatProvider;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;
import java.util.MissingResourceException;
import java.util.ResourceBundle;
import java.util.TimeZone;
import java.util.spi.LocaleServiceProvider;
import sun.util.locale.provider.LocaleProviderAdapter;
import sun.util.locale.provider.LocaleServiceProviderPool;
/**
* {@code DateFormat} is an abstract class for date/time formatting subclasses which
* formats and parses dates or time in a language-independent manner.
* The date/time formatting subclass, such as {@link SimpleDateFormat}, allows for
* formatting (i.e., date → text), parsing (text → date), and
* normalization. The date is represented as a {@code Date} object or
* as the milliseconds since January 1, 1970, 00:00:00 GMT.
*
* <p>{@code DateFormat} provides static factory methods for obtaining default date/time
* formatters based on the default or a given locale and a number of formatting
* styles. The formatting styles include {@link #FULL}, {@link #LONG}, {@link #MEDIUM}, and {@link #SHORT}.
* For any of the factory methods with the parameter <i>style</i>, an {@code
* IllegalArgumentException} will be thrown if <i>style</i> is not equal to any
* of the defined formatting styles. More detail and examples of using these styles are provided in the method
* descriptions.
*
* <p>{@code DateFormat} helps you to format and parse dates for any locale.
* Your code can be completely independent of the locale conventions for
* months, days of the week, or even the calendar format: lunar vs. solar.
*
* <p>To format a date for the current Locale, use one of the
* static factory methods:
* <blockquote>
* {@snippet lang=java :
* myString = DateFormat.getDateInstance().format(myDate);
* }
* </blockquote>
* <p>If you are formatting multiple dates, it is
* more efficient to get the format and use it multiple times so that
* the system doesn't have to fetch the information about the local
* language and country conventions multiple times.
* <blockquote>
* {@snippet lang=java :
* DateFormat df = DateFormat.getDateInstance();
* for (Date myDate : dates) {
* output.println(df.format(myDate) + "; ");
* }
* }
* </blockquote>
* <p>To format a date for a different Locale, specify it in the
* call to {@link #getDateInstance(int, Locale) getDateInstance()}.
* <blockquote>
* {@snippet lang=java :
* DateFormat df = DateFormat.getDateInstance(DateFormat.LONG, Locale.FRANCE);
* }
* </blockquote>
*
* <p>If the specified locale contains "ca" (calendar), "rg" (region override),
* and/or "tz" (timezone) {@linkplain Locale##def_locale_extension Unicode
* extensions}, the calendar, the country and/or the time zone for formatting
* are overridden. If both "ca" and "rg" are specified, the calendar from the "ca"
* extension supersedes the implicit one from the "rg" extension.
*
* <p>You can use a DateFormat to parse also.
* <blockquote>
* {@snippet lang=java :
* myDate = df.parse(myString);
* }
* </blockquote>
* <p>Use {@code getDateInstance} to get the normal date format for that country.
* There are other static factory methods available.
* Use {@code getTimeInstance} to get the time format for that country.
* Use {@code getDateTimeInstance} to get a date and time format. You can pass in
* different options to these factory methods to control the length of the
* result; from {@link #SHORT} to {@link #MEDIUM} to {@link #LONG} to {@link #FULL}. The exact result depends
* on the locale, but generally:
* <ul><li>{@link #SHORT} is the shortest and mainly numeric, such as {@code 12.13.52} or {@code 3:30pm}
* <li>{@link #MEDIUM} is longer, such as {@code Jan 12, 1952}
* <li>{@link #LONG} is even longer, such as {@code January 12, 1952} or {@code 3:30:32pm}
* <li>{@link #FULL} is the longest, such as
* {@code Tuesday, April 12, 1952 AD or 3:30:42pm PST}.
* </ul>
* For those fields with text, typically abbreviated text form is used with {@link #MEDIUM} option,
* and full text form is used with {@link #LONG} and {@link #FULL} options.
*
* <p>You can also set the time zone on the format if you wish.
* If you want even more control over the format or parsing,
* (or want to give your users more control),
* you can try casting the {@code DateFormat} you get from the factory methods
* to a {@link SimpleDateFormat}. This will work for the majority
* of countries; just remember to put it in a {@code try} block in case you
* encounter an unusual one.
*
* <p>You can also use forms of the parse and format methods with
* {@link ParsePosition} and {@link FieldPosition} to
* allow you to
* <ul><li>progressively parse through pieces of a string.
* <li>align any particular field, or find out where it is for selection
* on the screen.
* </ul>
*
* <h2><a id="synchronization">Synchronization</a></h2>
*
* <p>
* Date formats are not synchronized.
* It is recommended to create separate format instances for each thread.
* If multiple threads access a format concurrently, it must be synchronized
* externally.
* @apiNote Consider using {@link java.time.format.DateTimeFormatter} as an
* immutable and thread-safe alternative.
*
* @implSpec
* <ul><li>The {@link #format(Date, StringBuffer, FieldPosition)} and
* {@link #parse(String, ParsePosition)} methods may throw
* {@code NullPointerException}, if any of their parameter is {@code null}.
* The subclass may provide its own implementation and specification about
* {@code NullPointerException}.</li>
* <li>The {@link #setCalendar(Calendar)}, {@link
* #setNumberFormat(NumberFormat)} and {@link #setTimeZone(TimeZone)} methods
* do not throw {@code NullPointerException} when their parameter is
* {@code null}, but any subsequent operations on the same instance may throw
* {@code NullPointerException}.</li>
* <li>The {@link #getCalendar()}, {@link #getNumberFormat()} and
* {@link #getTimeZone()} methods may return {@code null}, if the respective
* values of this instance is set to {@code null} through the corresponding
* setter methods. For Example: {@link #getTimeZone()} may return {@code null},
* if the {@code TimeZone} value of this instance is set as
* {@link #setTimeZone(java.util.TimeZone) setTimeZone(null)}.</li>
* </ul>
*
* @see Format
* @see NumberFormat
* @see SimpleDateFormat
* @see java.util.Calendar
* @see java.util.GregorianCalendar
* @see java.util.TimeZone
* @see java.time.format.DateTimeFormatter
* @author Mark Davis, Chen-Lieh Huang, Alan Liu
* @since 1.1
*/
public abstract class DateFormat extends Format {
/**
* The {@link Calendar} instance used for calculating the date-time fields
* and the instant of time. This field is used for both formatting and
* parsing.
*
* <p>Subclasses should initialize this field to a {@link Calendar}
* appropriate for the {@link Locale} associated with this
* {@code DateFormat}.
* @serial
*/
protected Calendar calendar;
/**
* The number formatter that {@code DateFormat} uses to format numbers
* in dates and times. Subclasses should initialize this to a number format
* appropriate for the locale associated with this {@code DateFormat}.
* @serial
*/
protected NumberFormat numberFormat;
/**
* Useful constant for ERA field alignment.
* Used in FieldPosition of date/time formatting.
*/
public static final int ERA_FIELD = 0;
/**
* Useful constant for YEAR field alignment.
* Used in FieldPosition of date/time formatting.
*/
public static final int YEAR_FIELD = 1;
/**
* Useful constant for MONTH field alignment.
* Used in FieldPosition of date/time formatting.
*/
public static final int MONTH_FIELD = 2;
/**
* Useful constant for DATE field alignment.
* Used in FieldPosition of date/time formatting.
*/
public static final int DATE_FIELD = 3;
/**
* Useful constant for one-based HOUR_OF_DAY field alignment.
* Used in FieldPosition of date/time formatting.
* HOUR_OF_DAY1_FIELD is used for the one-based 24-hour clock.
* For example, 23:59 + 01:00 results in 24:59.
*/
public static final int HOUR_OF_DAY1_FIELD = 4;
/**
* Useful constant for zero-based HOUR_OF_DAY field alignment.
* Used in FieldPosition of date/time formatting.
* HOUR_OF_DAY0_FIELD is used for the zero-based 24-hour clock.
* For example, 23:59 + 01:00 results in 00:59.
*/
public static final int HOUR_OF_DAY0_FIELD = 5;
/**
* Useful constant for MINUTE field alignment.
* Used in FieldPosition of date/time formatting.
*/
public static final int MINUTE_FIELD = 6;
/**
* Useful constant for SECOND field alignment.
* Used in FieldPosition of date/time formatting.
*/
public static final int SECOND_FIELD = 7;
/**
* Useful constant for MILLISECOND field alignment.
* Used in FieldPosition of date/time formatting.
*/
public static final int MILLISECOND_FIELD = 8;
/**
* Useful constant for DAY_OF_WEEK field alignment.
* Used in FieldPosition of date/time formatting.
*/
public static final int DAY_OF_WEEK_FIELD = 9;
/**
* Useful constant for DAY_OF_YEAR field alignment.
* Used in FieldPosition of date/time formatting.
*/
public static final int DAY_OF_YEAR_FIELD = 10;
/**
* Useful constant for DAY_OF_WEEK_IN_MONTH field alignment.
* Used in FieldPosition of date/time formatting.
*/
public static final int DAY_OF_WEEK_IN_MONTH_FIELD = 11;
/**
* Useful constant for WEEK_OF_YEAR field alignment.
* Used in FieldPosition of date/time formatting.
*/
public static final int WEEK_OF_YEAR_FIELD = 12;
/**
* Useful constant for WEEK_OF_MONTH field alignment.
* Used in FieldPosition of date/time formatting.
*/
public static final int WEEK_OF_MONTH_FIELD = 13;
/**
* Useful constant for AM_PM field alignment.
* Used in FieldPosition of date/time formatting.
*/
public static final int AM_PM_FIELD = 14;
/**
* Useful constant for one-based HOUR field alignment.
* Used in FieldPosition of date/time formatting.
* HOUR1_FIELD is used for the one-based 12-hour clock.
* For example, 11:30 PM + 1 hour results in 12:30 AM.
*/
public static final int HOUR1_FIELD = 15;
/**
* Useful constant for zero-based HOUR field alignment.
* Used in FieldPosition of date/time formatting.
* HOUR0_FIELD is used for the zero-based 12-hour clock.
* For example, 11:30 PM + 1 hour results in 00:30 AM.
*/
public static final int HOUR0_FIELD = 16;
/**
* Useful constant for TIMEZONE field alignment.
* Used in FieldPosition of date/time formatting.
*/
public static final int TIMEZONE_FIELD = 17;
// Proclaim serial compatibility with 1.1 FCS
@java.io.Serial
private static final long serialVersionUID = 7218322306649953788L;
/**
* Formats the given {@code Object} into a date-time string. The formatted
* string is appended to the given {@code StringBuffer}.
*
* @param obj Must be a {@code Date} or a {@code Number} representing a
* millisecond offset from the <a href="../util/Calendar.html#Epoch">Epoch</a>.
* @param toAppendTo The string buffer for the returning date-time string.
* @param fieldPosition keeps track on the position of the field within
* the returned string. For example, given a date-time text
* {@code "1996.07.10 AD at 15:08:56 PDT"}, if the given {@code fieldPosition}
* is {@link DateFormat#YEAR_FIELD}, the begin index and end index of
* {@code fieldPosition} will be set to 0 and 4, respectively.
* Notice that if the same date-time field appears more than once in a
* pattern, the {@code fieldPosition} will be set for the first occurrence
* of that date-time field. For instance, formatting a {@code Date} to the
* date-time string {@code "1 PM PDT (Pacific Daylight Time)"} using the
* pattern {@code "h a z (zzzz)"} and the alignment field
* {@link DateFormat#TIMEZONE_FIELD}, the begin index and end index of
* {@code fieldPosition} will be set to 5 and 8, respectively, for the
* first occurrence of the timezone pattern character {@code 'z'}.
* @return the string buffer passed in as {@code toAppendTo},
* with formatted text appended.
* @throws IllegalArgumentException if the {@code Format} cannot format
* the given {@code obj}.
* @see java.text.Format
*/
public final StringBuffer format(Object obj, StringBuffer toAppendTo,
FieldPosition fieldPosition)
{
if (obj instanceof Date)
return format( (Date)obj, toAppendTo, fieldPosition );
else if (obj instanceof Number)
return format( new Date(((Number)obj).longValue()),
toAppendTo, fieldPosition );
else
throw new IllegalArgumentException("Cannot format given Object as a Date");
}
@Override
final StringBuf format(Object obj, StringBuf toAppendTo,
FieldPosition fieldPosition) {
if (obj instanceof Date) {
return format((Date) obj, toAppendTo, fieldPosition);
} else if (obj instanceof Number) {
return format(new Date(((Number) obj).longValue()),
toAppendTo, fieldPosition);
} else {
throw new IllegalArgumentException("Cannot format given Object as a Date");
}
}
/**
* Formats a {@link Date} into a date-time string. The formatted
* string is appended to the given {@code StringBuffer}.
*
* @param date a Date to be formatted into a date-time string.
* @param toAppendTo the string buffer for the returning date-time string.
* @param fieldPosition keeps track on the position of the field within
* the returned string. For example, given a date-time text
* {@code "1996.07.10 AD at 15:08:56 PDT"}, if the given {@code fieldPosition}
* is {@link DateFormat#YEAR_FIELD}, the begin index and end index of
* {@code fieldPosition} will be set to 0 and 4, respectively.
* Notice that if the same date-time field appears more than once in a
* pattern, the {@code fieldPosition} will be set for the first occurrence
* of that date-time field. For instance, formatting a {@code Date} to the
* date-time string {@code "1 PM PDT (Pacific Daylight Time)"} using the
* pattern {@code "h a z (zzzz)"} and the alignment field
* {@link DateFormat#TIMEZONE_FIELD}, the begin index and end index of
* {@code fieldPosition} will be set to 5 and 8, respectively, for the
* first occurrence of the timezone pattern character {@code 'z'}.
* @return the string buffer passed in as {@code toAppendTo}, with formatted
* text appended.
*/
public abstract StringBuffer format(Date date, StringBuffer toAppendTo,
FieldPosition fieldPosition);
StringBuf format(Date date, StringBuf toAppendTo,
FieldPosition fieldPosition) {
throw new UnsupportedOperationException("Subclasses should override this method");
}
/**
* Formats a {@link Date} into a date-time string.
*
* @param date the time value to be formatted into a date-time string.
* @return the formatted date-time string.
*/
public final String format(Date date)
{
if ("java.text".equals(getClass().getPackageName())
&& "java.text".equals(numberFormat.getClass().getPackageName())) {
return format(date, StringBufFactory.of(),
DontCareFieldPosition.INSTANCE).toString();
} else {
return format(date, new StringBuffer(),
DontCareFieldPosition.INSTANCE).toString();
}
}
/**
* Parses text from the beginning of the given string to produce a date.
* The method may not use the entire text of the given string.
* <p>
* See the {@link #parse(String, ParsePosition)} method for more information
* on date parsing.
*
* @param source A {@code String} whose beginning should be parsed.
* @return A {@code Date} parsed from the string.
* @throws ParseException if the beginning of the specified string
* cannot be parsed.
*/
public Date parse(String source) throws ParseException
{
ParsePosition pos = new ParsePosition(0);
Date result = parse(source, pos);
if (pos.index == 0)
throw new ParseException("Unparseable date: \"" + source + "\"" ,
pos.errorIndex);
return result;
}
/**
* Parse a date/time string according to the given parse position. For
* example, if {@code this} has the pattern {@code "M/d/yy h:m a, z"},
* then a time text {@code "07/10/96 4:5 PM, PDT"} will be parsed into a {@code Date}
* that is equivalent to {@code Date(837039900000L)}.
*
* <p> By default, parsing is lenient: If the input is not in the form used
* by this object's format method but can still be parsed as a date, then
* the parse succeeds. Clients may insist on strict adherence to the
* format by calling {@link #setLenient(boolean) setLenient(false)}.
*
* <p>This parsing operation uses the {@link #calendar} to produce
* a {@code Date}. As a result, the {@code calendar}'s date-time
* fields and the {@code TimeZone} value may have been
* overwritten, depending on subclass implementations. Any {@code
* TimeZone} value that has previously been set by a call to
* {@link #setTimeZone(java.util.TimeZone) setTimeZone} may need
* to be restored for further operations.
*
* @param source The date/time string to be parsed
*
* @param pos On input, the position at which to start parsing; on
* output, the position at which parsing terminated, or the
* start position if the parse failed.
*
* @return A {@code Date}, or {@code null} if the input could not be parsed
*/
public abstract Date parse(String source, ParsePosition pos);
/**
* Parses text from a string to produce a {@code Date}.
* <p>
* The method attempts to parse text starting at the index given by
* {@code pos}.
* If parsing succeeds, then the index of {@code pos} is updated
* to the index after the last character used (parsing does not necessarily
* use all characters up to the end of the string), and the parsed
* date is returned. The updated {@code pos} can be used to
* indicate the starting point for the next call to this method.
* If an error occurs, then the index of {@code pos} is not
* changed, the error index of {@code pos} is set to the index of
* the character where the error occurred, and null is returned.
* <p>
* See the {@link #parse(String, ParsePosition)} method for more information
* on date parsing.
*
* @param source A {@code String}, part of which should be parsed.
* @param pos A {@code ParsePosition} object with index and error
* index information as described above.
* @return A {@code Date} parsed from the string. In case of
* error, returns null.
* @throws NullPointerException if {@code source} or {@code pos} is null.
*/
public Object parseObject(String source, ParsePosition pos) {
return parse(source, pos);
}
/**
* Constant for full style pattern.
*/
public static final int FULL = 0;
/**
* Constant for long style pattern.
*/
public static final int LONG = 1;
/**
* Constant for medium style pattern.
*/
public static final int MEDIUM = 2;
/**
* Constant for short style pattern.
*/
public static final int SHORT = 3;
/**
* Constant for default style pattern. Its value is MEDIUM.
*/
public static final int DEFAULT = MEDIUM;
/**
* A DateFormat style.
* {@code Style} is an enum which corresponds to the DateFormat style
* constants. Use {@code getValue()} to retrieve the associated int style
* value.
*/
enum Style {
FULL(DateFormat.FULL),
LONG(DateFormat.LONG),
MEDIUM(DateFormat.MEDIUM),
SHORT(DateFormat.SHORT),
DEFAULT(DateFormat.MEDIUM);
private final int value;
Style(int value){
this.value = value;
}
int getValue() {
return value;
}
}
/**
* Gets the time formatter with the default formatting style
* for the default {@link java.util.Locale.Category#FORMAT FORMAT} locale.
* <p>This is equivalent to calling
* {@link #getTimeInstance(int, Locale) getTimeInstance(DEFAULT,
* Locale.getDefault(Locale.Category.FORMAT))}.
* @see java.util.Locale#getDefault(java.util.Locale.Category)
* @see java.util.Locale.Category#FORMAT
* @return a time formatter.
*/
public static final DateFormat getTimeInstance()
{
return get(DEFAULT, 0, 1, Locale.getDefault(Locale.Category.FORMAT));
}
/**
* Gets the time formatter with the given formatting style
* for the default {@link java.util.Locale.Category#FORMAT FORMAT} locale.
* <p>This is equivalent to calling
* {@link #getTimeInstance(int, Locale) getTimeInstance(style,
* Locale.getDefault(Locale.Category.FORMAT))}.
* @see java.util.Locale#getDefault(java.util.Locale.Category)
* @see java.util.Locale.Category#FORMAT
* @param style the given formatting style. For example,
* SHORT for "h:mm a" in the US locale.
* @return a time formatter.
*/
public static final DateFormat getTimeInstance(int style)
{
return get(style, 0, 1, Locale.getDefault(Locale.Category.FORMAT));
}
/**
* Gets the time formatter with the given formatting style
* for the given locale.
* @param style the given formatting style. For example,
* SHORT for "h:mm a" in the US locale.
* @param aLocale the given locale.
* @return a time formatter.
*/
public static final DateFormat getTimeInstance(int style,
Locale aLocale)
{
return get(style, 0, 1, aLocale);
}
/**
* Gets the date formatter with the default formatting style
* for the default {@link java.util.Locale.Category#FORMAT FORMAT} locale.
* <p>This is equivalent to calling
* {@link #getDateInstance(int, Locale) getDateInstance(DEFAULT,
* Locale.getDefault(Locale.Category.FORMAT))}.
* @see java.util.Locale#getDefault(java.util.Locale.Category)
* @see java.util.Locale.Category#FORMAT
* @return a date formatter.
*/
public static final DateFormat getDateInstance()
{
return get(0, DEFAULT, 2, Locale.getDefault(Locale.Category.FORMAT));
}
/**
* Gets the date formatter with the given formatting style
* for the default {@link java.util.Locale.Category#FORMAT FORMAT} locale.
* <p>This is equivalent to calling
* {@link #getDateInstance(int, Locale) getDateInstance(style,
* Locale.getDefault(Locale.Category.FORMAT))}.
* @see java.util.Locale#getDefault(java.util.Locale.Category)
* @see java.util.Locale.Category#FORMAT
* @param style the given formatting style. For example,
* SHORT for "M/d/yy" in the US locale.
* @return a date formatter.
*/
public static final DateFormat getDateInstance(int style)
{
return get(0, style, 2, Locale.getDefault(Locale.Category.FORMAT));
}
/**
* Gets the date formatter with the given formatting style
* for the given locale.
* @param style the given formatting style. For example,
* SHORT for "M/d/yy" in the US locale.
* @param aLocale the given locale.
* @return a date formatter.
*/
public static final DateFormat getDateInstance(int style,
Locale aLocale)
{
return get(0, style, 2, aLocale);
}
/**
* Gets the date/time formatter with the default formatting style
* for the default {@link java.util.Locale.Category#FORMAT FORMAT} locale.
* <p>This is equivalent to calling
* {@link #getDateTimeInstance(int, int, Locale) getDateTimeInstance(DEFAULT,
* DEFAULT, Locale.getDefault(Locale.Category.FORMAT))}.
* @see java.util.Locale#getDefault(java.util.Locale.Category)
* @see java.util.Locale.Category#FORMAT
* @return a date/time formatter.
*/
public static final DateFormat getDateTimeInstance()
{
return get(DEFAULT, DEFAULT, 3, Locale.getDefault(Locale.Category.FORMAT));
}
/**
* Gets the date/time formatter with the given date and time
* formatting styles for the default {@link java.util.Locale.Category#FORMAT FORMAT} locale.
* <p>This is equivalent to calling
* {@link #getDateTimeInstance(int, int, Locale) getDateTimeInstance(dateStyle,
* timeStyle, Locale.getDefault(Locale.Category.FORMAT))}.
* @see java.util.Locale#getDefault(java.util.Locale.Category)
* @see java.util.Locale.Category#FORMAT
* @param dateStyle the given date formatting style. For example,
* SHORT for "M/d/yy" in the US locale.
* @param timeStyle the given time formatting style. For example,
* SHORT for "h:mm a" in the US locale.
* @return a date/time formatter.
*/
public static final DateFormat getDateTimeInstance(int dateStyle,
int timeStyle)
{
return get(timeStyle, dateStyle, 3, Locale.getDefault(Locale.Category.FORMAT));
}
/**
* Gets the date/time formatter with the given formatting styles
* for the given locale.
* @param dateStyle the given date formatting style.
* @param timeStyle the given time formatting style.
* @param aLocale the given locale.
* @return a date/time formatter.
*/
public static final DateFormat
getDateTimeInstance(int dateStyle, int timeStyle, Locale aLocale)
{
return get(timeStyle, dateStyle, 3, aLocale);
}
/**
* Get a default date/time formatter that uses the SHORT style for both the
* date and the time.
*
* @return a date/time formatter
*/
public static final DateFormat getInstance() {
return getDateTimeInstance(SHORT, SHORT);
}
/**
* Returns an array of all locales for which the
* {@code get*Instance} methods of this class can return
* localized instances.
* The returned array represents the union of locales supported by the Java
* runtime and by installed
* {@link java.text.spi.DateFormatProvider DateFormatProvider} implementations.
* At a minimum, the returned array must contain a {@code Locale} instance equal to
* {@link Locale#ROOT Locale.ROOT} and a {@code Locale} instance equal to
* {@link Locale#US Locale.US}.
*
* @return An array of locales for which localized
* {@code DateFormat} instances are available.
*/
public static Locale[] getAvailableLocales()
{
LocaleServiceProviderPool pool =
LocaleServiceProviderPool.getPool(DateFormatProvider.class);
return pool.getAvailableLocales();
}
/**
* Set the calendar to be used by this date format. Initially, the default
* calendar for the specified or default locale is used.
*
* <p>Any {@link java.util.TimeZone TimeZone} and {@linkplain
* #isLenient() leniency} values that have previously been set are
* overwritten by {@code newCalendar}'s values.
*
* @param newCalendar the new {@code Calendar} to be used by the date format
*/
public void setCalendar(Calendar newCalendar)
{
this.calendar = newCalendar;
}
/**
* Gets the calendar associated with this date/time formatter.
*
* @return the calendar associated with this date/time formatter.
*/
public Calendar getCalendar()
{
return calendar;
}
/**
* Allows you to set the number formatter.
* @param newNumberFormat the given new NumberFormat.
*/
public void setNumberFormat(NumberFormat newNumberFormat)
{
this.numberFormat = newNumberFormat;
}
/**
* Gets the number formatter which this date/time formatter uses to
* format and parse a time.
* @return the number formatter which this date/time formatter uses.
*/
public NumberFormat getNumberFormat()
{
return numberFormat;
}
/**
* Sets the time zone for the calendar of this {@code DateFormat} object.
* This method is equivalent to the following call.
* <blockquote>{@snippet lang=java :
* getCalendar().setTimeZone(zone);
* }</blockquote>
*
* <p>The {@code TimeZone} set by this method is overwritten by a
* {@link #setCalendar(java.util.Calendar) setCalendar} call.
*
* <p>The {@code TimeZone} set by this method may be overwritten as
* a result of a call to the parse method.
*
* @param zone the given new time zone.
*/
public void setTimeZone(TimeZone zone)
{
calendar.setTimeZone(zone);
}
/**
* Gets the time zone.
* This method is equivalent to the following call.
* <blockquote>{@snippet lang=java :
* getCalendar().getTimeZone();
* }</blockquote>
*
* @return the time zone associated with the calendar of DateFormat.
*/
public TimeZone getTimeZone()
{
return calendar.getTimeZone();
}
/**
* Specify whether or not date/time parsing is to be lenient. With
* lenient parsing, the parser may use heuristics to interpret inputs that
* do not precisely match this object's format. With strict parsing,
* inputs must match this object's format.
*
* <p>This method is equivalent to the following call.
* <blockquote>{@snippet lang=java :
* getCalendar().setLenient(lenient);
* }</blockquote>
*
* <p>This leniency value is overwritten by a call to {@link
* #setCalendar(java.util.Calendar) setCalendar()}.
*
* @implSpec A {@link Character#SPACE_SEPARATOR SPACE_SEPARATOR} in the input
* text will match any other {@link Character#SPACE_SEPARATOR SPACE_SEPARATOR}s
* in the pattern with lenient parsing; otherwise, it will not match.
*
* @param lenient when {@code true}, parsing is lenient
* @see java.util.Calendar#setLenient(boolean)
*/
public void setLenient(boolean lenient)
{
calendar.setLenient(lenient);
}
/**
* Tell whether date/time parsing is to be lenient.
* This method is equivalent to the following call.
* <blockquote>{@snippet lang=java :
* getCalendar().isLenient();
* }</blockquote>
*
* @return {@code true} if the {@link #calendar} is lenient;
* {@code false} otherwise.
* @see java.util.Calendar#isLenient()
*/
public boolean isLenient()
{
return calendar.isLenient();
}
/**
* {@return the hash code for this {@code DateFormat}}
*
* @implSpec This method calculates the hash code value using the value returned by
* {@link #getNumberFormat()}.
* @see Object#hashCode()
*/
public int hashCode() {
return numberFormat.hashCode();
// just enough fields for a reasonable distribution
}
/**
* Compares the specified object with this {@code DateFormat} for equality.
* Returns true if the object is also a {@code DateFormat} and the
* two formats would format any value the same.
*
* @implSpec This method performs an equality check with a notion of class
* identity based on {@code getClass()}, rather than {@code instanceof}.
* Therefore, in the equals methods in subclasses, no instance of this class
* should compare as equal to an instance of a subclass.
* @param obj object to be compared for equality
* @return {@code true} if the specified object is equal to this {@code DateFormat}
* @see Object#equals(Object)
*/
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null || getClass() != obj.getClass()) return false;
DateFormat other = (DateFormat) obj;
return (// calendar.equivalentTo(other.calendar) // THIS API DOESN'T EXIST YET!
calendar.getFirstDayOfWeek() == other.calendar.getFirstDayOfWeek() &&
calendar.getMinimalDaysInFirstWeek() == other.calendar.getMinimalDaysInFirstWeek() &&
calendar.isLenient() == other.calendar.isLenient() &&
calendar.getTimeZone().equals(other.calendar.getTimeZone()) &&
numberFormat.equals(other.numberFormat));
}
/**
* Overrides Cloneable
*/
public Object clone()
{
DateFormat other = (DateFormat) super.clone();
other.calendar = (Calendar) calendar.clone();
other.numberFormat = (NumberFormat) numberFormat.clone();
return other;
}
/**
* Creates a DateFormat with the given time and/or date style in the given
* locale.
* @param timeStyle a value from 0 to 3 indicating the time format,
* ignored if flags is 2
* @param dateStyle a value from 0 to 3 indicating the time format,
* ignored if flags is 1
* @param flags either 1 for a time format, 2 for a date format,
* or 3 for a date/time format
* @param loc the locale for the format
*/
private static DateFormat get(int timeStyle, int dateStyle,
int flags, Locale loc) {
if ((flags & 1) != 0) {
if (timeStyle < 0 || timeStyle > 3) {
throw new IllegalArgumentException("Illegal time style " + timeStyle);
}
} else {
timeStyle = -1;
}
if ((flags & 2) != 0) {
if (dateStyle < 0 || dateStyle > 3) {
throw new IllegalArgumentException("Illegal date style " + dateStyle);
}
} else {
dateStyle = -1;
}
LocaleProviderAdapter adapter = LocaleProviderAdapter.getAdapter(DateFormatProvider.class, loc);
DateFormat dateFormat = get(adapter, timeStyle, dateStyle, loc);
if (dateFormat == null) {
dateFormat = get(LocaleProviderAdapter.forJRE(), timeStyle, dateStyle, loc);
}
return dateFormat;
}
private static DateFormat get(LocaleProviderAdapter adapter, int timeStyle, int dateStyle, Locale loc) {
DateFormatProvider provider = adapter.getDateFormatProvider();
DateFormat dateFormat;
if (timeStyle == -1) {
dateFormat = provider.getDateInstance(dateStyle, loc);
} else {
if (dateStyle == -1) {
dateFormat = provider.getTimeInstance(timeStyle, loc);
} else {
dateFormat = provider.getDateTimeInstance(dateStyle, timeStyle, loc);
}
}
return dateFormat;
}
/**
* Create a new date format.
*/
protected DateFormat() {}
/**
* Defines constants that are used as attribute keys in the
* {@code AttributedCharacterIterator} returned
* from {@code DateFormat.formatToCharacterIterator} and as
* field identifiers in {@code FieldPosition}.
* <p>
* The class also provides two methods to map
* between its constants and the corresponding Calendar constants.
*
* @since 1.4
* @see java.util.Calendar
*/
public static class Field extends Format.Field {
// Proclaim serial compatibility with 1.4 FCS
@java.io.Serial
private static final long serialVersionUID = 7441350119349544720L;
// table of all instances in this class, used by readResolve
private static final Map<String, Field> instanceMap = new HashMap<>(18);
// Maps from Calendar constant (such as Calendar.ERA) to Field
// constant (such as Field.ERA).
private static final Field[] calendarToFieldMapping =
new Field[Calendar.FIELD_COUNT];
/** @serial Calendar field. */
private int calendarField;
/**
* Returns the {@code Field} constant that corresponds to
* the {@code Calendar} constant {@code calendarField}.
* If there is no direct mapping between the {@code Calendar}
* constant and a {@code Field}, null is returned.
*
* @throws IllegalArgumentException if {@code calendarField} is
* not the value of a {@code Calendar} field constant.
* @param calendarField Calendar field constant
* @return Field instance representing calendarField.
* @see java.util.Calendar
*/
public static Field ofCalendarField(int calendarField) {
if (calendarField < 0 || calendarField >=
calendarToFieldMapping.length) {
throw new IllegalArgumentException("Unknown Calendar constant "
+ calendarField);
}
return calendarToFieldMapping[calendarField];
}
/**
* Creates a {@code Field}.
*
* @param name the name of the {@code Field}
* @param calendarField the {@code Calendar} constant this
* {@code Field} corresponds to; any value, even one
* outside the range of legal {@code Calendar} values may
* be used, but {@code -1} should be used for values
* that don't correspond to legal {@code Calendar} values
*/
@SuppressWarnings("this-escape")
protected Field(String name, int calendarField) {
super(name);
this.calendarField = calendarField;
if (this.getClass() == DateFormat.Field.class) {
instanceMap.put(name, this);
if (calendarField >= 0) {
// assert(calendarField < Calendar.FIELD_COUNT);
calendarToFieldMapping[calendarField] = this;
}
}