author | redestad |
Mon, 17 Nov 2014 23:56:53 +0100 | |
changeset 27731 | 3cba975130c0 |
parent 26733 | bb835fd801b6 |
child 28302 | 5de69b0d3a84 |
permissions | -rw-r--r-- |
2 | 1 |
/* |
18143
b6ef7bd945ce
7032154: Performance tuning of sun.misc.FloatingDecimal/FormattedFloatingDecimal
bpb
parents:
16852
diff
changeset
|
2 |
* Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved. |
2 | 3 |
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 |
* |
|
5 |
* This code is free software; you can redistribute it and/or modify it |
|
6 |
* under the terms of the GNU General Public License version 2 only, as |
|
5506 | 7 |
* published by the Free Software Foundation. Oracle designates this |
2 | 8 |
* particular file as subject to the "Classpath" exception as provided |
5506 | 9 |
* by Oracle in the LICENSE file that accompanied this code. |
2 | 10 |
* |
11 |
* This code is distributed in the hope that it will be useful, but WITHOUT |
|
12 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
13 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
14 |
* version 2 for more details (a copy is included in the LICENSE file that |
|
15 |
* accompanied this code). |
|
16 |
* |
|
17 |
* You should have received a copy of the GNU General Public License version |
|
18 |
* 2 along with this work; if not, write to the Free Software Foundation, |
|
19 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
20 |
* |
|
5506 | 21 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
22 |
* or visit www.oracle.com if you need additional information or have any |
|
23 |
* questions. |
|
2 | 24 |
*/ |
25 |
||
26 |
package java.util; |
|
27 |
||
28 |
import java.io.BufferedWriter; |
|
29 |
import java.io.Closeable; |
|
30 |
import java.io.IOException; |
|
31 |
import java.io.File; |
|
32 |
import java.io.FileOutputStream; |
|
33 |
import java.io.FileNotFoundException; |
|
34 |
import java.io.Flushable; |
|
35 |
import java.io.OutputStream; |
|
36 |
import java.io.OutputStreamWriter; |
|
37 |
import java.io.PrintStream; |
|
38 |
import java.io.UnsupportedEncodingException; |
|
39 |
import java.math.BigDecimal; |
|
40 |
import java.math.BigInteger; |
|
41 |
import java.math.MathContext; |
|
1823
23d42a96635e
6476425: (fmt)java.util.Formatter.print() throws IllegalArgumentException on large BigDecima
sherman
parents:
2
diff
changeset
|
42 |
import java.math.RoundingMode; |
2 | 43 |
import java.nio.charset.Charset; |
7966
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
44 |
import java.nio.charset.IllegalCharsetNameException; |
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
45 |
import java.nio.charset.UnsupportedCharsetException; |
2 | 46 |
import java.text.DateFormatSymbols; |
47 |
import java.text.DecimalFormat; |
|
48 |
import java.text.DecimalFormatSymbols; |
|
49 |
import java.text.NumberFormat; |
|
50 |
import java.util.regex.Matcher; |
|
51 |
import java.util.regex.Pattern; |
|
52 |
||
15289 | 53 |
import java.time.DateTimeException; |
54 |
import java.time.Instant; |
|
55 |
import java.time.ZoneId; |
|
56 |
import java.time.ZoneOffset; |
|
57 |
import java.time.temporal.ChronoField; |
|
58 |
import java.time.temporal.TemporalAccessor; |
|
20795 | 59 |
import java.time.temporal.TemporalQueries; |
15289 | 60 |
|
2 | 61 |
import sun.misc.DoubleConsts; |
62 |
import sun.misc.FormattedFloatingDecimal; |
|
63 |
||
64 |
/** |
|
65 |
* An interpreter for printf-style format strings. This class provides support |
|
66 |
* for layout justification and alignment, common formats for numeric, string, |
|
67 |
* and date/time data, and locale-specific output. Common Java types such as |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
68 |
* {@code byte}, {@link java.math.BigDecimal BigDecimal}, and {@link Calendar} |
2 | 69 |
* are supported. Limited formatting customization for arbitrary user types is |
70 |
* provided through the {@link Formattable} interface. |
|
71 |
* |
|
72 |
* <p> Formatters are not necessarily safe for multithreaded access. Thread |
|
73 |
* safety is optional and is the responsibility of users of methods in this |
|
74 |
* class. |
|
75 |
* |
|
76 |
* <p> Formatted printing for the Java language is heavily inspired by C's |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
77 |
* {@code printf}. Although the format strings are similar to C, some |
2 | 78 |
* customizations have been made to accommodate the Java language and exploit |
79 |
* some of its features. Also, Java formatting is more strict than C's; for |
|
80 |
* example, if a conversion is incompatible with a flag, an exception will be |
|
81 |
* thrown. In C inapplicable flags are silently ignored. The format strings |
|
82 |
* are thus intended to be recognizable to C programmers but not necessarily |
|
83 |
* completely compatible with those in C. |
|
84 |
* |
|
85 |
* <p> Examples of expected usage: |
|
86 |
* |
|
87 |
* <blockquote><pre> |
|
88 |
* StringBuilder sb = new StringBuilder(); |
|
89 |
* // Send all output to the Appendable object sb |
|
90 |
* Formatter formatter = new Formatter(sb, Locale.US); |
|
91 |
* |
|
92 |
* // Explicit argument indices may be used to re-order output. |
|
93 |
* formatter.format("%4$2s %3$2s %2$2s %1$2s", "a", "b", "c", "d") |
|
94 |
* // -> " d c b a" |
|
95 |
* |
|
96 |
* // Optional locale as the first argument can be used to get |
|
97 |
* // locale-specific formatting of numbers. The precision and width can be |
|
98 |
* // given to round and align the value. |
|
99 |
* formatter.format(Locale.FRANCE, "e = %+10.4f", Math.E); |
|
100 |
* // -> "e = +2,7183" |
|
101 |
* |
|
102 |
* // The '(' numeric flag may be used to format negative numbers with |
|
103 |
* // parentheses rather than a minus sign. Group separators are |
|
104 |
* // automatically inserted. |
|
105 |
* formatter.format("Amount gained or lost since last statement: $ %(,.2f", |
|
106 |
* balanceDelta); |
|
107 |
* // -> "Amount gained or lost since last statement: $ (6,217.58)" |
|
108 |
* </pre></blockquote> |
|
109 |
* |
|
110 |
* <p> Convenience methods for common formatting requests exist as illustrated |
|
111 |
* by the following invocations: |
|
112 |
* |
|
113 |
* <blockquote><pre> |
|
114 |
* // Writes a formatted string to System.out. |
|
115 |
* System.out.format("Local time: %tT", Calendar.getInstance()); |
|
116 |
* // -> "Local time: 13:34:18" |
|
117 |
* |
|
118 |
* // Writes formatted output to System.err. |
|
119 |
* System.err.printf("Unable to open file '%1$s': %2$s", |
|
120 |
* fileName, exception.getMessage()); |
|
121 |
* // -> "Unable to open file 'food': No such file or directory" |
|
122 |
* </pre></blockquote> |
|
123 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
124 |
* <p> Like C's {@code sprintf(3)}, Strings may be formatted using the static |
2 | 125 |
* method {@link String#format(String,Object...) String.format}: |
126 |
* |
|
127 |
* <blockquote><pre> |
|
128 |
* // Format a string containing a date. |
|
129 |
* import java.util.Calendar; |
|
130 |
* import java.util.GregorianCalendar; |
|
131 |
* import static java.util.Calendar.*; |
|
132 |
* |
|
133 |
* Calendar c = new GregorianCalendar(1995, MAY, 23); |
|
21368
7b48f137e525
5063500: Formatter spec says "char" is not an integral type
smarks
parents:
20795
diff
changeset
|
134 |
* String s = String.format("Duke's Birthday: %1$tb %1$te, %1$tY", c); |
2 | 135 |
* // -> s == "Duke's Birthday: May 23, 1995" |
136 |
* </pre></blockquote> |
|
137 |
* |
|
138 |
* <h3><a name="org">Organization</a></h3> |
|
139 |
* |
|
140 |
* <p> This specification is divided into two sections. The first section, <a |
|
141 |
* href="#summary">Summary</a>, covers the basic formatting concepts. This |
|
142 |
* section is intended for users who want to get started quickly and are |
|
143 |
* familiar with formatted printing in other programming languages. The second |
|
144 |
* section, <a href="#detail">Details</a>, covers the specific implementation |
|
145 |
* details. It is intended for users who want more precise specification of |
|
146 |
* formatting behavior. |
|
147 |
* |
|
148 |
* <h3><a name="summary">Summary</a></h3> |
|
149 |
* |
|
150 |
* <p> This section is intended to provide a brief overview of formatting |
|
151 |
* concepts. For precise behavioral details, refer to the <a |
|
152 |
* href="#detail">Details</a> section. |
|
153 |
* |
|
154 |
* <h4><a name="syntax">Format String Syntax</a></h4> |
|
155 |
* |
|
156 |
* <p> Every method which produces formatted output requires a <i>format |
|
157 |
* string</i> and an <i>argument list</i>. The format string is a {@link |
|
158 |
* String} which may contain fixed text and one or more embedded <i>format |
|
159 |
* specifiers</i>. Consider the following example: |
|
160 |
* |
|
161 |
* <blockquote><pre> |
|
162 |
* Calendar c = ...; |
|
163 |
* String s = String.format("Duke's Birthday: %1$tm %1$te,%1$tY", c); |
|
164 |
* </pre></blockquote> |
|
165 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
166 |
* This format string is the first argument to the {@code format} method. It |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
167 |
* contains three format specifiers "{@code %1$tm}", "{@code %1$te}", and |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
168 |
* "{@code %1$tY}" which indicate how the arguments should be processed and |
2 | 169 |
* where they should be inserted in the text. The remaining portions of the |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
170 |
* format string are fixed text including {@code "Dukes Birthday: "} and any |
2 | 171 |
* other spaces or punctuation. |
172 |
* |
|
173 |
* The argument list consists of all arguments passed to the method after the |
|
174 |
* format string. In the above example, the argument list is of size one and |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
175 |
* consists of the {@link java.util.Calendar Calendar} object {@code c}. |
2 | 176 |
* |
177 |
* <ul> |
|
178 |
* |
|
179 |
* <li> The format specifiers for general, character, and numeric types have |
|
180 |
* the following syntax: |
|
181 |
* |
|
182 |
* <blockquote><pre> |
|
183 |
* %[argument_index$][flags][width][.precision]conversion |
|
184 |
* </pre></blockquote> |
|
185 |
* |
|
186 |
* <p> The optional <i>argument_index</i> is a decimal integer indicating the |
|
187 |
* position of the argument in the argument list. The first argument is |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
188 |
* referenced by "{@code 1$}", the second by "{@code 2$}", etc. |
2 | 189 |
* |
190 |
* <p> The optional <i>flags</i> is a set of characters that modify the output |
|
191 |
* format. The set of valid flags depends on the conversion. |
|
192 |
* |
|
18797
ced9bcc861d9
6178739: (fmt) Formatter.format("%0.4f\n", 56789.456789) generates MissingFormatWidthException
bpb
parents:
18774
diff
changeset
|
193 |
* <p> The optional <i>width</i> is a positive decimal integer indicating |
2 | 194 |
* the minimum number of characters to be written to the output. |
195 |
* |
|
196 |
* <p> The optional <i>precision</i> is a non-negative decimal integer usually |
|
197 |
* used to restrict the number of characters. The specific behavior depends on |
|
198 |
* the conversion. |
|
199 |
* |
|
200 |
* <p> The required <i>conversion</i> is a character indicating how the |
|
201 |
* argument should be formatted. The set of valid conversions for a given |
|
202 |
* argument depends on the argument's data type. |
|
203 |
* |
|
204 |
* <li> The format specifiers for types which are used to represents dates and |
|
205 |
* times have the following syntax: |
|
206 |
* |
|
207 |
* <blockquote><pre> |
|
208 |
* %[argument_index$][flags][width]conversion |
|
209 |
* </pre></blockquote> |
|
210 |
* |
|
211 |
* <p> The optional <i>argument_index</i>, <i>flags</i> and <i>width</i> are |
|
212 |
* defined as above. |
|
213 |
* |
|
214 |
* <p> The required <i>conversion</i> is a two character sequence. The first |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
215 |
* character is {@code 't'} or {@code 'T'}. The second character indicates |
2 | 216 |
* the format to be used. These characters are similar to but not completely |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
217 |
* identical to those defined by GNU {@code date} and POSIX |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
218 |
* {@code strftime(3c)}. |
2 | 219 |
* |
220 |
* <li> The format specifiers which do not correspond to arguments have the |
|
221 |
* following syntax: |
|
222 |
* |
|
223 |
* <blockquote><pre> |
|
224 |
* %[flags][width]conversion |
|
225 |
* </pre></blockquote> |
|
226 |
* |
|
227 |
* <p> The optional <i>flags</i> and <i>width</i> is defined as above. |
|
228 |
* |
|
229 |
* <p> The required <i>conversion</i> is a character indicating content to be |
|
230 |
* inserted in the output. |
|
231 |
* |
|
232 |
* </ul> |
|
233 |
* |
|
234 |
* <h4> Conversions </h4> |
|
235 |
* |
|
236 |
* <p> Conversions are divided into the following categories: |
|
237 |
* |
|
238 |
* <ol> |
|
239 |
* |
|
240 |
* <li> <b>General</b> - may be applied to any argument |
|
241 |
* type |
|
242 |
* |
|
243 |
* <li> <b>Character</b> - may be applied to basic types which represent |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
244 |
* Unicode characters: {@code char}, {@link Character}, {@code byte}, {@link |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
245 |
* Byte}, {@code short}, and {@link Short}. This conversion may also be |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
246 |
* applied to the types {@code int} and {@link Integer} when {@link |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
247 |
* Character#isValidCodePoint} returns {@code true} |
2 | 248 |
* |
249 |
* <li> <b>Numeric</b> |
|
250 |
* |
|
251 |
* <ol> |
|
252 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
253 |
* <li> <b>Integral</b> - may be applied to Java integral types: {@code byte}, |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
254 |
* {@link Byte}, {@code short}, {@link Short}, {@code int} and {@link |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
255 |
* Integer}, {@code long}, {@link Long}, and {@link java.math.BigInteger |
21368
7b48f137e525
5063500: Formatter spec says "char" is not an integral type
smarks
parents:
20795
diff
changeset
|
256 |
* BigInteger} (but not {@code char} or {@link Character}) |
2 | 257 |
* |
258 |
* <li><b>Floating Point</b> - may be applied to Java floating-point types: |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
259 |
* {@code float}, {@link Float}, {@code double}, {@link Double}, and {@link |
2 | 260 |
* java.math.BigDecimal BigDecimal} |
261 |
* |
|
262 |
* </ol> |
|
263 |
* |
|
264 |
* <li> <b>Date/Time</b> - may be applied to Java types which are capable of |
|
15289 | 265 |
* encoding a date or time: {@code long}, {@link Long}, {@link Calendar}, |
266 |
* {@link Date} and {@link TemporalAccessor TemporalAccessor} |
|
2 | 267 |
* |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
268 |
* <li> <b>Percent</b> - produces a literal {@code '%'} |
2 | 269 |
* (<tt>'\u0025'</tt>) |
270 |
* |
|
271 |
* <li> <b>Line Separator</b> - produces the platform-specific line separator |
|
272 |
* |
|
273 |
* </ol> |
|
274 |
* |
|
275 |
* <p> The following table summarizes the supported conversions. Conversions |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
276 |
* denoted by an upper-case character (i.e. {@code 'B'}, {@code 'H'}, |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
277 |
* {@code 'S'}, {@code 'C'}, {@code 'X'}, {@code 'E'}, {@code 'G'}, |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
278 |
* {@code 'A'}, and {@code 'T'}) are the same as those for the corresponding |
2 | 279 |
* lower-case conversion characters except that the result is converted to |
280 |
* upper case according to the rules of the prevailing {@link java.util.Locale |
|
281 |
* Locale}. The result is equivalent to the following invocation of {@link |
|
282 |
* String#toUpperCase()} |
|
283 |
* |
|
284 |
* <pre> |
|
285 |
* out.toUpperCase() </pre> |
|
286 |
* |
|
287 |
* <table cellpadding=5 summary="genConv"> |
|
288 |
* |
|
289 |
* <tr><th valign="bottom"> Conversion |
|
290 |
* <th valign="bottom"> Argument Category |
|
291 |
* <th valign="bottom"> Description |
|
292 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
293 |
* <tr><td valign="top"> {@code 'b'}, {@code 'B'} |
2 | 294 |
* <td valign="top"> general |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
295 |
* <td> If the argument <i>arg</i> is {@code null}, then the result is |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
296 |
* "{@code false}". If <i>arg</i> is a {@code boolean} or {@link |
2 | 297 |
* Boolean}, then the result is the string returned by {@link |
298 |
* String#valueOf(boolean) String.valueOf(arg)}. Otherwise, the result is |
|
299 |
* "true". |
|
300 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
301 |
* <tr><td valign="top"> {@code 'h'}, {@code 'H'} |
2 | 302 |
* <td valign="top"> general |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
303 |
* <td> If the argument <i>arg</i> is {@code null}, then the result is |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
304 |
* "{@code null}". Otherwise, the result is obtained by invoking |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
305 |
* {@code Integer.toHexString(arg.hashCode())}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
306 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
307 |
* <tr><td valign="top"> {@code 's'}, {@code 'S'} |
2 | 308 |
* <td valign="top"> general |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
309 |
* <td> If the argument <i>arg</i> is {@code null}, then the result is |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
310 |
* "{@code null}". If <i>arg</i> implements {@link Formattable}, then |
2 | 311 |
* {@link Formattable#formatTo arg.formatTo} is invoked. Otherwise, the |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
312 |
* result is obtained by invoking {@code arg.toString()}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
313 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
314 |
* <tr><td valign="top">{@code 'c'}, {@code 'C'} |
2 | 315 |
* <td valign="top"> character |
316 |
* <td> The result is a Unicode character |
|
317 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
318 |
* <tr><td valign="top">{@code 'd'} |
2 | 319 |
* <td valign="top"> integral |
320 |
* <td> The result is formatted as a decimal integer |
|
321 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
322 |
* <tr><td valign="top">{@code 'o'} |
2 | 323 |
* <td valign="top"> integral |
324 |
* <td> The result is formatted as an octal integer |
|
325 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
326 |
* <tr><td valign="top">{@code 'x'}, {@code 'X'} |
2 | 327 |
* <td valign="top"> integral |
328 |
* <td> The result is formatted as a hexadecimal integer |
|
329 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
330 |
* <tr><td valign="top">{@code 'e'}, {@code 'E'} |
2 | 331 |
* <td valign="top"> floating point |
332 |
* <td> The result is formatted as a decimal number in computerized |
|
333 |
* scientific notation |
|
334 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
335 |
* <tr><td valign="top">{@code 'f'} |
2 | 336 |
* <td valign="top"> floating point |
337 |
* <td> The result is formatted as a decimal number |
|
338 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
339 |
* <tr><td valign="top">{@code 'g'}, {@code 'G'} |
2 | 340 |
* <td valign="top"> floating point |
341 |
* <td> The result is formatted using computerized scientific notation or |
|
342 |
* decimal format, depending on the precision and the value after rounding. |
|
343 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
344 |
* <tr><td valign="top">{@code 'a'}, {@code 'A'} |
2 | 345 |
* <td valign="top"> floating point |
346 |
* <td> The result is formatted as a hexadecimal floating-point number with |
|
15524
b77777dcac17
5035569: Formatter should document that %a conversion unsupported for BigDecimal args
alanb
parents:
15289
diff
changeset
|
347 |
* a significand and an exponent. This conversion is <b>not</b> supported |
b77777dcac17
5035569: Formatter should document that %a conversion unsupported for BigDecimal args
alanb
parents:
15289
diff
changeset
|
348 |
* for the {@code BigDecimal} type despite the latter's being in the |
b77777dcac17
5035569: Formatter should document that %a conversion unsupported for BigDecimal args
alanb
parents:
15289
diff
changeset
|
349 |
* <i>floating point</i> argument category. |
2 | 350 |
* |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
351 |
* <tr><td valign="top">{@code 't'}, {@code 'T'} |
2 | 352 |
* <td valign="top"> date/time |
353 |
* <td> Prefix for date and time conversion characters. See <a |
|
354 |
* href="#dt">Date/Time Conversions</a>. |
|
355 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
356 |
* <tr><td valign="top">{@code '%'} |
2 | 357 |
* <td valign="top"> percent |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
358 |
* <td> The result is a literal {@code '%'} (<tt>'\u0025'</tt>) |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
359 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
360 |
* <tr><td valign="top">{@code 'n'} |
2 | 361 |
* <td valign="top"> line separator |
362 |
* <td> The result is the platform-specific line separator |
|
363 |
* |
|
364 |
* </table> |
|
365 |
* |
|
366 |
* <p> Any characters not explicitly defined as conversions are illegal and are |
|
367 |
* reserved for future extensions. |
|
368 |
* |
|
369 |
* <h4><a name="dt">Date/Time Conversions</a></h4> |
|
370 |
* |
|
371 |
* <p> The following date and time conversion suffix characters are defined for |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
372 |
* the {@code 't'} and {@code 'T'} conversions. The types are similar to but |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
373 |
* not completely identical to those defined by GNU {@code date} and POSIX |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
374 |
* {@code strftime(3c)}. Additional conversion types are provided to access |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
375 |
* Java-specific functionality (e.g. {@code 'L'} for milliseconds within the |
2 | 376 |
* second). |
377 |
* |
|
378 |
* <p> The following conversion characters are used for formatting times: |
|
379 |
* |
|
380 |
* <table cellpadding=5 summary="time"> |
|
381 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
382 |
* <tr><td valign="top"> {@code 'H'} |
2 | 383 |
* <td> Hour of the day for the 24-hour clock, formatted as two digits with |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
384 |
* a leading zero as necessary i.e. {@code 00 - 23}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
385 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
386 |
* <tr><td valign="top">{@code 'I'} |
2 | 387 |
* <td> Hour for the 12-hour clock, formatted as two digits with a leading |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
388 |
* zero as necessary, i.e. {@code 01 - 12}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
389 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
390 |
* <tr><td valign="top">{@code 'k'} |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
391 |
* <td> Hour of the day for the 24-hour clock, i.e. {@code 0 - 23}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
392 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
393 |
* <tr><td valign="top">{@code 'l'} |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
394 |
* <td> Hour for the 12-hour clock, i.e. {@code 1 - 12}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
395 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
396 |
* <tr><td valign="top">{@code 'M'} |
2 | 397 |
* <td> Minute within the hour formatted as two digits with a leading zero |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
398 |
* as necessary, i.e. {@code 00 - 59}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
399 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
400 |
* <tr><td valign="top">{@code 'S'} |
2 | 401 |
* <td> Seconds within the minute, formatted as two digits with a leading |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
402 |
* zero as necessary, i.e. {@code 00 - 60} ("{@code 60}" is a special |
2 | 403 |
* value required to support leap seconds). |
404 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
405 |
* <tr><td valign="top">{@code 'L'} |
2 | 406 |
* <td> Millisecond within the second formatted as three digits with |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
407 |
* leading zeros as necessary, i.e. {@code 000 - 999}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
408 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
409 |
* <tr><td valign="top">{@code 'N'} |
2 | 410 |
* <td> Nanosecond within the second, formatted as nine digits with leading |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
411 |
* zeros as necessary, i.e. {@code 000000000 - 999999999}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
412 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
413 |
* <tr><td valign="top">{@code 'p'} |
2 | 414 |
* <td> Locale-specific {@linkplain |
415 |
* java.text.DateFormatSymbols#getAmPmStrings morning or afternoon} marker |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
416 |
* in lower case, e.g."{@code am}" or "{@code pm}". Use of the conversion |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
417 |
* prefix {@code 'T'} forces this output to upper case. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
418 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
419 |
* <tr><td valign="top">{@code 'z'} |
2 | 420 |
* <td> <a href="http://www.ietf.org/rfc/rfc0822.txt">RFC 822</a> |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
421 |
* style numeric time zone offset from GMT, e.g. {@code -0800}. This |
2 | 422 |
* value will be adjusted as necessary for Daylight Saving Time. For |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
423 |
* {@code long}, {@link Long}, and {@link Date} the time zone used is |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
424 |
* the {@linkplain TimeZone#getDefault() default time zone} for this |
2 | 425 |
* instance of the Java virtual machine. |
426 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
427 |
* <tr><td valign="top">{@code 'Z'} |
2 | 428 |
* <td> A string representing the abbreviation for the time zone. This |
429 |
* value will be adjusted as necessary for Daylight Saving Time. For |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
430 |
* {@code long}, {@link Long}, and {@link Date} the time zone used is |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
431 |
* the {@linkplain TimeZone#getDefault() default time zone} for this |
2 | 432 |
* instance of the Java virtual machine. The Formatter's locale will |
433 |
* supersede the locale of the argument (if any). |
|
434 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
435 |
* <tr><td valign="top">{@code 's'} |
2 | 436 |
* <td> Seconds since the beginning of the epoch starting at 1 January 1970 |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
437 |
* {@code 00:00:00} UTC, i.e. {@code Long.MIN_VALUE/1000} to |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
438 |
* {@code Long.MAX_VALUE/1000}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
439 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
440 |
* <tr><td valign="top">{@code 'Q'} |
2 | 441 |
* <td> Milliseconds since the beginning of the epoch starting at 1 January |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
442 |
* 1970 {@code 00:00:00} UTC, i.e. {@code Long.MIN_VALUE} to |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
443 |
* {@code Long.MAX_VALUE}. |
2 | 444 |
* |
445 |
* </table> |
|
446 |
* |
|
447 |
* <p> The following conversion characters are used for formatting dates: |
|
448 |
* |
|
449 |
* <table cellpadding=5 summary="date"> |
|
450 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
451 |
* <tr><td valign="top">{@code 'B'} |
2 | 452 |
* <td> Locale-specific {@linkplain java.text.DateFormatSymbols#getMonths |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
453 |
* full month name}, e.g. {@code "January"}, {@code "February"}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
454 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
455 |
* <tr><td valign="top">{@code 'b'} |
2 | 456 |
* <td> Locale-specific {@linkplain |
457 |
* java.text.DateFormatSymbols#getShortMonths abbreviated month name}, |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
458 |
* e.g. {@code "Jan"}, {@code "Feb"}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
459 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
460 |
* <tr><td valign="top">{@code 'h'} |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
461 |
* <td> Same as {@code 'b'}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
462 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
463 |
* <tr><td valign="top">{@code 'A'} |
2 | 464 |
* <td> Locale-specific full name of the {@linkplain |
465 |
* java.text.DateFormatSymbols#getWeekdays day of the week}, |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
466 |
* e.g. {@code "Sunday"}, {@code "Monday"} |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
467 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
468 |
* <tr><td valign="top">{@code 'a'} |
2 | 469 |
* <td> Locale-specific short name of the {@linkplain |
470 |
* java.text.DateFormatSymbols#getShortWeekdays day of the week}, |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
471 |
* e.g. {@code "Sun"}, {@code "Mon"} |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
472 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
473 |
* <tr><td valign="top">{@code 'C'} |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
474 |
* <td> Four-digit year divided by {@code 100}, formatted as two digits |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
475 |
* with leading zero as necessary, i.e. {@code 00 - 99} |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
476 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
477 |
* <tr><td valign="top">{@code 'Y'} |
2 | 478 |
* <td> Year, formatted as at least four digits with leading zeros as |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
479 |
* necessary, e.g. {@code 0092} equals {@code 92} CE for the Gregorian |
2 | 480 |
* calendar. |
481 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
482 |
* <tr><td valign="top">{@code 'y'} |
2 | 483 |
* <td> Last two digits of the year, formatted with leading zeros as |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
484 |
* necessary, i.e. {@code 00 - 99}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
485 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
486 |
* <tr><td valign="top">{@code 'j'} |
2 | 487 |
* <td> Day of year, formatted as three digits with leading zeros as |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
488 |
* necessary, e.g. {@code 001 - 366} for the Gregorian calendar. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
489 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
490 |
* <tr><td valign="top">{@code 'm'} |
2 | 491 |
* <td> Month, formatted as two digits with leading zeros as necessary, |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
492 |
* i.e. {@code 01 - 13}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
493 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
494 |
* <tr><td valign="top">{@code 'd'} |
2 | 495 |
* <td> Day of month, formatted as two digits with leading zeros as |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
496 |
* necessary, i.e. {@code 01 - 31} |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
497 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
498 |
* <tr><td valign="top">{@code 'e'} |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
499 |
* <td> Day of month, formatted as two digits, i.e. {@code 1 - 31}. |
2 | 500 |
* |
501 |
* </table> |
|
502 |
* |
|
503 |
* <p> The following conversion characters are used for formatting common |
|
504 |
* date/time compositions. |
|
505 |
* |
|
506 |
* <table cellpadding=5 summary="composites"> |
|
507 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
508 |
* <tr><td valign="top">{@code 'R'} |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
509 |
* <td> Time formatted for the 24-hour clock as {@code "%tH:%tM"} |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
510 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
511 |
* <tr><td valign="top">{@code 'T'} |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
512 |
* <td> Time formatted for the 24-hour clock as {@code "%tH:%tM:%tS"}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
513 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
514 |
* <tr><td valign="top">{@code 'r'} |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
515 |
* <td> Time formatted for the 12-hour clock as {@code "%tI:%tM:%tS %Tp"}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
516 |
* The location of the morning or afternoon marker ({@code '%Tp'}) may be |
2 | 517 |
* locale-dependent. |
518 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
519 |
* <tr><td valign="top">{@code 'D'} |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
520 |
* <td> Date formatted as {@code "%tm/%td/%ty"}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
521 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
522 |
* <tr><td valign="top">{@code 'F'} |
2 | 523 |
* <td> <a href="http://www.w3.org/TR/NOTE-datetime">ISO 8601</a> |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
524 |
* complete date formatted as {@code "%tY-%tm-%td"}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
525 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
526 |
* <tr><td valign="top">{@code 'c'} |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
527 |
* <td> Date and time formatted as {@code "%ta %tb %td %tT %tZ %tY"}, |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
528 |
* e.g. {@code "Sun Jul 20 16:17:00 EDT 1969"}. |
2 | 529 |
* |
530 |
* </table> |
|
531 |
* |
|
532 |
* <p> Any characters not explicitly defined as date/time conversion suffixes |
|
533 |
* are illegal and are reserved for future extensions. |
|
534 |
* |
|
535 |
* <h4> Flags </h4> |
|
536 |
* |
|
537 |
* <p> The following table summarizes the supported flags. <i>y</i> means the |
|
538 |
* flag is supported for the indicated argument types. |
|
539 |
* |
|
540 |
* <table cellpadding=5 summary="genConv"> |
|
541 |
* |
|
542 |
* <tr><th valign="bottom"> Flag <th valign="bottom"> General |
|
543 |
* <th valign="bottom"> Character <th valign="bottom"> Integral |
|
544 |
* <th valign="bottom"> Floating Point |
|
545 |
* <th valign="bottom"> Date/Time |
|
546 |
* <th valign="bottom"> Description |
|
547 |
* |
|
548 |
* <tr><td> '-' <td align="center" valign="top"> y |
|
549 |
* <td align="center" valign="top"> y |
|
550 |
* <td align="center" valign="top"> y |
|
551 |
* <td align="center" valign="top"> y |
|
552 |
* <td align="center" valign="top"> y |
|
553 |
* <td> The result will be left-justified. |
|
554 |
* |
|
555 |
* <tr><td> '#' <td align="center" valign="top"> y<sup>1</sup> |
|
556 |
* <td align="center" valign="top"> - |
|
557 |
* <td align="center" valign="top"> y<sup>3</sup> |
|
558 |
* <td align="center" valign="top"> y |
|
559 |
* <td align="center" valign="top"> - |
|
560 |
* <td> The result should use a conversion-dependent alternate form |
|
561 |
* |
|
562 |
* <tr><td> '+' <td align="center" valign="top"> - |
|
563 |
* <td align="center" valign="top"> - |
|
564 |
* <td align="center" valign="top"> y<sup>4</sup> |
|
565 |
* <td align="center" valign="top"> y |
|
566 |
* <td align="center" valign="top"> - |
|
567 |
* <td> The result will always include a sign |
|
568 |
* |
|
569 |
* <tr><td> ' ' <td align="center" valign="top"> - |
|
570 |
* <td align="center" valign="top"> - |
|
571 |
* <td align="center" valign="top"> y<sup>4</sup> |
|
572 |
* <td align="center" valign="top"> y |
|
573 |
* <td align="center" valign="top"> - |
|
574 |
* <td> The result will include a leading space for positive values |
|
575 |
* |
|
576 |
* <tr><td> '0' <td align="center" valign="top"> - |
|
577 |
* <td align="center" valign="top"> - |
|
578 |
* <td align="center" valign="top"> y |
|
579 |
* <td align="center" valign="top"> y |
|
580 |
* <td align="center" valign="top"> - |
|
581 |
* <td> The result will be zero-padded |
|
582 |
* |
|
583 |
* <tr><td> ',' <td align="center" valign="top"> - |
|
584 |
* <td align="center" valign="top"> - |
|
585 |
* <td align="center" valign="top"> y<sup>2</sup> |
|
586 |
* <td align="center" valign="top"> y<sup>5</sup> |
|
587 |
* <td align="center" valign="top"> - |
|
588 |
* <td> The result will include locale-specific {@linkplain |
|
589 |
* java.text.DecimalFormatSymbols#getGroupingSeparator grouping separators} |
|
590 |
* |
|
591 |
* <tr><td> '(' <td align="center" valign="top"> - |
|
592 |
* <td align="center" valign="top"> - |
|
593 |
* <td align="center" valign="top"> y<sup>4</sup> |
|
594 |
* <td align="center" valign="top"> y<sup>5</sup> |
|
595 |
* <td align="center"> - |
|
596 |
* <td> The result will enclose negative numbers in parentheses |
|
597 |
* |
|
598 |
* </table> |
|
599 |
* |
|
600 |
* <p> <sup>1</sup> Depends on the definition of {@link Formattable}. |
|
601 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
602 |
* <p> <sup>2</sup> For {@code 'd'} conversion only. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
603 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
604 |
* <p> <sup>3</sup> For {@code 'o'}, {@code 'x'}, and {@code 'X'} |
2 | 605 |
* conversions only. |
606 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
607 |
* <p> <sup>4</sup> For {@code 'd'}, {@code 'o'}, {@code 'x'}, and |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
608 |
* {@code 'X'} conversions applied to {@link java.math.BigInteger BigInteger} |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
609 |
* or {@code 'd'} applied to {@code byte}, {@link Byte}, {@code short}, {@link |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
610 |
* Short}, {@code int} and {@link Integer}, {@code long}, and {@link Long}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
611 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
612 |
* <p> <sup>5</sup> For {@code 'e'}, {@code 'E'}, {@code 'f'}, |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
613 |
* {@code 'g'}, and {@code 'G'} conversions only. |
2 | 614 |
* |
615 |
* <p> Any characters not explicitly defined as flags are illegal and are |
|
616 |
* reserved for future extensions. |
|
617 |
* |
|
618 |
* <h4> Width </h4> |
|
619 |
* |
|
620 |
* <p> The width is the minimum number of characters to be written to the |
|
621 |
* output. For the line separator conversion, width is not applicable; if it |
|
622 |
* is provided, an exception will be thrown. |
|
623 |
* |
|
624 |
* <h4> Precision </h4> |
|
625 |
* |
|
626 |
* <p> For general argument types, the precision is the maximum number of |
|
627 |
* characters to be written to the output. |
|
628 |
* |
|
19196
5368bd038f19
6476168: (fmt) Inconsistency formatting subnormal doubles with hexadecimal conversion
bpb
parents:
18797
diff
changeset
|
629 |
* <p> For the floating-point conversions {@code 'a'}, {@code 'A'}, {@code 'e'}, |
5368bd038f19
6476168: (fmt) Inconsistency formatting subnormal doubles with hexadecimal conversion
bpb
parents:
18797
diff
changeset
|
630 |
* {@code 'E'}, and {@code 'f'} the precision is the number of digits after the |
5368bd038f19
6476168: (fmt) Inconsistency formatting subnormal doubles with hexadecimal conversion
bpb
parents:
18797
diff
changeset
|
631 |
* radix point. If the conversion is {@code 'g'} or {@code 'G'}, then the |
2 | 632 |
* precision is the total number of digits in the resulting magnitude after |
19196
5368bd038f19
6476168: (fmt) Inconsistency formatting subnormal doubles with hexadecimal conversion
bpb
parents:
18797
diff
changeset
|
633 |
* rounding. |
2 | 634 |
* |
635 |
* <p> For character, integral, and date/time argument types and the percent |
|
636 |
* and line separator conversions, the precision is not applicable; if a |
|
637 |
* precision is provided, an exception will be thrown. |
|
638 |
* |
|
639 |
* <h4> Argument Index </h4> |
|
640 |
* |
|
641 |
* <p> The argument index is a decimal integer indicating the position of the |
|
642 |
* argument in the argument list. The first argument is referenced by |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
643 |
* "{@code 1$}", the second by "{@code 2$}", etc. |
2 | 644 |
* |
645 |
* <p> Another way to reference arguments by position is to use the |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
646 |
* {@code '<'} (<tt>'\u003c'</tt>) flag, which causes the argument for |
2 | 647 |
* the previous format specifier to be re-used. For example, the following two |
648 |
* statements would produce identical strings: |
|
649 |
* |
|
650 |
* <blockquote><pre> |
|
651 |
* Calendar c = ...; |
|
652 |
* String s1 = String.format("Duke's Birthday: %1$tm %1$te,%1$tY", c); |
|
653 |
* |
|
654 |
* String s2 = String.format("Duke's Birthday: %1$tm %<te,%<tY", c); |
|
655 |
* </pre></blockquote> |
|
656 |
* |
|
657 |
* <hr> |
|
658 |
* <h3><a name="detail">Details</a></h3> |
|
659 |
* |
|
660 |
* <p> This section is intended to provide behavioral details for formatting, |
|
661 |
* including conditions and exceptions, supported data types, localization, and |
|
662 |
* interactions between flags, conversions, and data types. For an overview of |
|
663 |
* formatting concepts, refer to the <a href="#summary">Summary</a> |
|
664 |
* |
|
665 |
* <p> Any characters not explicitly defined as conversions, date/time |
|
666 |
* conversion suffixes, or flags are illegal and are reserved for |
|
667 |
* future extensions. Use of such a character in a format string will |
|
668 |
* cause an {@link UnknownFormatConversionException} or {@link |
|
669 |
* UnknownFormatFlagsException} to be thrown. |
|
670 |
* |
|
671 |
* <p> If the format specifier contains a width or precision with an invalid |
|
672 |
* value or which is otherwise unsupported, then a {@link |
|
673 |
* IllegalFormatWidthException} or {@link IllegalFormatPrecisionException} |
|
674 |
* respectively will be thrown. |
|
675 |
* |
|
676 |
* <p> If a format specifier contains a conversion character that is not |
|
677 |
* applicable to the corresponding argument, then an {@link |
|
678 |
* IllegalFormatConversionException} will be thrown. |
|
679 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
680 |
* <p> All specified exceptions may be thrown by any of the {@code format} |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
681 |
* methods of {@code Formatter} as well as by any {@code format} convenience |
2 | 682 |
* methods such as {@link String#format(String,Object...) String.format} and |
683 |
* {@link java.io.PrintStream#printf(String,Object...) PrintStream.printf}. |
|
684 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
685 |
* <p> Conversions denoted by an upper-case character (i.e. {@code 'B'}, |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
686 |
* {@code 'H'}, {@code 'S'}, {@code 'C'}, {@code 'X'}, {@code 'E'}, |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
687 |
* {@code 'G'}, {@code 'A'}, and {@code 'T'}) are the same as those for the |
2 | 688 |
* corresponding lower-case conversion characters except that the result is |
689 |
* converted to upper case according to the rules of the prevailing {@link |
|
690 |
* java.util.Locale Locale}. The result is equivalent to the following |
|
691 |
* invocation of {@link String#toUpperCase()} |
|
692 |
* |
|
693 |
* <pre> |
|
694 |
* out.toUpperCase() </pre> |
|
695 |
* |
|
696 |
* <h4><a name="dgen">General</a></h4> |
|
697 |
* |
|
698 |
* <p> The following general conversions may be applied to any argument type: |
|
699 |
* |
|
700 |
* <table cellpadding=5 summary="dgConv"> |
|
701 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
702 |
* <tr><td valign="top"> {@code 'b'} |
2 | 703 |
* <td valign="top"> <tt>'\u0062'</tt> |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
704 |
* <td> Produces either "{@code true}" or "{@code false}" as returned by |
2 | 705 |
* {@link Boolean#toString(boolean)}. |
706 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
707 |
* <p> If the argument is {@code null}, then the result is |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
708 |
* "{@code false}". If the argument is a {@code boolean} or {@link |
2 | 709 |
* Boolean}, then the result is the string returned by {@link |
710 |
* String#valueOf(boolean) String.valueOf()}. Otherwise, the result is |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
711 |
* "{@code true}". |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
712 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
713 |
* <p> If the {@code '#'} flag is given, then a {@link |
2 | 714 |
* FormatFlagsConversionMismatchException} will be thrown. |
715 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
716 |
* <tr><td valign="top"> {@code 'B'} |
2 | 717 |
* <td valign="top"> <tt>'\u0042'</tt> |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
718 |
* <td> The upper-case variant of {@code 'b'}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
719 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
720 |
* <tr><td valign="top"> {@code 'h'} |
2 | 721 |
* <td valign="top"> <tt>'\u0068'</tt> |
722 |
* <td> Produces a string representing the hash code value of the object. |
|
723 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
724 |
* <p> If the argument, <i>arg</i> is {@code null}, then the |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
725 |
* result is "{@code null}". Otherwise, the result is obtained |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
726 |
* by invoking {@code Integer.toHexString(arg.hashCode())}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
727 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
728 |
* <p> If the {@code '#'} flag is given, then a {@link |
2 | 729 |
* FormatFlagsConversionMismatchException} will be thrown. |
730 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
731 |
* <tr><td valign="top"> {@code 'H'} |
2 | 732 |
* <td valign="top"> <tt>'\u0048'</tt> |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
733 |
* <td> The upper-case variant of {@code 'h'}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
734 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
735 |
* <tr><td valign="top"> {@code 's'} |
2 | 736 |
* <td valign="top"> <tt>'\u0073'</tt> |
737 |
* <td> Produces a string. |
|
738 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
739 |
* <p> If the argument is {@code null}, then the result is |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
740 |
* "{@code null}". If the argument implements {@link Formattable}, then |
2 | 741 |
* its {@link Formattable#formatTo formatTo} method is invoked. |
742 |
* Otherwise, the result is obtained by invoking the argument's |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
743 |
* {@code toString()} method. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
744 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
745 |
* <p> If the {@code '#'} flag is given and the argument is not a {@link |
2 | 746 |
* Formattable} , then a {@link FormatFlagsConversionMismatchException} |
747 |
* will be thrown. |
|
748 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
749 |
* <tr><td valign="top"> {@code 'S'} |
2 | 750 |
* <td valign="top"> <tt>'\u0053'</tt> |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
751 |
* <td> The upper-case variant of {@code 's'}. |
2 | 752 |
* |
753 |
* </table> |
|
754 |
* |
|
755 |
* <p> The following <a name="dFlags">flags</a> apply to general conversions: |
|
756 |
* |
|
757 |
* <table cellpadding=5 summary="dFlags"> |
|
758 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
759 |
* <tr><td valign="top"> {@code '-'} |
2 | 760 |
* <td valign="top"> <tt>'\u002d'</tt> |
761 |
* <td> Left justifies the output. Spaces (<tt>'\u0020'</tt>) will be |
|
762 |
* added at the end of the converted value as required to fill the minimum |
|
763 |
* width of the field. If the width is not provided, then a {@link |
|
764 |
* MissingFormatWidthException} will be thrown. If this flag is not given |
|
765 |
* then the output will be right-justified. |
|
766 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
767 |
* <tr><td valign="top"> {@code '#'} |
2 | 768 |
* <td valign="top"> <tt>'\u0023'</tt> |
769 |
* <td> Requires the output use an alternate form. The definition of the |
|
770 |
* form is specified by the conversion. |
|
771 |
* |
|
772 |
* </table> |
|
773 |
* |
|
774 |
* <p> The <a name="genWidth">width</a> is the minimum number of characters to |
|
775 |
* be written to the |
|
776 |
* output. If the length of the converted value is less than the width then |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
777 |
* the output will be padded by <tt>' '</tt> (<tt>'\u0020'</tt>) |
2 | 778 |
* until the total number of characters equals the width. The padding is on |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
779 |
* the left by default. If the {@code '-'} flag is given, then the padding |
2 | 780 |
* will be on the right. If the width is not specified then there is no |
781 |
* minimum. |
|
782 |
* |
|
783 |
* <p> The precision is the maximum number of characters to be written to the |
|
784 |
* output. The precision is applied before the width, thus the output will be |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
785 |
* truncated to {@code precision} characters even if the width is greater than |
2 | 786 |
* the precision. If the precision is not specified then there is no explicit |
787 |
* limit on the number of characters. |
|
788 |
* |
|
789 |
* <h4><a name="dchar">Character</a></h4> |
|
790 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
791 |
* This conversion may be applied to {@code char} and {@link Character}. It |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
792 |
* may also be applied to the types {@code byte}, {@link Byte}, |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
793 |
* {@code short}, and {@link Short}, {@code int} and {@link Integer} when |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
794 |
* {@link Character#isValidCodePoint} returns {@code true}. If it returns |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
795 |
* {@code false} then an {@link IllegalFormatCodePointException} will be |
2 | 796 |
* thrown. |
797 |
* |
|
798 |
* <table cellpadding=5 summary="charConv"> |
|
799 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
800 |
* <tr><td valign="top"> {@code 'c'} |
2 | 801 |
* <td valign="top"> <tt>'\u0063'</tt> |
802 |
* <td> Formats the argument as a Unicode character as described in <a |
|
803 |
* href="../lang/Character.html#unicode">Unicode Character |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
804 |
* Representation</a>. This may be more than one 16-bit {@code char} in |
2 | 805 |
* the case where the argument represents a supplementary character. |
806 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
807 |
* <p> If the {@code '#'} flag is given, then a {@link |
2 | 808 |
* FormatFlagsConversionMismatchException} will be thrown. |
809 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
810 |
* <tr><td valign="top"> {@code 'C'} |
2 | 811 |
* <td valign="top"> <tt>'\u0043'</tt> |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
812 |
* <td> The upper-case variant of {@code 'c'}. |
2 | 813 |
* |
814 |
* </table> |
|
815 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
816 |
* <p> The {@code '-'} flag defined for <a href="#dFlags">General |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
817 |
* conversions</a> applies. If the {@code '#'} flag is given, then a {@link |
2 | 818 |
* FormatFlagsConversionMismatchException} will be thrown. |
819 |
* |
|
820 |
* <p> The width is defined as for <a href="#genWidth">General conversions</a>. |
|
821 |
* |
|
822 |
* <p> The precision is not applicable. If the precision is specified then an |
|
823 |
* {@link IllegalFormatPrecisionException} will be thrown. |
|
824 |
* |
|
825 |
* <h4><a name="dnum">Numeric</a></h4> |
|
826 |
* |
|
827 |
* <p> Numeric conversions are divided into the following categories: |
|
828 |
* |
|
829 |
* <ol> |
|
830 |
* |
|
831 |
* <li> <a href="#dnint"><b>Byte, Short, Integer, and Long</b></a> |
|
832 |
* |
|
833 |
* <li> <a href="#dnbint"><b>BigInteger</b></a> |
|
834 |
* |
|
835 |
* <li> <a href="#dndec"><b>Float and Double</b></a> |
|
836 |
* |
|
9689
53a4e9b16900
7043234: (fmt) java.util.Formatter links in javadoc to BigDecimal need to be fixed
sherman
parents:
9266
diff
changeset
|
837 |
* <li> <a href="#dnbdec"><b>BigDecimal</b></a> |
2 | 838 |
* |
839 |
* </ol> |
|
840 |
* |
|
841 |
* <p> Numeric types will be formatted according to the following algorithm: |
|
842 |
* |
|
18774 | 843 |
* <p><b><a name="L10nAlgorithm"> Number Localization Algorithm</a></b> |
2 | 844 |
* |
845 |
* <p> After digits are obtained for the integer part, fractional part, and |
|
846 |
* exponent (as appropriate for the data type), the following transformation |
|
847 |
* is applied: |
|
848 |
* |
|
849 |
* <ol> |
|
850 |
* |
|
851 |
* <li> Each digit character <i>d</i> in the string is replaced by a |
|
852 |
* locale-specific digit computed relative to the current locale's |
|
853 |
* {@linkplain java.text.DecimalFormatSymbols#getZeroDigit() zero digit} |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
854 |
* <i>z</i>; that is <i>d - </i> {@code '0'} |
2 | 855 |
* <i> + z</i>. |
856 |
* |
|
857 |
* <li> If a decimal separator is present, a locale-specific {@linkplain |
|
858 |
* java.text.DecimalFormatSymbols#getDecimalSeparator decimal separator} is |
|
859 |
* substituted. |
|
860 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
861 |
* <li> If the {@code ','} (<tt>'\u002c'</tt>) |
18774 | 862 |
* <a name="L10nGroup">flag</a> is given, then the locale-specific {@linkplain |
2 | 863 |
* java.text.DecimalFormatSymbols#getGroupingSeparator grouping separator} is |
864 |
* inserted by scanning the integer part of the string from least significant |
|
865 |
* to most significant digits and inserting a separator at intervals defined by |
|
866 |
* the locale's {@linkplain java.text.DecimalFormat#getGroupingSize() grouping |
|
867 |
* size}. |
|
868 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
869 |
* <li> If the {@code '0'} flag is given, then the locale-specific {@linkplain |
2 | 870 |
* java.text.DecimalFormatSymbols#getZeroDigit() zero digits} are inserted |
871 |
* after the sign character, if any, and before the first non-zero digit, until |
|
872 |
* the length of the string is equal to the requested field width. |
|
873 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
874 |
* <li> If the value is negative and the {@code '('} flag is given, then a |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
875 |
* {@code '('} (<tt>'\u0028'</tt>) is prepended and a {@code ')'} |
2 | 876 |
* (<tt>'\u0029'</tt>) is appended. |
877 |
* |
|
878 |
* <li> If the value is negative (or floating-point negative zero) and |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
879 |
* {@code '('} flag is not given, then a {@code '-'} (<tt>'\u002d'</tt>) |
2 | 880 |
* is prepended. |
881 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
882 |
* <li> If the {@code '+'} flag is given and the value is positive or zero (or |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
883 |
* floating-point positive zero), then a {@code '+'} (<tt>'\u002b'</tt>) |
2 | 884 |
* will be prepended. |
885 |
* |
|
886 |
* </ol> |
|
887 |
* |
|
888 |
* <p> If the value is NaN or positive infinity the literal strings "NaN" or |
|
889 |
* "Infinity" respectively, will be output. If the value is negative infinity, |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
890 |
* then the output will be "(Infinity)" if the {@code '('} flag is given |
2 | 891 |
* otherwise the output will be "-Infinity". These values are not localized. |
892 |
* |
|
893 |
* <p><a name="dnint"><b> Byte, Short, Integer, and Long </b></a> |
|
894 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
895 |
* <p> The following conversions may be applied to {@code byte}, {@link Byte}, |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
896 |
* {@code short}, {@link Short}, {@code int} and {@link Integer}, |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
897 |
* {@code long}, and {@link Long}. |
2 | 898 |
* |
899 |
* <table cellpadding=5 summary="IntConv"> |
|
900 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
901 |
* <tr><td valign="top"> {@code 'd'} |
21368
7b48f137e525
5063500: Formatter spec says "char" is not an integral type
smarks
parents:
20795
diff
changeset
|
902 |
* <td valign="top"> <tt>'\u0064'</tt> |
2 | 903 |
* <td> Formats the argument as a decimal integer. The <a |
18774 | 904 |
* href="#L10nAlgorithm">localization algorithm</a> is applied. |
2 | 905 |
* |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
906 |
* <p> If the {@code '0'} flag is given and the value is negative, then |
2 | 907 |
* the zero padding will occur after the sign. |
908 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
909 |
* <p> If the {@code '#'} flag is given then a {@link |
2 | 910 |
* FormatFlagsConversionMismatchException} will be thrown. |
911 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
912 |
* <tr><td valign="top"> {@code 'o'} |
2 | 913 |
* <td valign="top"> <tt>'\u006f'</tt> |
914 |
* <td> Formats the argument as an integer in base eight. No localization |
|
915 |
* is applied. |
|
916 |
* |
|
917 |
* <p> If <i>x</i> is negative then the result will be an unsigned value |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
918 |
* generated by adding 2<sup>n</sup> to the value where {@code n} is the |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
919 |
* number of bits in the type as returned by the static {@code SIZE} field |
2 | 920 |
* in the {@linkplain Byte#SIZE Byte}, {@linkplain Short#SIZE Short}, |
921 |
* {@linkplain Integer#SIZE Integer}, or {@linkplain Long#SIZE Long} |
|
922 |
* classes as appropriate. |
|
923 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
924 |
* <p> If the {@code '#'} flag is given then the output will always begin |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
925 |
* with the radix indicator {@code '0'}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
926 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
927 |
* <p> If the {@code '0'} flag is given then the output will be padded |
2 | 928 |
* with leading zeros to the field width following any indication of sign. |
929 |
* |
|
14014 | 930 |
* <p> If {@code '('}, {@code '+'}, ' ', or {@code ','} flags |
2 | 931 |
* are given then a {@link FormatFlagsConversionMismatchException} will be |
932 |
* thrown. |
|
933 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
934 |
* <tr><td valign="top"> {@code 'x'} |
2 | 935 |
* <td valign="top"> <tt>'\u0078'</tt> |
936 |
* <td> Formats the argument as an integer in base sixteen. No |
|
937 |
* localization is applied. |
|
938 |
* |
|
939 |
* <p> If <i>x</i> is negative then the result will be an unsigned value |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
940 |
* generated by adding 2<sup>n</sup> to the value where {@code n} is the |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
941 |
* number of bits in the type as returned by the static {@code SIZE} field |
2 | 942 |
* in the {@linkplain Byte#SIZE Byte}, {@linkplain Short#SIZE Short}, |
943 |
* {@linkplain Integer#SIZE Integer}, or {@linkplain Long#SIZE Long} |
|
944 |
* classes as appropriate. |
|
945 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
946 |
* <p> If the {@code '#'} flag is given then the output will always begin |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
947 |
* with the radix indicator {@code "0x"}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
948 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
949 |
* <p> If the {@code '0'} flag is given then the output will be padded to |
2 | 950 |
* the field width with leading zeros after the radix indicator or sign (if |
951 |
* present). |
|
952 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
953 |
* <p> If {@code '('}, <tt>' '</tt>, {@code '+'}, or |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
954 |
* {@code ','} flags are given then a {@link |
2 | 955 |
* FormatFlagsConversionMismatchException} will be thrown. |
956 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
957 |
* <tr><td valign="top"> {@code 'X'} |
2 | 958 |
* <td valign="top"> <tt>'\u0058'</tt> |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
959 |
* <td> The upper-case variant of {@code 'x'}. The entire string |
2 | 960 |
* representing the number will be converted to {@linkplain |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
961 |
* String#toUpperCase upper case} including the {@code 'x'} (if any) and |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
962 |
* all hexadecimal digits {@code 'a'} - {@code 'f'} |
2 | 963 |
* (<tt>'\u0061'</tt> - <tt>'\u0066'</tt>). |
964 |
* |
|
965 |
* </table> |
|
966 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
967 |
* <p> If the conversion is {@code 'o'}, {@code 'x'}, or {@code 'X'} and |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
968 |
* both the {@code '#'} and the {@code '0'} flags are given, then result will |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
969 |
* contain the radix indicator ({@code '0'} for octal and {@code "0x"} or |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
970 |
* {@code "0X"} for hexadecimal), some number of zeros (based on the width), |
2 | 971 |
* and the value. |
972 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
973 |
* <p> If the {@code '-'} flag is not given, then the space padding will occur |
2 | 974 |
* before the sign. |
975 |
* |
|
976 |
* <p> The following <a name="intFlags">flags</a> apply to numeric integral |
|
977 |
* conversions: |
|
978 |
* |
|
979 |
* <table cellpadding=5 summary="intFlags"> |
|
980 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
981 |
* <tr><td valign="top"> {@code '+'} |
2 | 982 |
* <td valign="top"> <tt>'\u002b'</tt> |
983 |
* <td> Requires the output to include a positive sign for all positive |
|
984 |
* numbers. If this flag is not given then only negative values will |
|
985 |
* include a sign. |
|
986 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
987 |
* <p> If both the {@code '+'} and <tt>' '</tt> flags are given |
2 | 988 |
* then an {@link IllegalFormatFlagsException} will be thrown. |
989 |
* |
|
990 |
* <tr><td valign="top"> <tt>' '</tt> |
|
991 |
* <td valign="top"> <tt>'\u0020'</tt> |
|
992 |
* <td> Requires the output to include a single extra space |
|
993 |
* (<tt>'\u0020'</tt>) for non-negative values. |
|
994 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
995 |
* <p> If both the {@code '+'} and <tt>' '</tt> flags are given |
2 | 996 |
* then an {@link IllegalFormatFlagsException} will be thrown. |
997 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
998 |
* <tr><td valign="top"> {@code '0'} |
2 | 999 |
* <td valign="top"> <tt>'\u0030'</tt> |
1000 |
* <td> Requires the output to be padded with leading {@linkplain |
|
1001 |
* java.text.DecimalFormatSymbols#getZeroDigit zeros} to the minimum field |
|
1002 |
* width following any sign or radix indicator except when converting NaN |
|
1003 |
* or infinity. If the width is not provided, then a {@link |
|
1004 |
* MissingFormatWidthException} will be thrown. |
|
1005 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1006 |
* <p> If both the {@code '-'} and {@code '0'} flags are given then an |
2 | 1007 |
* {@link IllegalFormatFlagsException} will be thrown. |
1008 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1009 |
* <tr><td valign="top"> {@code ','} |
2 | 1010 |
* <td valign="top"> <tt>'\u002c'</tt> |
1011 |
* <td> Requires the output to include the locale-specific {@linkplain |
|
1012 |
* java.text.DecimalFormatSymbols#getGroupingSeparator group separators} as |
|
18774 | 1013 |
* described in the <a href="#L10nGroup">"group" section</a> of the |
2 | 1014 |
* localization algorithm. |
1015 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1016 |
* <tr><td valign="top"> {@code '('} |
2 | 1017 |
* <td valign="top"> <tt>'\u0028'</tt> |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1018 |
* <td> Requires the output to prepend a {@code '('} |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1019 |
* (<tt>'\u0028'</tt>) and append a {@code ')'} |
2 | 1020 |
* (<tt>'\u0029'</tt>) to negative values. |
1021 |
* |
|
1022 |
* </table> |
|
1023 |
* |
|
1024 |
* <p> If no <a name="intdFlags">flags</a> are given the default formatting is |
|
1025 |
* as follows: |
|
1026 |
* |
|
1027 |
* <ul> |
|
1028 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1029 |
* <li> The output is right-justified within the {@code width} |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1030 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1031 |
* <li> Negative numbers begin with a {@code '-'} (<tt>'\u002d'</tt>) |
2 | 1032 |
* |
1033 |
* <li> Positive numbers and zero do not include a sign or extra leading |
|
1034 |
* space |
|
1035 |
* |
|
1036 |
* <li> No grouping separators are included |
|
1037 |
* |
|
1038 |
* </ul> |
|
1039 |
* |
|
1040 |
* <p> The <a name="intWidth">width</a> is the minimum number of characters to |
|
1041 |
* be written to the output. This includes any signs, digits, grouping |
|
1042 |
* separators, radix indicator, and parentheses. If the length of the |
|
1043 |
* converted value is less than the width then the output will be padded by |
|
1044 |
* spaces (<tt>'\u0020'</tt>) until the total number of characters equals |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1045 |
* width. The padding is on the left by default. If {@code '-'} flag is |
2 | 1046 |
* given then the padding will be on the right. If width is not specified then |
1047 |
* there is no minimum. |
|
1048 |
* |
|
1049 |
* <p> The precision is not applicable. If precision is specified then an |
|
1050 |
* {@link IllegalFormatPrecisionException} will be thrown. |
|
1051 |
* |
|
1052 |
* <p><a name="dnbint"><b> BigInteger </b></a> |
|
1053 |
* |
|
1054 |
* <p> The following conversions may be applied to {@link |
|
1055 |
* java.math.BigInteger}. |
|
1056 |
* |
|
1057 |
* <table cellpadding=5 summary="BIntConv"> |
|
1058 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1059 |
* <tr><td valign="top"> {@code 'd'} |
21368
7b48f137e525
5063500: Formatter spec says "char" is not an integral type
smarks
parents:
20795
diff
changeset
|
1060 |
* <td valign="top"> <tt>'\u0064'</tt> |
2 | 1061 |
* <td> Requires the output to be formatted as a decimal integer. The <a |
18774 | 1062 |
* href="#L10nAlgorithm">localization algorithm</a> is applied. |
2 | 1063 |
* |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1064 |
* <p> If the {@code '#'} flag is given {@link |
2 | 1065 |
* FormatFlagsConversionMismatchException} will be thrown. |
1066 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1067 |
* <tr><td valign="top"> {@code 'o'} |
2 | 1068 |
* <td valign="top"> <tt>'\u006f'</tt> |
1069 |
* <td> Requires the output to be formatted as an integer in base eight. |
|
1070 |
* No localization is applied. |
|
1071 |
* |
|
1072 |
* <p> If <i>x</i> is negative then the result will be a signed value |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1073 |
* beginning with {@code '-'} (<tt>'\u002d'</tt>). Signed output is |
2 | 1074 |
* allowed for this type because unlike the primitive types it is not |
1075 |
* possible to create an unsigned equivalent without assuming an explicit |
|
1076 |
* data-type size. |
|
1077 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1078 |
* <p> If <i>x</i> is positive or zero and the {@code '+'} flag is given |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1079 |
* then the result will begin with {@code '+'} (<tt>'\u002b'</tt>). |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1080 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1081 |
* <p> If the {@code '#'} flag is given then the output will always begin |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1082 |
* with {@code '0'} prefix. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1083 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1084 |
* <p> If the {@code '0'} flag is given then the output will be padded |
2 | 1085 |
* with leading zeros to the field width following any indication of sign. |
1086 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1087 |
* <p> If the {@code ','} flag is given then a {@link |
2 | 1088 |
* FormatFlagsConversionMismatchException} will be thrown. |
1089 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1090 |
* <tr><td valign="top"> {@code 'x'} |
2 | 1091 |
* <td valign="top"> <tt>'\u0078'</tt> |
1092 |
* <td> Requires the output to be formatted as an integer in base |
|
1093 |
* sixteen. No localization is applied. |
|
1094 |
* |
|
1095 |
* <p> If <i>x</i> is negative then the result will be a signed value |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1096 |
* beginning with {@code '-'} (<tt>'\u002d'</tt>). Signed output is |
2 | 1097 |
* allowed for this type because unlike the primitive types it is not |
1098 |
* possible to create an unsigned equivalent without assuming an explicit |
|
1099 |
* data-type size. |
|
1100 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1101 |
* <p> If <i>x</i> is positive or zero and the {@code '+'} flag is given |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1102 |
* then the result will begin with {@code '+'} (<tt>'\u002b'</tt>). |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1103 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1104 |
* <p> If the {@code '#'} flag is given then the output will always begin |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1105 |
* with the radix indicator {@code "0x"}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1106 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1107 |
* <p> If the {@code '0'} flag is given then the output will be padded to |
2 | 1108 |
* the field width with leading zeros after the radix indicator or sign (if |
1109 |
* present). |
|
1110 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1111 |
* <p> If the {@code ','} flag is given then a {@link |
2 | 1112 |
* FormatFlagsConversionMismatchException} will be thrown. |
1113 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1114 |
* <tr><td valign="top"> {@code 'X'} |
2 | 1115 |
* <td valign="top"> <tt>'\u0058'</tt> |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1116 |
* <td> The upper-case variant of {@code 'x'}. The entire string |
2 | 1117 |
* representing the number will be converted to {@linkplain |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1118 |
* String#toUpperCase upper case} including the {@code 'x'} (if any) and |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1119 |
* all hexadecimal digits {@code 'a'} - {@code 'f'} |
2 | 1120 |
* (<tt>'\u0061'</tt> - <tt>'\u0066'</tt>). |
1121 |
* |
|
1122 |
* </table> |
|
1123 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1124 |
* <p> If the conversion is {@code 'o'}, {@code 'x'}, or {@code 'X'} and |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1125 |
* both the {@code '#'} and the {@code '0'} flags are given, then result will |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1126 |
* contain the base indicator ({@code '0'} for octal and {@code "0x"} or |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1127 |
* {@code "0X"} for hexadecimal), some number of zeros (based on the width), |
2 | 1128 |
* and the value. |
1129 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1130 |
* <p> If the {@code '0'} flag is given and the value is negative, then the |
2 | 1131 |
* zero padding will occur after the sign. |
1132 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1133 |
* <p> If the {@code '-'} flag is not given, then the space padding will occur |
2 | 1134 |
* before the sign. |
1135 |
* |
|
1136 |
* <p> All <a href="#intFlags">flags</a> defined for Byte, Short, Integer, and |
|
1137 |
* Long apply. The <a href="#intdFlags">default behavior</a> when no flags are |
|
1138 |
* given is the same as for Byte, Short, Integer, and Long. |
|
1139 |
* |
|
1140 |
* <p> The specification of <a href="#intWidth">width</a> is the same as |
|
1141 |
* defined for Byte, Short, Integer, and Long. |
|
1142 |
* |
|
1143 |
* <p> The precision is not applicable. If precision is specified then an |
|
1144 |
* {@link IllegalFormatPrecisionException} will be thrown. |
|
1145 |
* |
|
1146 |
* <p><a name="dndec"><b> Float and Double</b></a> |
|
1147 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1148 |
* <p> The following conversions may be applied to {@code float}, {@link |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1149 |
* Float}, {@code double} and {@link Double}. |
2 | 1150 |
* |
1151 |
* <table cellpadding=5 summary="floatConv"> |
|
1152 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1153 |
* <tr><td valign="top"> {@code 'e'} |
2 | 1154 |
* <td valign="top"> <tt>'\u0065'</tt> |
1155 |
* <td> Requires the output to be formatted using <a |
|
1156 |
* name="scientific">computerized scientific notation</a>. The <a |
|
18774 | 1157 |
* href="#L10nAlgorithm">localization algorithm</a> is applied. |
2 | 1158 |
* |
1159 |
* <p> The formatting of the magnitude <i>m</i> depends upon its value. |
|
1160 |
* |
|
1161 |
* <p> If <i>m</i> is NaN or infinite, the literal strings "NaN" or |
|
1162 |
* "Infinity", respectively, will be output. These values are not |
|
1163 |
* localized. |
|
1164 |
* |
|
1165 |
* <p> If <i>m</i> is positive-zero or negative-zero, then the exponent |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1166 |
* will be {@code "+00"}. |
2 | 1167 |
* |
1168 |
* <p> Otherwise, the result is a string that represents the sign and |
|
1169 |
* magnitude (absolute value) of the argument. The formatting of the sign |
|
18774 | 1170 |
* is described in the <a href="#L10nAlgorithm">localization |
2 | 1171 |
* algorithm</a>. The formatting of the magnitude <i>m</i> depends upon its |
1172 |
* value. |
|
1173 |
* |
|
1174 |
* <p> Let <i>n</i> be the unique integer such that 10<sup><i>n</i></sup> |
|
1175 |
* <= <i>m</i> < 10<sup><i>n</i>+1</sup>; then let <i>a</i> be the |
|
1176 |
* mathematically exact quotient of <i>m</i> and 10<sup><i>n</i></sup> so |
|
1177 |
* that 1 <= <i>a</i> < 10. The magnitude is then represented as the |
|
1178 |
* integer part of <i>a</i>, as a single decimal digit, followed by the |
|
1179 |
* decimal separator followed by decimal digits representing the fractional |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1180 |
* part of <i>a</i>, followed by the exponent symbol {@code 'e'} |
2 | 1181 |
* (<tt>'\u0065'</tt>), followed by the sign of the exponent, followed |
1182 |
* by a representation of <i>n</i> as a decimal integer, as produced by the |
|
1183 |
* method {@link Long#toString(long, int)}, and zero-padded to include at |
|
1184 |
* least two digits. |
|
1185 |
* |
|
1186 |
* <p> The number of digits in the result for the fractional part of |
|
1187 |
* <i>m</i> or <i>a</i> is equal to the precision. If the precision is not |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1188 |
* specified then the default value is {@code 6}. If the precision is less |
2 | 1189 |
* than the number of digits which would appear after the decimal point in |
1190 |
* the string returned by {@link Float#toString(float)} or {@link |
|
1191 |
* Double#toString(double)} respectively, then the value will be rounded |
|
1192 |
* using the {@linkplain java.math.BigDecimal#ROUND_HALF_UP round half up |
|
1193 |
* algorithm}. Otherwise, zeros may be appended to reach the precision. |
|
1194 |
* For a canonical representation of the value, use {@link |
|
1195 |
* Float#toString(float)} or {@link Double#toString(double)} as |
|
1196 |
* appropriate. |
|
1197 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1198 |
* <p>If the {@code ','} flag is given, then an {@link |
2 | 1199 |
* FormatFlagsConversionMismatchException} will be thrown. |
1200 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1201 |
* <tr><td valign="top"> {@code 'E'} |
2 | 1202 |
* <td valign="top"> <tt>'\u0045'</tt> |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1203 |
* <td> The upper-case variant of {@code 'e'}. The exponent symbol |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1204 |
* will be {@code 'E'} (<tt>'\u0045'</tt>). |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1205 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1206 |
* <tr><td valign="top"> {@code 'g'} |
2 | 1207 |
* <td valign="top"> <tt>'\u0067'</tt> |
1208 |
* <td> Requires the output to be formatted in general scientific notation |
|
18774 | 1209 |
* as described below. The <a href="#L10nAlgorithm">localization |
2 | 1210 |
* algorithm</a> is applied. |
1211 |
* |
|
1212 |
* <p> After rounding for the precision, the formatting of the resulting |
|
1213 |
* magnitude <i>m</i> depends on its value. |
|
1214 |
* |
|
1215 |
* <p> If <i>m</i> is greater than or equal to 10<sup>-4</sup> but less |
|
1216 |
* than 10<sup>precision</sup> then it is represented in <i><a |
|
1217 |
* href="#decimal">decimal format</a></i>. |
|
1218 |
* |
|
1219 |
* <p> If <i>m</i> is less than 10<sup>-4</sup> or greater than or equal to |
|
1220 |
* 10<sup>precision</sup>, then it is represented in <i><a |
|
1221 |
* href="#scientific">computerized scientific notation</a></i>. |
|
1222 |
* |
|
1223 |
* <p> The total number of significant digits in <i>m</i> is equal to the |
|
1224 |
* precision. If the precision is not specified, then the default value is |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1225 |
* {@code 6}. If the precision is {@code 0}, then it is taken to be |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1226 |
* {@code 1}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1227 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1228 |
* <p> If the {@code '#'} flag is given then an {@link |
2 | 1229 |
* FormatFlagsConversionMismatchException} will be thrown. |
1230 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1231 |
* <tr><td valign="top"> {@code 'G'} |
2 | 1232 |
* <td valign="top"> <tt>'\u0047'</tt> |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1233 |
* <td> The upper-case variant of {@code 'g'}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1234 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1235 |
* <tr><td valign="top"> {@code 'f'} |
2 | 1236 |
* <td valign="top"> <tt>'\u0066'</tt> |
1237 |
* <td> Requires the output to be formatted using <a name="decimal">decimal |
|
18774 | 1238 |
* format</a>. The <a href="#L10nAlgorithm">localization algorithm</a> is |
2 | 1239 |
* applied. |
1240 |
* |
|
1241 |
* <p> The result is a string that represents the sign and magnitude |
|
1242 |
* (absolute value) of the argument. The formatting of the sign is |
|
18774 | 1243 |
* described in the <a href="#L10nAlgorithm">localization |
2 | 1244 |
* algorithm</a>. The formatting of the magnitude <i>m</i> depends upon its |
1245 |
* value. |
|
1246 |
* |
|
1247 |
* <p> If <i>m</i> NaN or infinite, the literal strings "NaN" or |
|
1248 |
* "Infinity", respectively, will be output. These values are not |
|
1249 |
* localized. |
|
1250 |
* |
|
1251 |
* <p> The magnitude is formatted as the integer part of <i>m</i>, with no |
|
1252 |
* leading zeroes, followed by the decimal separator followed by one or |
|
1253 |
* more decimal digits representing the fractional part of <i>m</i>. |
|
1254 |
* |
|
1255 |
* <p> The number of digits in the result for the fractional part of |
|
1256 |
* <i>m</i> or <i>a</i> is equal to the precision. If the precision is not |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1257 |
* specified then the default value is {@code 6}. If the precision is less |
2 | 1258 |
* than the number of digits which would appear after the decimal point in |
1259 |
* the string returned by {@link Float#toString(float)} or {@link |
|
1260 |
* Double#toString(double)} respectively, then the value will be rounded |
|
1261 |
* using the {@linkplain java.math.BigDecimal#ROUND_HALF_UP round half up |
|
1262 |
* algorithm}. Otherwise, zeros may be appended to reach the precision. |
|
1823
23d42a96635e
6476425: (fmt)java.util.Formatter.print() throws IllegalArgumentException on large BigDecima
sherman
parents:
2
diff
changeset
|
1263 |
* For a canonical representation of the value, use {@link |
2 | 1264 |
* Float#toString(float)} or {@link Double#toString(double)} as |
1265 |
* appropriate. |
|
1266 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1267 |
* <tr><td valign="top"> {@code 'a'} |
2 | 1268 |
* <td valign="top"> <tt>'\u0061'</tt> |
1269 |
* <td> Requires the output to be formatted in hexadecimal exponential |
|
1270 |
* form. No localization is applied. |
|
1271 |
* |
|
1272 |
* <p> The result is a string that represents the sign and magnitude |
|
1273 |
* (absolute value) of the argument <i>x</i>. |
|
1274 |
* |
|
1275 |
* <p> If <i>x</i> is negative or a negative-zero value then the result |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1276 |
* will begin with {@code '-'} (<tt>'\u002d'</tt>). |
2 | 1277 |
* |
1278 |
* <p> If <i>x</i> is positive or a positive-zero value and the |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1279 |
* {@code '+'} flag is given then the result will begin with {@code '+'} |
2 | 1280 |
* (<tt>'\u002b'</tt>). |
1281 |
* |
|
1282 |
* <p> The formatting of the magnitude <i>m</i> depends upon its value. |
|
1283 |
* |
|
1284 |
* <ul> |
|
1285 |
* |
|
1286 |
* <li> If the value is NaN or infinite, the literal strings "NaN" or |
|
1287 |
* "Infinity", respectively, will be output. |
|
1288 |
* |
|
1289 |
* <li> If <i>m</i> is zero then it is represented by the string |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1290 |
* {@code "0x0.0p0"}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1291 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1292 |
* <li> If <i>m</i> is a {@code double} value with a normalized |
2 | 1293 |
* representation then substrings are used to represent the significand and |
1294 |
* exponent fields. The significand is represented by the characters |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1295 |
* {@code "0x1."} followed by the hexadecimal representation of the rest |
2 | 1296 |
* of the significand as a fraction. The exponent is represented by |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1297 |
* {@code 'p'} (<tt>'\u0070'</tt>) followed by a decimal string of the |
2 | 1298 |
* unbiased exponent as if produced by invoking {@link |
19196
5368bd038f19
6476168: (fmt) Inconsistency formatting subnormal doubles with hexadecimal conversion
bpb
parents:
18797
diff
changeset
|
1299 |
* Integer#toString(int) Integer.toString} on the exponent value. If the |
5368bd038f19
6476168: (fmt) Inconsistency formatting subnormal doubles with hexadecimal conversion
bpb
parents:
18797
diff
changeset
|
1300 |
* precision is specified, the value is rounded to the given number of |
5368bd038f19
6476168: (fmt) Inconsistency formatting subnormal doubles with hexadecimal conversion
bpb
parents:
18797
diff
changeset
|
1301 |
* hexadecimal digits. |
2 | 1302 |
* |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1303 |
* <li> If <i>m</i> is a {@code double} value with a subnormal |
19196
5368bd038f19
6476168: (fmt) Inconsistency formatting subnormal doubles with hexadecimal conversion
bpb
parents:
18797
diff
changeset
|
1304 |
* representation then, unless the precision is specified to be in the range |
5368bd038f19
6476168: (fmt) Inconsistency formatting subnormal doubles with hexadecimal conversion
bpb
parents:
18797
diff
changeset
|
1305 |
* 1 through 12, inclusive, the significand is represented by the characters |
5368bd038f19
6476168: (fmt) Inconsistency formatting subnormal doubles with hexadecimal conversion
bpb
parents:
18797
diff
changeset
|
1306 |
* {@code '0x0.'} followed by the hexadecimal representation of the rest of |
5368bd038f19
6476168: (fmt) Inconsistency formatting subnormal doubles with hexadecimal conversion
bpb
parents:
18797
diff
changeset
|
1307 |
* the significand as a fraction, and the exponent represented by |
5368bd038f19
6476168: (fmt) Inconsistency formatting subnormal doubles with hexadecimal conversion
bpb
parents:
18797
diff
changeset
|
1308 |
* {@code 'p-1022'}. If the precision is in the interval |
5368bd038f19
6476168: (fmt) Inconsistency formatting subnormal doubles with hexadecimal conversion
bpb
parents:
18797
diff
changeset
|
1309 |
* [1, 12], the subnormal value is normalized such that it |
5368bd038f19
6476168: (fmt) Inconsistency formatting subnormal doubles with hexadecimal conversion
bpb
parents:
18797
diff
changeset
|
1310 |
* begins with the characters {@code '0x1.'}, rounded to the number of |
5368bd038f19
6476168: (fmt) Inconsistency formatting subnormal doubles with hexadecimal conversion
bpb
parents:
18797
diff
changeset
|
1311 |
* hexadecimal digits of precision, and the exponent adjusted |
5368bd038f19
6476168: (fmt) Inconsistency formatting subnormal doubles with hexadecimal conversion
bpb
parents:
18797
diff
changeset
|
1312 |
* accordingly. Note that there must be at least one nonzero digit in a |
5368bd038f19
6476168: (fmt) Inconsistency formatting subnormal doubles with hexadecimal conversion
bpb
parents:
18797
diff
changeset
|
1313 |
* subnormal significand. |
2 | 1314 |
* |
1315 |
* </ul> |
|
1316 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1317 |
* <p> If the {@code '('} or {@code ','} flags are given, then a {@link |
2 | 1318 |
* FormatFlagsConversionMismatchException} will be thrown. |
1319 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1320 |
* <tr><td valign="top"> {@code 'A'} |
2 | 1321 |
* <td valign="top"> <tt>'\u0041'</tt> |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1322 |
* <td> The upper-case variant of {@code 'a'}. The entire string |
2 | 1323 |
* representing the number will be converted to upper case including the |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1324 |
* {@code 'x'} (<tt>'\u0078'</tt>) and {@code 'p'} |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1325 |
* (<tt>'\u0070'</tt> and all hexadecimal digits {@code 'a'} - |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1326 |
* {@code 'f'} (<tt>'\u0061'</tt> - <tt>'\u0066'</tt>). |
2 | 1327 |
* |
1328 |
* </table> |
|
1329 |
* |
|
1330 |
* <p> All <a href="#intFlags">flags</a> defined for Byte, Short, Integer, and |
|
1331 |
* Long apply. |
|
1332 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1333 |
* <p> If the {@code '#'} flag is given, then the decimal separator will |
2 | 1334 |
* always be present. |
1335 |
* |
|
1336 |
* <p> If no <a name="floatdFlags">flags</a> are given the default formatting |
|
1337 |
* is as follows: |
|
1338 |
* |
|
1339 |
* <ul> |
|
1340 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1341 |
* <li> The output is right-justified within the {@code width} |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1342 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1343 |
* <li> Negative numbers begin with a {@code '-'} |
2 | 1344 |
* |
1345 |
* <li> Positive numbers and positive zero do not include a sign or extra |
|
1346 |
* leading space |
|
1347 |
* |
|
1348 |
* <li> No grouping separators are included |
|
1349 |
* |
|
1350 |
* <li> The decimal separator will only appear if a digit follows it |
|
1351 |
* |
|
1352 |
* </ul> |
|
1353 |
* |
|
1354 |
* <p> The <a name="floatDWidth">width</a> is the minimum number of characters |
|
1355 |
* to be written to the output. This includes any signs, digits, grouping |
|
1356 |
* separators, decimal separators, exponential symbol, radix indicator, |
|
1357 |
* parentheses, and strings representing infinity and NaN as applicable. If |
|
1358 |
* the length of the converted value is less than the width then the output |
|
1359 |
* will be padded by spaces (<tt>'\u0020'</tt>) until the total number of |
|
1360 |
* characters equals width. The padding is on the left by default. If the |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1361 |
* {@code '-'} flag is given then the padding will be on the right. If width |
2 | 1362 |
* is not specified then there is no minimum. |
1363 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1364 |
* <p> If the <a name="floatDPrec">conversion</a> is {@code 'e'}, |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1365 |
* {@code 'E'} or {@code 'f'}, then the precision is the number of digits |
2 | 1366 |
* after the decimal separator. If the precision is not specified, then it is |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1367 |
* assumed to be {@code 6}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1368 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1369 |
* <p> If the conversion is {@code 'g'} or {@code 'G'}, then the precision is |
2 | 1370 |
* the total number of significant digits in the resulting magnitude after |
1371 |
* rounding. If the precision is not specified, then the default value is |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1372 |
* {@code 6}. If the precision is {@code 0}, then it is taken to be |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1373 |
* {@code 1}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1374 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1375 |
* <p> If the conversion is {@code 'a'} or {@code 'A'}, then the precision |
19196
5368bd038f19
6476168: (fmt) Inconsistency formatting subnormal doubles with hexadecimal conversion
bpb
parents:
18797
diff
changeset
|
1376 |
* is the number of hexadecimal digits after the radix point. If the |
2 | 1377 |
* precision is not provided, then all of the digits as returned by {@link |
1378 |
* Double#toHexString(double)} will be output. |
|
1379 |
* |
|
9689
53a4e9b16900
7043234: (fmt) java.util.Formatter links in javadoc to BigDecimal need to be fixed
sherman
parents:
9266
diff
changeset
|
1380 |
* <p><a name="dnbdec"><b> BigDecimal </b></a> |
2 | 1381 |
* |
1382 |
* <p> The following conversions may be applied {@link java.math.BigDecimal |
|
1383 |
* BigDecimal}. |
|
1384 |
* |
|
1385 |
* <table cellpadding=5 summary="floatConv"> |
|
1386 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1387 |
* <tr><td valign="top"> {@code 'e'} |
2 | 1388 |
* <td valign="top"> <tt>'\u0065'</tt> |
1389 |
* <td> Requires the output to be formatted using <a |
|
9689
53a4e9b16900
7043234: (fmt) java.util.Formatter links in javadoc to BigDecimal need to be fixed
sherman
parents:
9266
diff
changeset
|
1390 |
* name="bscientific">computerized scientific notation</a>. The <a |
18774 | 1391 |
* href="#L10nAlgorithm">localization algorithm</a> is applied. |
2 | 1392 |
* |
1393 |
* <p> The formatting of the magnitude <i>m</i> depends upon its value. |
|
1394 |
* |
|
1395 |
* <p> If <i>m</i> is positive-zero or negative-zero, then the exponent |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1396 |
* will be {@code "+00"}. |
2 | 1397 |
* |
1398 |
* <p> Otherwise, the result is a string that represents the sign and |
|
1399 |
* magnitude (absolute value) of the argument. The formatting of the sign |
|
18774 | 1400 |
* is described in the <a href="#L10nAlgorithm">localization |
2 | 1401 |
* algorithm</a>. The formatting of the magnitude <i>m</i> depends upon its |
1402 |
* value. |
|
1403 |
* |
|
1404 |
* <p> Let <i>n</i> be the unique integer such that 10<sup><i>n</i></sup> |
|
1405 |
* <= <i>m</i> < 10<sup><i>n</i>+1</sup>; then let <i>a</i> be the |
|
1406 |
* mathematically exact quotient of <i>m</i> and 10<sup><i>n</i></sup> so |
|
1407 |
* that 1 <= <i>a</i> < 10. The magnitude is then represented as the |
|
1408 |
* integer part of <i>a</i>, as a single decimal digit, followed by the |
|
1409 |
* decimal separator followed by decimal digits representing the fractional |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1410 |
* part of <i>a</i>, followed by the exponent symbol {@code 'e'} |
2 | 1411 |
* (<tt>'\u0065'</tt>), followed by the sign of the exponent, followed |
1412 |
* by a representation of <i>n</i> as a decimal integer, as produced by the |
|
1413 |
* method {@link Long#toString(long, int)}, and zero-padded to include at |
|
1414 |
* least two digits. |
|
1415 |
* |
|
1416 |
* <p> The number of digits in the result for the fractional part of |
|
1417 |
* <i>m</i> or <i>a</i> is equal to the precision. If the precision is not |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1418 |
* specified then the default value is {@code 6}. If the precision is |
8799
99032bb1a2b9
6796662: (fmt spec) Formatter spec on BigDecimal output should not reference Float a
sherman
parents:
8166
diff
changeset
|
1419 |
* less than the number of digits to the right of the decimal point then |
99032bb1a2b9
6796662: (fmt spec) Formatter spec on BigDecimal output should not reference Float a
sherman
parents:
8166
diff
changeset
|
1420 |
* the value will be rounded using the |
99032bb1a2b9
6796662: (fmt spec) Formatter spec on BigDecimal output should not reference Float a
sherman
parents:
8166
diff
changeset
|
1421 |
* {@linkplain java.math.BigDecimal#ROUND_HALF_UP round half up |
2 | 1422 |
* algorithm}. Otherwise, zeros may be appended to reach the precision. |
1423 |
* For a canonical representation of the value, use {@link |
|
1424 |
* BigDecimal#toString()}. |
|
1425 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1426 |
* <p> If the {@code ','} flag is given, then an {@link |
2 | 1427 |
* FormatFlagsConversionMismatchException} will be thrown. |
1428 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1429 |
* <tr><td valign="top"> {@code 'E'} |
2 | 1430 |
* <td valign="top"> <tt>'\u0045'</tt> |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1431 |
* <td> The upper-case variant of {@code 'e'}. The exponent symbol |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1432 |
* will be {@code 'E'} (<tt>'\u0045'</tt>). |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1433 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1434 |
* <tr><td valign="top"> {@code 'g'} |
2 | 1435 |
* <td valign="top"> <tt>'\u0067'</tt> |
1436 |
* <td> Requires the output to be formatted in general scientific notation |
|
18774 | 1437 |
* as described below. The <a href="#L10nAlgorithm">localization |
2 | 1438 |
* algorithm</a> is applied. |
1439 |
* |
|
1440 |
* <p> After rounding for the precision, the formatting of the resulting |
|
1441 |
* magnitude <i>m</i> depends on its value. |
|
1442 |
* |
|
1443 |
* <p> If <i>m</i> is greater than or equal to 10<sup>-4</sup> but less |
|
1444 |
* than 10<sup>precision</sup> then it is represented in <i><a |
|
9689
53a4e9b16900
7043234: (fmt) java.util.Formatter links in javadoc to BigDecimal need to be fixed
sherman
parents:
9266
diff
changeset
|
1445 |
* href="#bdecimal">decimal format</a></i>. |
2 | 1446 |
* |
1447 |
* <p> If <i>m</i> is less than 10<sup>-4</sup> or greater than or equal to |
|
1448 |
* 10<sup>precision</sup>, then it is represented in <i><a |
|
9689
53a4e9b16900
7043234: (fmt) java.util.Formatter links in javadoc to BigDecimal need to be fixed
sherman
parents:
9266
diff
changeset
|
1449 |
* href="#bscientific">computerized scientific notation</a></i>. |
2 | 1450 |
* |
1451 |
* <p> The total number of significant digits in <i>m</i> is equal to the |
|
1452 |
* precision. If the precision is not specified, then the default value is |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1453 |
* {@code 6}. If the precision is {@code 0}, then it is taken to be |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1454 |
* {@code 1}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1455 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1456 |
* <p> If the {@code '#'} flag is given then an {@link |
2 | 1457 |
* FormatFlagsConversionMismatchException} will be thrown. |
1458 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1459 |
* <tr><td valign="top"> {@code 'G'} |
2 | 1460 |
* <td valign="top"> <tt>'\u0047'</tt> |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1461 |
* <td> The upper-case variant of {@code 'g'}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1462 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1463 |
* <tr><td valign="top"> {@code 'f'} |
2 | 1464 |
* <td valign="top"> <tt>'\u0066'</tt> |
9689
53a4e9b16900
7043234: (fmt) java.util.Formatter links in javadoc to BigDecimal need to be fixed
sherman
parents:
9266
diff
changeset
|
1465 |
* <td> Requires the output to be formatted using <a name="bdecimal">decimal |
18774 | 1466 |
* format</a>. The <a href="#L10nAlgorithm">localization algorithm</a> is |
2 | 1467 |
* applied. |
1468 |
* |
|
1469 |
* <p> The result is a string that represents the sign and magnitude |
|
1470 |
* (absolute value) of the argument. The formatting of the sign is |
|
18774 | 1471 |
* described in the <a href="#L10nAlgorithm">localization |
2 | 1472 |
* algorithm</a>. The formatting of the magnitude <i>m</i> depends upon its |
1473 |
* value. |
|
1474 |
* |
|
1475 |
* <p> The magnitude is formatted as the integer part of <i>m</i>, with no |
|
1476 |
* leading zeroes, followed by the decimal separator followed by one or |
|
1477 |
* more decimal digits representing the fractional part of <i>m</i>. |
|
1478 |
* |
|
1479 |
* <p> The number of digits in the result for the fractional part of |
|
8799
99032bb1a2b9
6796662: (fmt spec) Formatter spec on BigDecimal output should not reference Float a
sherman
parents:
8166
diff
changeset
|
1480 |
* <i>m</i> or <i>a</i> is equal to the precision. If the precision is not |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1481 |
* specified then the default value is {@code 6}. If the precision is |
8799
99032bb1a2b9
6796662: (fmt spec) Formatter spec on BigDecimal output should not reference Float a
sherman
parents:
8166
diff
changeset
|
1482 |
* less than the number of digits to the right of the decimal point |
99032bb1a2b9
6796662: (fmt spec) Formatter spec on BigDecimal output should not reference Float a
sherman
parents:
8166
diff
changeset
|
1483 |
* then the value will be rounded using the |
99032bb1a2b9
6796662: (fmt spec) Formatter spec on BigDecimal output should not reference Float a
sherman
parents:
8166
diff
changeset
|
1484 |
* {@linkplain java.math.BigDecimal#ROUND_HALF_UP round half up |
2 | 1485 |
* algorithm}. Otherwise, zeros may be appended to reach the precision. |
1486 |
* For a canonical representation of the value, use {@link |
|
1487 |
* BigDecimal#toString()}. |
|
1488 |
* |
|
1489 |
* </table> |
|
1490 |
* |
|
1491 |
* <p> All <a href="#intFlags">flags</a> defined for Byte, Short, Integer, and |
|
1492 |
* Long apply. |
|
1493 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1494 |
* <p> If the {@code '#'} flag is given, then the decimal separator will |
2 | 1495 |
* always be present. |
1496 |
* |
|
1497 |
* <p> The <a href="#floatdFlags">default behavior</a> when no flags are |
|
1498 |
* given is the same as for Float and Double. |
|
1499 |
* |
|
1500 |
* <p> The specification of <a href="#floatDWidth">width</a> and <a |
|
1501 |
* href="#floatDPrec">precision</a> is the same as defined for Float and |
|
1502 |
* Double. |
|
1503 |
* |
|
1504 |
* <h4><a name="ddt">Date/Time</a></h4> |
|
1505 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1506 |
* <p> This conversion may be applied to {@code long}, {@link Long}, {@link |
15289 | 1507 |
* Calendar}, {@link Date} and {@link TemporalAccessor TemporalAccessor} |
2 | 1508 |
* |
1509 |
* <table cellpadding=5 summary="DTConv"> |
|
1510 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1511 |
* <tr><td valign="top"> {@code 't'} |
2 | 1512 |
* <td valign="top"> <tt>'\u0074'</tt> |
1513 |
* <td> Prefix for date and time conversion characters. |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1514 |
* <tr><td valign="top"> {@code 'T'} |
2 | 1515 |
* <td valign="top"> <tt>'\u0054'</tt> |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1516 |
* <td> The upper-case variant of {@code 't'}. |
2 | 1517 |
* |
1518 |
* </table> |
|
1519 |
* |
|
1520 |
* <p> The following date and time conversion character suffixes are defined |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1521 |
* for the {@code 't'} and {@code 'T'} conversions. The types are similar to |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1522 |
* but not completely identical to those defined by GNU {@code date} and |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1523 |
* POSIX {@code strftime(3c)}. Additional conversion types are provided to |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1524 |
* access Java-specific functionality (e.g. {@code 'L'} for milliseconds |
2 | 1525 |
* within the second). |
1526 |
* |
|
1527 |
* <p> The following conversion characters are used for formatting times: |
|
1528 |
* |
|
1529 |
* <table cellpadding=5 summary="time"> |
|
1530 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1531 |
* <tr><td valign="top"> {@code 'H'} |
2 | 1532 |
* <td valign="top"> <tt>'\u0048'</tt> |
1533 |
* <td> Hour of the day for the 24-hour clock, formatted as two digits with |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1534 |
* a leading zero as necessary i.e. {@code 00 - 23}. {@code 00} |
2 | 1535 |
* corresponds to midnight. |
1536 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1537 |
* <tr><td valign="top">{@code 'I'} |
2 | 1538 |
* <td valign="top"> <tt>'\u0049'</tt> |
1539 |
* <td> Hour for the 12-hour clock, formatted as two digits with a leading |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1540 |
* zero as necessary, i.e. {@code 01 - 12}. {@code 01} corresponds to |
2 | 1541 |
* one o'clock (either morning or afternoon). |
1542 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1543 |
* <tr><td valign="top">{@code 'k'} |
2 | 1544 |
* <td valign="top"> <tt>'\u006b'</tt> |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1545 |
* <td> Hour of the day for the 24-hour clock, i.e. {@code 0 - 23}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1546 |
* {@code 0} corresponds to midnight. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1547 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1548 |
* <tr><td valign="top">{@code 'l'} |
2 | 1549 |
* <td valign="top"> <tt>'\u006c'</tt> |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1550 |
* <td> Hour for the 12-hour clock, i.e. {@code 1 - 12}. {@code 1} |
2 | 1551 |
* corresponds to one o'clock (either morning or afternoon). |
1552 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1553 |
* <tr><td valign="top">{@code 'M'} |
2 | 1554 |
* <td valign="top"> <tt>'\u004d'</tt> |
1555 |
* <td> Minute within the hour formatted as two digits with a leading zero |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1556 |
* as necessary, i.e. {@code 00 - 59}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1557 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1558 |
* <tr><td valign="top">{@code 'S'} |
2 | 1559 |
* <td valign="top"> <tt>'\u0053'</tt> |
1560 |
* <td> Seconds within the minute, formatted as two digits with a leading |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1561 |
* zero as necessary, i.e. {@code 00 - 60} ("{@code 60}" is a special |
2 | 1562 |
* value required to support leap seconds). |
1563 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1564 |
* <tr><td valign="top">{@code 'L'} |
2 | 1565 |
* <td valign="top"> <tt>'\u004c'</tt> |
1566 |
* <td> Millisecond within the second formatted as three digits with |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1567 |
* leading zeros as necessary, i.e. {@code 000 - 999}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1568 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1569 |
* <tr><td valign="top">{@code 'N'} |
2 | 1570 |
* <td valign="top"> <tt>'\u004e'</tt> |
1571 |
* <td> Nanosecond within the second, formatted as nine digits with leading |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1572 |
* zeros as necessary, i.e. {@code 000000000 - 999999999}. The precision |
2 | 1573 |
* of this value is limited by the resolution of the underlying operating |
1574 |
* system or hardware. |
|
1575 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1576 |
* <tr><td valign="top">{@code 'p'} |
2 | 1577 |
* <td valign="top"> <tt>'\u0070'</tt> |
1578 |
* <td> Locale-specific {@linkplain |
|
1579 |
* java.text.DateFormatSymbols#getAmPmStrings morning or afternoon} marker |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1580 |
* in lower case, e.g."{@code am}" or "{@code pm}". Use of the |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1581 |
* conversion prefix {@code 'T'} forces this output to upper case. (Note |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1582 |
* that {@code 'p'} produces lower-case output. This is different from |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1583 |
* GNU {@code date} and POSIX {@code strftime(3c)} which produce |
2 | 1584 |
* upper-case output.) |
1585 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1586 |
* <tr><td valign="top">{@code 'z'} |
2 | 1587 |
* <td valign="top"> <tt>'\u007a'</tt> |
1588 |
* <td> <a href="http://www.ietf.org/rfc/rfc0822.txt">RFC 822</a> |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1589 |
* style numeric time zone offset from GMT, e.g. {@code -0800}. This |
2 | 1590 |
* value will be adjusted as necessary for Daylight Saving Time. For |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1591 |
* {@code long}, {@link Long}, and {@link Date} the time zone used is |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1592 |
* the {@linkplain TimeZone#getDefault() default time zone} for this |
2 | 1593 |
* instance of the Java virtual machine. |
1594 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1595 |
* <tr><td valign="top">{@code 'Z'} |
7273
3367d89043cf
6615506: (fmt spec) Date/Time conversion table missing column for 'Z'
sherman
parents:
6489
diff
changeset
|
1596 |
* <td valign="top"> <tt>'\u005a'</tt> |
2 | 1597 |
* <td> A string representing the abbreviation for the time zone. This |
1598 |
* value will be adjusted as necessary for Daylight Saving Time. For |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1599 |
* {@code long}, {@link Long}, and {@link Date} the time zone used is |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1600 |
* the {@linkplain TimeZone#getDefault() default time zone} for this |
2 | 1601 |
* instance of the Java virtual machine. The Formatter's locale will |
1602 |
* supersede the locale of the argument (if any). |
|
1603 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1604 |
* <tr><td valign="top">{@code 's'} |
2 | 1605 |
* <td valign="top"> <tt>'\u0073'</tt> |
1606 |
* <td> Seconds since the beginning of the epoch starting at 1 January 1970 |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1607 |
* {@code 00:00:00} UTC, i.e. {@code Long.MIN_VALUE/1000} to |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1608 |
* {@code Long.MAX_VALUE/1000}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1609 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1610 |
* <tr><td valign="top">{@code 'Q'} |
2 | 1611 |
* <td valign="top"> <tt>'\u004f'</tt> |
1612 |
* <td> Milliseconds since the beginning of the epoch starting at 1 January |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1613 |
* 1970 {@code 00:00:00} UTC, i.e. {@code Long.MIN_VALUE} to |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1614 |
* {@code Long.MAX_VALUE}. The precision of this value is limited by |
2 | 1615 |
* the resolution of the underlying operating system or hardware. |
1616 |
* |
|
1617 |
* </table> |
|
1618 |
* |
|
1619 |
* <p> The following conversion characters are used for formatting dates: |
|
1620 |
* |
|
1621 |
* <table cellpadding=5 summary="date"> |
|
1622 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1623 |
* <tr><td valign="top">{@code 'B'} |
2 | 1624 |
* <td valign="top"> <tt>'\u0042'</tt> |
1625 |
* <td> Locale-specific {@linkplain java.text.DateFormatSymbols#getMonths |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1626 |
* full month name}, e.g. {@code "January"}, {@code "February"}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1627 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1628 |
* <tr><td valign="top">{@code 'b'} |
2 | 1629 |
* <td valign="top"> <tt>'\u0062'</tt> |
1630 |
* <td> Locale-specific {@linkplain |
|
1631 |
* java.text.DateFormatSymbols#getShortMonths abbreviated month name}, |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1632 |
* e.g. {@code "Jan"}, {@code "Feb"}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1633 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1634 |
* <tr><td valign="top">{@code 'h'} |
2 | 1635 |
* <td valign="top"> <tt>'\u0068'</tt> |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1636 |
* <td> Same as {@code 'b'}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1637 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1638 |
* <tr><td valign="top">{@code 'A'} |
2 | 1639 |
* <td valign="top"> <tt>'\u0041'</tt> |
1640 |
* <td> Locale-specific full name of the {@linkplain |
|
1641 |
* java.text.DateFormatSymbols#getWeekdays day of the week}, |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1642 |
* e.g. {@code "Sunday"}, {@code "Monday"} |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1643 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1644 |
* <tr><td valign="top">{@code 'a'} |
2 | 1645 |
* <td valign="top"> <tt>'\u0061'</tt> |
1646 |
* <td> Locale-specific short name of the {@linkplain |
|
1647 |
* java.text.DateFormatSymbols#getShortWeekdays day of the week}, |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1648 |
* e.g. {@code "Sun"}, {@code "Mon"} |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1649 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1650 |
* <tr><td valign="top">{@code 'C'} |
2 | 1651 |
* <td valign="top"> <tt>'\u0043'</tt> |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1652 |
* <td> Four-digit year divided by {@code 100}, formatted as two digits |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1653 |
* with leading zero as necessary, i.e. {@code 00 - 99} |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1654 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1655 |
* <tr><td valign="top">{@code 'Y'} |
2 | 1656 |
* <td valign="top"> <tt>'\u0059'</tt> <td> Year, formatted to at least |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1657 |
* four digits with leading zeros as necessary, e.g. {@code 0092} equals |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1658 |
* {@code 92} CE for the Gregorian calendar. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1659 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1660 |
* <tr><td valign="top">{@code 'y'} |
2 | 1661 |
* <td valign="top"> <tt>'\u0079'</tt> |
1662 |
* <td> Last two digits of the year, formatted with leading zeros as |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1663 |
* necessary, i.e. {@code 00 - 99}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1664 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1665 |
* <tr><td valign="top">{@code 'j'} |
2 | 1666 |
* <td valign="top"> <tt>'\u006a'</tt> |
1667 |
* <td> Day of year, formatted as three digits with leading zeros as |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1668 |
* necessary, e.g. {@code 001 - 366} for the Gregorian calendar. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1669 |
* {@code 001} corresponds to the first day of the year. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1670 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1671 |
* <tr><td valign="top">{@code 'm'} |
2 | 1672 |
* <td valign="top"> <tt>'\u006d'</tt> |
1673 |
* <td> Month, formatted as two digits with leading zeros as necessary, |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1674 |
* i.e. {@code 01 - 13}, where "{@code 01}" is the first month of the |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1675 |
* year and ("{@code 13}" is a special value required to support lunar |
2 | 1676 |
* calendars). |
1677 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1678 |
* <tr><td valign="top">{@code 'd'} |
2 | 1679 |
* <td valign="top"> <tt>'\u0064'</tt> |
1680 |
* <td> Day of month, formatted as two digits with leading zeros as |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1681 |
* necessary, i.e. {@code 01 - 31}, where "{@code 01}" is the first day |
2 | 1682 |
* of the month. |
1683 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1684 |
* <tr><td valign="top">{@code 'e'} |
2 | 1685 |
* <td valign="top"> <tt>'\u0065'</tt> |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1686 |
* <td> Day of month, formatted as two digits, i.e. {@code 1 - 31} where |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1687 |
* "{@code 1}" is the first day of the month. |
2 | 1688 |
* |
1689 |
* </table> |
|
1690 |
* |
|
1691 |
* <p> The following conversion characters are used for formatting common |
|
1692 |
* date/time compositions. |
|
1693 |
* |
|
1694 |
* <table cellpadding=5 summary="composites"> |
|
1695 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1696 |
* <tr><td valign="top">{@code 'R'} |
2 | 1697 |
* <td valign="top"> <tt>'\u0052'</tt> |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1698 |
* <td> Time formatted for the 24-hour clock as {@code "%tH:%tM"} |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1699 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1700 |
* <tr><td valign="top">{@code 'T'} |
2 | 1701 |
* <td valign="top"> <tt>'\u0054'</tt> |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1702 |
* <td> Time formatted for the 24-hour clock as {@code "%tH:%tM:%tS"}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1703 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1704 |
* <tr><td valign="top">{@code 'r'} |
2 | 1705 |
* <td valign="top"> <tt>'\u0072'</tt> |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1706 |
* <td> Time formatted for the 12-hour clock as {@code "%tI:%tM:%tS |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1707 |
* %Tp"}. The location of the morning or afternoon marker |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1708 |
* ({@code '%Tp'}) may be locale-dependent. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1709 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1710 |
* <tr><td valign="top">{@code 'D'} |
2 | 1711 |
* <td valign="top"> <tt>'\u0044'</tt> |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1712 |
* <td> Date formatted as {@code "%tm/%td/%ty"}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1713 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1714 |
* <tr><td valign="top">{@code 'F'} |
2 | 1715 |
* <td valign="top"> <tt>'\u0046'</tt> |
1716 |
* <td> <a href="http://www.w3.org/TR/NOTE-datetime">ISO 8601</a> |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1717 |
* complete date formatted as {@code "%tY-%tm-%td"}. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1718 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1719 |
* <tr><td valign="top">{@code 'c'} |
2 | 1720 |
* <td valign="top"> <tt>'\u0063'</tt> |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1721 |
* <td> Date and time formatted as {@code "%ta %tb %td %tT %tZ %tY"}, |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1722 |
* e.g. {@code "Sun Jul 20 16:17:00 EDT 1969"}. |
2 | 1723 |
* |
1724 |
* </table> |
|
1725 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1726 |
* <p> The {@code '-'} flag defined for <a href="#dFlags">General |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1727 |
* conversions</a> applies. If the {@code '#'} flag is given, then a {@link |
2 | 1728 |
* FormatFlagsConversionMismatchException} will be thrown. |
1729 |
* |
|
18774 | 1730 |
* <p> The width is the minimum number of characters to |
2 | 1731 |
* be written to the output. If the length of the converted value is less than |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1732 |
* the {@code width} then the output will be padded by spaces |
2 | 1733 |
* (<tt>'\u0020'</tt>) until the total number of characters equals width. |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1734 |
* The padding is on the left by default. If the {@code '-'} flag is given |
2 | 1735 |
* then the padding will be on the right. If width is not specified then there |
1736 |
* is no minimum. |
|
1737 |
* |
|
1738 |
* <p> The precision is not applicable. If the precision is specified then an |
|
1739 |
* {@link IllegalFormatPrecisionException} will be thrown. |
|
1740 |
* |
|
1741 |
* <h4><a name="dper">Percent</a></h4> |
|
1742 |
* |
|
1743 |
* <p> The conversion does not correspond to any argument. |
|
1744 |
* |
|
1745 |
* <table cellpadding=5 summary="DTConv"> |
|
1746 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1747 |
* <tr><td valign="top">{@code '%'} |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1748 |
* <td> The result is a literal {@code '%'} (<tt>'\u0025'</tt>) |
2 | 1749 |
* |
18774 | 1750 |
* <p> The width is the minimum number of characters to |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1751 |
* be written to the output including the {@code '%'}. If the length of the |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1752 |
* converted value is less than the {@code width} then the output will be |
2 | 1753 |
* padded by spaces (<tt>'\u0020'</tt>) until the total number of |
1754 |
* characters equals width. The padding is on the left. If width is not |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1755 |
* specified then just the {@code '%'} is output. |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1756 |
* |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1757 |
* <p> The {@code '-'} flag defined for <a href="#dFlags">General |
2 | 1758 |
* conversions</a> applies. If any other flags are provided, then a |
1759 |
* {@link FormatFlagsConversionMismatchException} will be thrown. |
|
1760 |
* |
|
1761 |
* <p> The precision is not applicable. If the precision is specified an |
|
1762 |
* {@link IllegalFormatPrecisionException} will be thrown. |
|
1763 |
* |
|
1764 |
* </table> |
|
1765 |
* |
|
1766 |
* <h4><a name="dls">Line Separator</a></h4> |
|
1767 |
* |
|
1768 |
* <p> The conversion does not correspond to any argument. |
|
1769 |
* |
|
1770 |
* <table cellpadding=5 summary="DTConv"> |
|
1771 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1772 |
* <tr><td valign="top">{@code 'n'} |
2 | 1773 |
* <td> the platform-specific line separator as returned by {@link |
1774 |
* System#getProperty System.getProperty("line.separator")}. |
|
1775 |
* |
|
1776 |
* </table> |
|
1777 |
* |
|
1778 |
* <p> Flags, width, and precision are not applicable. If any are provided an |
|
1779 |
* {@link IllegalFormatFlagsException}, {@link IllegalFormatWidthException}, |
|
1780 |
* and {@link IllegalFormatPrecisionException}, respectively will be thrown. |
|
1781 |
* |
|
1782 |
* <h4><a name="dpos">Argument Index</a></h4> |
|
1783 |
* |
|
1784 |
* <p> Format specifiers can reference arguments in three ways: |
|
1785 |
* |
|
1786 |
* <ul> |
|
1787 |
* |
|
1788 |
* <li> <i>Explicit indexing</i> is used when the format specifier contains an |
|
1789 |
* argument index. The argument index is a decimal integer indicating the |
|
1790 |
* position of the argument in the argument list. The first argument is |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1791 |
* referenced by "{@code 1$}", the second by "{@code 2$}", etc. An argument |
2 | 1792 |
* may be referenced more than once. |
1793 |
* |
|
1794 |
* <p> For example: |
|
1795 |
* |
|
1796 |
* <blockquote><pre> |
|
1797 |
* formatter.format("%4$s %3$s %2$s %1$s %4$s %3$s %2$s %1$s", |
|
1798 |
* "a", "b", "c", "d") |
|
1799 |
* // -> "d c b a d c b a" |
|
1800 |
* </pre></blockquote> |
|
1801 |
* |
|
1802 |
* <li> <i>Relative indexing</i> is used when the format specifier contains a |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1803 |
* {@code '<'} (<tt>'\u003c'</tt>) flag which causes the argument for |
2 | 1804 |
* the previous format specifier to be re-used. If there is no previous |
1805 |
* argument, then a {@link MissingFormatArgumentException} is thrown. |
|
1806 |
* |
|
1807 |
* <blockquote><pre> |
|
1808 |
* formatter.format("%s %s %<s %<s", "a", "b", "c", "d") |
|
1809 |
* // -> "a b b b" |
|
1810 |
* // "c" and "d" are ignored because they are not referenced |
|
1811 |
* </pre></blockquote> |
|
1812 |
* |
|
1813 |
* <li> <i>Ordinary indexing</i> is used when the format specifier contains |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1814 |
* neither an argument index nor a {@code '<'} flag. Each format specifier |
2 | 1815 |
* which uses ordinary indexing is assigned a sequential implicit index into |
1816 |
* argument list which is independent of the indices used by explicit or |
|
1817 |
* relative indexing. |
|
1818 |
* |
|
1819 |
* <blockquote><pre> |
|
1820 |
* formatter.format("%s %s %s %s", "a", "b", "c", "d") |
|
1821 |
* // -> "a b c d" |
|
1822 |
* </pre></blockquote> |
|
1823 |
* |
|
1824 |
* </ul> |
|
1825 |
* |
|
1826 |
* <p> It is possible to have a format string which uses all forms of indexing, |
|
1827 |
* for example: |
|
1828 |
* |
|
1829 |
* <blockquote><pre> |
|
1830 |
* formatter.format("%2$s %s %<s %s", "a", "b", "c", "d") |
|
1831 |
* // -> "b a a b" |
|
1832 |
* // "c" and "d" are ignored because they are not referenced |
|
1833 |
* </pre></blockquote> |
|
1834 |
* |
|
1835 |
* <p> The maximum number of arguments is limited by the maximum dimension of a |
|
9266
121fb370f179
7032960: API files in java.awt need to be updated for references to JVM Spec with editions/hyperlinks
jjh
parents:
8799
diff
changeset
|
1836 |
* Java array as defined by |
121fb370f179
7032960: API files in java.awt need to be updated for references to JVM Spec with editions/hyperlinks
jjh
parents:
8799
diff
changeset
|
1837 |
* <cite>The Java™ Virtual Machine Specification</cite>. |
121fb370f179
7032960: API files in java.awt need to be updated for references to JVM Spec with editions/hyperlinks
jjh
parents:
8799
diff
changeset
|
1838 |
* If the argument index is does not correspond to an |
2 | 1839 |
* available argument, then a {@link MissingFormatArgumentException} is thrown. |
1840 |
* |
|
1841 |
* <p> If there are more arguments than format specifiers, the extra arguments |
|
1842 |
* are ignored. |
|
1843 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1844 |
* <p> Unless otherwise specified, passing a {@code null} argument to any |
2 | 1845 |
* method or constructor in this class will cause a {@link |
1846 |
* NullPointerException} to be thrown. |
|
1847 |
* |
|
1848 |
* @author Iris Clark |
|
1849 |
* @since 1.5 |
|
1850 |
*/ |
|
1851 |
public final class Formatter implements Closeable, Flushable { |
|
1852 |
private Appendable a; |
|
7966
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1853 |
private final Locale l; |
2 | 1854 |
|
1855 |
private IOException lastException; |
|
1856 |
||
7966
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1857 |
private final char zero; |
2 | 1858 |
private static double scaleUp; |
1859 |
||
1860 |
// 1 (sign) + 19 (max # sig digits) + 1 ('.') + 1 ('e') + 1 (sign) |
|
1861 |
// + 3 (max # exp digits) + 4 (error) = 30 |
|
1862 |
private static final int MAX_FD_CHARS = 30; |
|
1863 |
||
7966
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1864 |
/** |
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1865 |
* Returns a charset object for the given charset name. |
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1866 |
* @throws NullPointerException is csn is null |
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1867 |
* @throws UnsupportedEncodingException if the charset is not supported |
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1868 |
*/ |
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1869 |
private static Charset toCharset(String csn) |
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1870 |
throws UnsupportedEncodingException |
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1871 |
{ |
8166
13423c0952ad
7012540: java.util.Objects.nonNull() incorrectly named
briangoetz
parents:
7966
diff
changeset
|
1872 |
Objects.requireNonNull(csn, "charsetName"); |
7966
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1873 |
try { |
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1874 |
return Charset.forName(csn); |
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1875 |
} catch (IllegalCharsetNameException|UnsupportedCharsetException unused) { |
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1876 |
// UnsupportedEncodingException should be thrown |
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1877 |
throw new UnsupportedEncodingException(csn); |
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1878 |
} |
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1879 |
} |
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1880 |
|
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1881 |
private static final Appendable nonNullAppendable(Appendable a) { |
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1882 |
if (a == null) |
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1883 |
return new StringBuilder(); |
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1884 |
|
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1885 |
return a; |
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1886 |
} |
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1887 |
|
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1888 |
/* Private constructors */ |
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1889 |
private Formatter(Locale l, Appendable a) { |
2 | 1890 |
this.a = a; |
1891 |
this.l = l; |
|
7966
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1892 |
this.zero = getZero(l); |
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1893 |
} |
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1894 |
|
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1895 |
private Formatter(Charset charset, Locale l, File file) |
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1896 |
throws FileNotFoundException |
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1897 |
{ |
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1898 |
this(l, |
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1899 |
new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), charset))); |
2 | 1900 |
} |
1901 |
||
1902 |
/** |
|
1903 |
* Constructs a new formatter. |
|
1904 |
* |
|
1905 |
* <p> The destination of the formatted output is a {@link StringBuilder} |
|
1906 |
* which may be retrieved by invoking {@link #out out()} and whose |
|
1907 |
* current content may be converted into a string by invoking {@link |
|
1908 |
* #toString toString()}. The locale used is the {@linkplain |
|
16010
2727163b5df5
7092447: Clarify the default locale used in each locale sensitive operation
naoto
parents:
15658
diff
changeset
|
1909 |
* Locale#getDefault(Locale.Category) default locale} for |
2727163b5df5
7092447: Clarify the default locale used in each locale sensitive operation
naoto
parents:
15658
diff
changeset
|
1910 |
* {@linkplain Locale.Category#FORMAT formatting} for this instance of the Java |
2 | 1911 |
* virtual machine. |
1912 |
*/ |
|
1913 |
public Formatter() { |
|
7966
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1914 |
this(Locale.getDefault(Locale.Category.FORMAT), new StringBuilder()); |
2 | 1915 |
} |
1916 |
||
1917 |
/** |
|
1918 |
* Constructs a new formatter with the specified destination. |
|
1919 |
* |
|
16010
2727163b5df5
7092447: Clarify the default locale used in each locale sensitive operation
naoto
parents:
15658
diff
changeset
|
1920 |
* <p> The locale used is the {@linkplain |
2727163b5df5
7092447: Clarify the default locale used in each locale sensitive operation
naoto
parents:
15658
diff
changeset
|
1921 |
* Locale#getDefault(Locale.Category) default locale} for |
2727163b5df5
7092447: Clarify the default locale used in each locale sensitive operation
naoto
parents:
15658
diff
changeset
|
1922 |
* {@linkplain Locale.Category#FORMAT formatting} for this instance of the Java |
2727163b5df5
7092447: Clarify the default locale used in each locale sensitive operation
naoto
parents:
15658
diff
changeset
|
1923 |
* virtual machine. |
2 | 1924 |
* |
1925 |
* @param a |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1926 |
* Destination for the formatted output. If {@code a} is |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1927 |
* {@code null} then a {@link StringBuilder} will be created. |
2 | 1928 |
*/ |
1929 |
public Formatter(Appendable a) { |
|
7966
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1930 |
this(Locale.getDefault(Locale.Category.FORMAT), nonNullAppendable(a)); |
2 | 1931 |
} |
1932 |
||
1933 |
/** |
|
1934 |
* Constructs a new formatter with the specified locale. |
|
1935 |
* |
|
1936 |
* <p> The destination of the formatted output is a {@link StringBuilder} |
|
1937 |
* which may be retrieved by invoking {@link #out out()} and whose current |
|
1938 |
* content may be converted into a string by invoking {@link #toString |
|
1939 |
* toString()}. |
|
1940 |
* |
|
1941 |
* @param l |
|
1942 |
* The {@linkplain java.util.Locale locale} to apply during |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1943 |
* formatting. If {@code l} is {@code null} then no localization |
2 | 1944 |
* is applied. |
1945 |
*/ |
|
1946 |
public Formatter(Locale l) { |
|
7966
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1947 |
this(l, new StringBuilder()); |
2 | 1948 |
} |
1949 |
||
1950 |
/** |
|
1951 |
* Constructs a new formatter with the specified destination and locale. |
|
1952 |
* |
|
1953 |
* @param a |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1954 |
* Destination for the formatted output. If {@code a} is |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1955 |
* {@code null} then a {@link StringBuilder} will be created. |
2 | 1956 |
* |
1957 |
* @param l |
|
1958 |
* The {@linkplain java.util.Locale locale} to apply during |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
1959 |
* formatting. If {@code l} is {@code null} then no localization |
2 | 1960 |
* is applied. |
1961 |
*/ |
|
1962 |
public Formatter(Appendable a, Locale l) { |
|
7966
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1963 |
this(l, nonNullAppendable(a)); |
2 | 1964 |
} |
1965 |
||
1966 |
/** |
|
1967 |
* Constructs a new formatter with the specified file name. |
|
1968 |
* |
|
1969 |
* <p> The charset used is the {@linkplain |
|
1970 |
* java.nio.charset.Charset#defaultCharset() default charset} for this |
|
1971 |
* instance of the Java virtual machine. |
|
1972 |
* |
|
16010
2727163b5df5
7092447: Clarify the default locale used in each locale sensitive operation
naoto
parents:
15658
diff
changeset
|
1973 |
* <p> The locale used is the {@linkplain |
2727163b5df5
7092447: Clarify the default locale used in each locale sensitive operation
naoto
parents:
15658
diff
changeset
|
1974 |
* Locale#getDefault(Locale.Category) default locale} for |
2727163b5df5
7092447: Clarify the default locale used in each locale sensitive operation
naoto
parents:
15658
diff
changeset
|
1975 |
* {@linkplain Locale.Category#FORMAT formatting} for this instance of the Java |
2727163b5df5
7092447: Clarify the default locale used in each locale sensitive operation
naoto
parents:
15658
diff
changeset
|
1976 |
* virtual machine. |
2 | 1977 |
* |
1978 |
* @param fileName |
|
1979 |
* The name of the file to use as the destination of this |
|
1980 |
* formatter. If the file exists then it will be truncated to |
|
1981 |
* zero size; otherwise, a new file will be created. The output |
|
1982 |
* will be written to the file and is buffered. |
|
1983 |
* |
|
1984 |
* @throws SecurityException |
|
1985 |
* If a security manager is present and {@link |
|
1986 |
* SecurityManager#checkWrite checkWrite(fileName)} denies write |
|
1987 |
* access to the file |
|
1988 |
* |
|
1989 |
* @throws FileNotFoundException |
|
1990 |
* If the given file name does not denote an existing, writable |
|
1991 |
* regular file and a new regular file of that name cannot be |
|
1992 |
* created, or if some other error occurs while opening or |
|
1993 |
* creating the file |
|
1994 |
*/ |
|
1995 |
public Formatter(String fileName) throws FileNotFoundException { |
|
7966
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1996 |
this(Locale.getDefault(Locale.Category.FORMAT), |
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
1997 |
new BufferedWriter(new OutputStreamWriter(new FileOutputStream(fileName)))); |
2 | 1998 |
} |
1999 |
||
2000 |
/** |
|
2001 |
* Constructs a new formatter with the specified file name and charset. |
|
2002 |
* |
|
16010
2727163b5df5
7092447: Clarify the default locale used in each locale sensitive operation
naoto
parents:
15658
diff
changeset
|
2003 |
* <p> The locale used is the {@linkplain |
2727163b5df5
7092447: Clarify the default locale used in each locale sensitive operation
naoto
parents:
15658
diff
changeset
|
2004 |
* Locale#getDefault(Locale.Category) default locale} for |
2727163b5df5
7092447: Clarify the default locale used in each locale sensitive operation
naoto
parents:
15658
diff
changeset
|
2005 |
* {@linkplain Locale.Category#FORMAT formatting} for this instance of the Java |
2727163b5df5
7092447: Clarify the default locale used in each locale sensitive operation
naoto
parents:
15658
diff
changeset
|
2006 |
* virtual machine. |
2 | 2007 |
* |
2008 |
* @param fileName |
|
2009 |
* The name of the file to use as the destination of this |
|
2010 |
* formatter. If the file exists then it will be truncated to |
|
2011 |
* zero size; otherwise, a new file will be created. The output |
|
2012 |
* will be written to the file and is buffered. |
|
2013 |
* |
|
2014 |
* @param csn |
|
2015 |
* The name of a supported {@linkplain java.nio.charset.Charset |
|
2016 |
* charset} |
|
2017 |
* |
|
2018 |
* @throws FileNotFoundException |
|
2019 |
* If the given file name does not denote an existing, writable |
|
2020 |
* regular file and a new regular file of that name cannot be |
|
2021 |
* created, or if some other error occurs while opening or |
|
2022 |
* creating the file |
|
2023 |
* |
|
2024 |
* @throws SecurityException |
|
2025 |
* If a security manager is present and {@link |
|
2026 |
* SecurityManager#checkWrite checkWrite(fileName)} denies write |
|
2027 |
* access to the file |
|
2028 |
* |
|
2029 |
* @throws UnsupportedEncodingException |
|
2030 |
* If the named charset is not supported |
|
2031 |
*/ |
|
2032 |
public Formatter(String fileName, String csn) |
|
2033 |
throws FileNotFoundException, UnsupportedEncodingException |
|
2034 |
{ |
|
6489
9e7015635425
4700857: RFE: separating user locale and user interface locale
naoto
parents:
5506
diff
changeset
|
2035 |
this(fileName, csn, Locale.getDefault(Locale.Category.FORMAT)); |
2 | 2036 |
} |
2037 |
||
2038 |
/** |
|
2039 |
* Constructs a new formatter with the specified file name, charset, and |
|
2040 |
* locale. |
|
2041 |
* |
|
2042 |
* @param fileName |
|
2043 |
* The name of the file to use as the destination of this |
|
2044 |
* formatter. If the file exists then it will be truncated to |
|
2045 |
* zero size; otherwise, a new file will be created. The output |
|
2046 |
* will be written to the file and is buffered. |
|
2047 |
* |
|
2048 |
* @param csn |
|
2049 |
* The name of a supported {@linkplain java.nio.charset.Charset |
|
2050 |
* charset} |
|
2051 |
* |
|
2052 |
* @param l |
|
2053 |
* The {@linkplain java.util.Locale locale} to apply during |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
2054 |
* formatting. If {@code l} is {@code null} then no localization |
2 | 2055 |
* is applied. |
2056 |
* |
|
2057 |
* @throws FileNotFoundException |
|
2058 |
* If the given file name does not denote an existing, writable |
|
2059 |
* regular file and a new regular file of that name cannot be |
|
2060 |
* created, or if some other error occurs while opening or |
|
2061 |
* creating the file |
|
2062 |
* |
|
2063 |
* @throws SecurityException |
|
2064 |
* If a security manager is present and {@link |
|
2065 |
* SecurityManager#checkWrite checkWrite(fileName)} denies write |
|
2066 |
* access to the file |
|
2067 |
* |
|
2068 |
* @throws UnsupportedEncodingException |
|
2069 |
* If the named charset is not supported |
|
2070 |
*/ |
|
2071 |
public Formatter(String fileName, String csn, Locale l) |
|
2072 |
throws FileNotFoundException, UnsupportedEncodingException |
|
2073 |
{ |
|
7966
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
2074 |
this(toCharset(csn), l, new File(fileName)); |
2 | 2075 |
} |
2076 |
||
2077 |
/** |
|
2078 |
* Constructs a new formatter with the specified file. |
|
2079 |
* |
|
2080 |
* <p> The charset used is the {@linkplain |
|
2081 |
* java.nio.charset.Charset#defaultCharset() default charset} for this |
|
2082 |
* instance of the Java virtual machine. |
|
2083 |
* |
|
16010
2727163b5df5
7092447: Clarify the default locale used in each locale sensitive operation
naoto
parents:
15658
diff
changeset
|
2084 |
* <p> The locale used is the {@linkplain |
2727163b5df5
7092447: Clarify the default locale used in each locale sensitive operation
naoto
parents:
15658
diff
changeset
|
2085 |
* Locale#getDefault(Locale.Category) default locale} for |
2727163b5df5
7092447: Clarify the default locale used in each locale sensitive operation
naoto
parents:
15658
diff
changeset
|
2086 |
* {@linkplain Locale.Category#FORMAT formatting} for this instance of the Java |
2727163b5df5
7092447: Clarify the default locale used in each locale sensitive operation
naoto
parents:
15658
diff
changeset
|
2087 |
* virtual machine. |
2 | 2088 |
* |
2089 |
* @param file |
|
2090 |
* The file to use as the destination of this formatter. If the |
|
2091 |
* file exists then it will be truncated to zero size; otherwise, |
|
2092 |
* a new file will be created. The output will be written to the |
|
2093 |
* file and is buffered. |
|
2094 |
* |
|
2095 |
* @throws SecurityException |
|
2096 |
* If a security manager is present and {@link |
|
2097 |
* SecurityManager#checkWrite checkWrite(file.getPath())} denies |
|
2098 |
* write access to the file |
|
2099 |
* |
|
2100 |
* @throws FileNotFoundException |
|
2101 |
* If the given file object does not denote an existing, writable |
|
2102 |
* regular file and a new regular file of that name cannot be |
|
2103 |
* created, or if some other error occurs while opening or |
|
2104 |
* creating the file |
|
2105 |
*/ |
|
2106 |
public Formatter(File file) throws FileNotFoundException { |
|
7966
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
2107 |
this(Locale.getDefault(Locale.Category.FORMAT), |
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
2108 |
new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file)))); |
2 | 2109 |
} |
2110 |
||
2111 |
/** |
|
2112 |
* Constructs a new formatter with the specified file and charset. |
|
2113 |
* |
|
16010
2727163b5df5
7092447: Clarify the default locale used in each locale sensitive operation
naoto
parents:
15658
diff
changeset
|
2114 |
* <p> The locale used is the {@linkplain |
2727163b5df5
7092447: Clarify the default locale used in each locale sensitive operation
naoto
parents:
15658
diff
changeset
|
2115 |
* Locale#getDefault(Locale.Category) default locale} for |
2727163b5df5
7092447: Clarify the default locale used in each locale sensitive operation
naoto
parents:
15658
diff
changeset
|
2116 |
* {@linkplain Locale.Category#FORMAT formatting} for this instance of the Java |
2727163b5df5
7092447: Clarify the default locale used in each locale sensitive operation
naoto
parents:
15658
diff
changeset
|
2117 |
* virtual machine. |
2 | 2118 |
* |
2119 |
* @param file |
|
2120 |
* The file to use as the destination of this formatter. If the |
|
2121 |
* file exists then it will be truncated to zero size; otherwise, |
|
2122 |
* a new file will be created. The output will be written to the |
|
2123 |
* file and is buffered. |
|
2124 |
* |
|
2125 |
* @param csn |
|
2126 |
* The name of a supported {@linkplain java.nio.charset.Charset |
|
2127 |
* charset} |
|
2128 |
* |
|
2129 |
* @throws FileNotFoundException |
|
2130 |
* If the given file object does not denote an existing, writable |
|
2131 |
* regular file and a new regular file of that name cannot be |
|
2132 |
* created, or if some other error occurs while opening or |
|
2133 |
* creating the file |
|
2134 |
* |
|
2135 |
* @throws SecurityException |
|
2136 |
* If a security manager is present and {@link |
|
2137 |
* SecurityManager#checkWrite checkWrite(file.getPath())} denies |
|
2138 |
* write access to the file |
|
2139 |
* |
|
2140 |
* @throws UnsupportedEncodingException |
|
2141 |
* If the named charset is not supported |
|
2142 |
*/ |
|
2143 |
public Formatter(File file, String csn) |
|
2144 |
throws FileNotFoundException, UnsupportedEncodingException |
|
2145 |
{ |
|
6489
9e7015635425
4700857: RFE: separating user locale and user interface locale
naoto
parents:
5506
diff
changeset
|
2146 |
this(file, csn, Locale.getDefault(Locale.Category.FORMAT)); |
2 | 2147 |
} |
2148 |
||
2149 |
/** |
|
2150 |
* Constructs a new formatter with the specified file, charset, and |
|
2151 |
* locale. |
|
2152 |
* |
|
2153 |
* @param file |
|
2154 |
* The file to use as the destination of this formatter. If the |
|
2155 |
* file exists then it will be truncated to zero size; otherwise, |
|
2156 |
* a new file will be created. The output will be written to the |
|
2157 |
* file and is buffered. |
|
2158 |
* |
|
2159 |
* @param csn |
|
2160 |
* The name of a supported {@linkplain java.nio.charset.Charset |
|
2161 |
* charset} |
|
2162 |
* |
|
2163 |
* @param l |
|
2164 |
* The {@linkplain java.util.Locale locale} to apply during |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
2165 |
* formatting. If {@code l} is {@code null} then no localization |
2 | 2166 |
* is applied. |
2167 |
* |
|
2168 |
* @throws FileNotFoundException |
|
2169 |
* If the given file object does not denote an existing, writable |
|
2170 |
* regular file and a new regular file of that name cannot be |
|
2171 |
* created, or if some other error occurs while opening or |
|
2172 |
* creating the file |
|
2173 |
* |
|
2174 |
* @throws SecurityException |
|
2175 |
* If a security manager is present and {@link |
|
2176 |
* SecurityManager#checkWrite checkWrite(file.getPath())} denies |
|
2177 |
* write access to the file |
|
2178 |
* |
|
2179 |
* @throws UnsupportedEncodingException |
|
2180 |
* If the named charset is not supported |
|
2181 |
*/ |
|
2182 |
public Formatter(File file, String csn, Locale l) |
|
2183 |
throws FileNotFoundException, UnsupportedEncodingException |
|
2184 |
{ |
|
7966
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
2185 |
this(toCharset(csn), l, file); |
2 | 2186 |
} |
2187 |
||
2188 |
/** |
|
2189 |
* Constructs a new formatter with the specified print stream. |
|
2190 |
* |
|
16010
2727163b5df5
7092447: Clarify the default locale used in each locale sensitive operation
naoto
parents:
15658
diff
changeset
|
2191 |
* <p> The locale used is the {@linkplain |
2727163b5df5
7092447: Clarify the default locale used in each locale sensitive operation
naoto
parents:
15658
diff
changeset
|
2192 |
* Locale#getDefault(Locale.Category) default locale} for |
2727163b5df5
7092447: Clarify the default locale used in each locale sensitive operation
naoto
parents:
15658
diff
changeset
|
2193 |
* {@linkplain Locale.Category#FORMAT formatting} for this instance of the Java |
2727163b5df5
7092447: Clarify the default locale used in each locale sensitive operation
naoto
parents:
15658
diff
changeset
|
2194 |
* virtual machine. |
2 | 2195 |
* |
2196 |
* <p> Characters are written to the given {@link java.io.PrintStream |
|
2197 |
* PrintStream} object and are therefore encoded using that object's |
|
2198 |
* charset. |
|
2199 |
* |
|
2200 |
* @param ps |
|
2201 |
* The stream to use as the destination of this formatter. |
|
2202 |
*/ |
|
2203 |
public Formatter(PrintStream ps) { |
|
7966
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
2204 |
this(Locale.getDefault(Locale.Category.FORMAT), |
8166
13423c0952ad
7012540: java.util.Objects.nonNull() incorrectly named
briangoetz
parents:
7966
diff
changeset
|
2205 |
(Appendable)Objects.requireNonNull(ps)); |
2 | 2206 |
} |
2207 |
||
2208 |
/** |
|
2209 |
* Constructs a new formatter with the specified output stream. |
|
2210 |
* |
|
2211 |
* <p> The charset used is the {@linkplain |
|
2212 |
* java.nio.charset.Charset#defaultCharset() default charset} for this |
|
2213 |
* instance of the Java virtual machine. |
|
2214 |
* |
|
16010
2727163b5df5
7092447: Clarify the default locale used in each locale sensitive operation
naoto
parents:
15658
diff
changeset
|
2215 |
* <p> The locale used is the {@linkplain |
2727163b5df5
7092447: Clarify the default locale used in each locale sensitive operation
naoto
parents:
15658
diff
changeset
|
2216 |
* Locale#getDefault(Locale.Category) default locale} for |
2727163b5df5
7092447: Clarify the default locale used in each locale sensitive operation
naoto
parents:
15658
diff
changeset
|
2217 |
* {@linkplain Locale.Category#FORMAT formatting} for this instance of the Java |
2727163b5df5
7092447: Clarify the default locale used in each locale sensitive operation
naoto
parents:
15658
diff
changeset
|
2218 |
* virtual machine. |
2 | 2219 |
* |
2220 |
* @param os |
|
2221 |
* The output stream to use as the destination of this formatter. |
|
2222 |
* The output will be buffered. |
|
2223 |
*/ |
|
2224 |
public Formatter(OutputStream os) { |
|
7966
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
2225 |
this(Locale.getDefault(Locale.Category.FORMAT), |
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
2226 |
new BufferedWriter(new OutputStreamWriter(os))); |
2 | 2227 |
} |
2228 |
||
2229 |
/** |
|
2230 |
* Constructs a new formatter with the specified output stream and |
|
2231 |
* charset. |
|
2232 |
* |
|
16010
2727163b5df5
7092447: Clarify the default locale used in each locale sensitive operation
naoto
parents:
15658
diff
changeset
|
2233 |
* <p> The locale used is the {@linkplain |
2727163b5df5
7092447: Clarify the default locale used in each locale sensitive operation
naoto
parents:
15658
diff
changeset
|
2234 |
* Locale#getDefault(Locale.Category) default locale} for |
2727163b5df5
7092447: Clarify the default locale used in each locale sensitive operation
naoto
parents:
15658
diff
changeset
|
2235 |
* {@linkplain Locale.Category#FORMAT formatting} for this instance of the Java |
2727163b5df5
7092447: Clarify the default locale used in each locale sensitive operation
naoto
parents:
15658
diff
changeset
|
2236 |
* virtual machine. |
2 | 2237 |
* |
2238 |
* @param os |
|
2239 |
* The output stream to use as the destination of this formatter. |
|
2240 |
* The output will be buffered. |
|
2241 |
* |
|
2242 |
* @param csn |
|
2243 |
* The name of a supported {@linkplain java.nio.charset.Charset |
|
2244 |
* charset} |
|
2245 |
* |
|
2246 |
* @throws UnsupportedEncodingException |
|
2247 |
* If the named charset is not supported |
|
2248 |
*/ |
|
2249 |
public Formatter(OutputStream os, String csn) |
|
2250 |
throws UnsupportedEncodingException |
|
2251 |
{ |
|
6489
9e7015635425
4700857: RFE: separating user locale and user interface locale
naoto
parents:
5506
diff
changeset
|
2252 |
this(os, csn, Locale.getDefault(Locale.Category.FORMAT)); |
2 | 2253 |
} |
2254 |
||
2255 |
/** |
|
2256 |
* Constructs a new formatter with the specified output stream, charset, |
|
2257 |
* and locale. |
|
2258 |
* |
|
2259 |
* @param os |
|
2260 |
* The output stream to use as the destination of this formatter. |
|
2261 |
* The output will be buffered. |
|
2262 |
* |
|
2263 |
* @param csn |
|
2264 |
* The name of a supported {@linkplain java.nio.charset.Charset |
|
2265 |
* charset} |
|
2266 |
* |
|
2267 |
* @param l |
|
2268 |
* The {@linkplain java.util.Locale locale} to apply during |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
2269 |
* formatting. If {@code l} is {@code null} then no localization |
2 | 2270 |
* is applied. |
2271 |
* |
|
2272 |
* @throws UnsupportedEncodingException |
|
2273 |
* If the named charset is not supported |
|
2274 |
*/ |
|
2275 |
public Formatter(OutputStream os, String csn, Locale l) |
|
2276 |
throws UnsupportedEncodingException |
|
2277 |
{ |
|
7966
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
2278 |
this(l, new BufferedWriter(new OutputStreamWriter(os, csn))); |
2 | 2279 |
} |
2280 |
||
7966
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
2281 |
private static char getZero(Locale l) { |
2 | 2282 |
if ((l != null) && !l.equals(Locale.US)) { |
2283 |
DecimalFormatSymbols dfs = DecimalFormatSymbols.getInstance(l); |
|
7966
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
2284 |
return dfs.getZeroDigit(); |
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
2285 |
} else { |
a23e3f47c5a8
7000511: PrintStream, PrintWriter, Formatter, Scanner leave files open when exception thrown
chegar
parents:
7816
diff
changeset
|
2286 |
return '0'; |
2 | 2287 |
} |
2288 |
} |
|
2289 |
||
2290 |
/** |
|
2291 |
* Returns the locale set by the construction of this formatter. |
|
2292 |
* |
|
2293 |
* <p> The {@link #format(java.util.Locale,String,Object...) format} method |
|
2294 |
* for this object which has a locale argument does not change this value. |
|
2295 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
2296 |
* @return {@code null} if no localization is applied, otherwise a |
2 | 2297 |
* locale |
2298 |
* |
|
2299 |
* @throws FormatterClosedException |
|
2300 |
* If this formatter has been closed by invoking its {@link |
|
2301 |
* #close()} method |
|
2302 |
*/ |
|
2303 |
public Locale locale() { |
|
2304 |
ensureOpen(); |
|
2305 |
return l; |
|
2306 |
} |
|
2307 |
||
2308 |
/** |
|
2309 |
* Returns the destination for the output. |
|
2310 |
* |
|
2311 |
* @return The destination for the output |
|
2312 |
* |
|
2313 |
* @throws FormatterClosedException |
|
2314 |
* If this formatter has been closed by invoking its {@link |
|
2315 |
* #close()} method |
|
2316 |
*/ |
|
2317 |
public Appendable out() { |
|
2318 |
ensureOpen(); |
|
2319 |
return a; |
|
2320 |
} |
|
2321 |
||
2322 |
/** |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
2323 |
* Returns the result of invoking {@code toString()} on the destination |
2 | 2324 |
* for the output. For example, the following code formats text into a |
2325 |
* {@link StringBuilder} then retrieves the resultant string: |
|
2326 |
* |
|
2327 |
* <blockquote><pre> |
|
2328 |
* Formatter f = new Formatter(); |
|
2329 |
* f.format("Last reboot at %tc", lastRebootDate); |
|
2330 |
* String s = f.toString(); |
|
2331 |
* // -> s == "Last reboot at Sat Jan 01 00:00:00 PST 2000" |
|
2332 |
* </pre></blockquote> |
|
2333 |
* |
|
2334 |
* <p> An invocation of this method behaves in exactly the same way as the |
|
2335 |
* invocation |
|
2336 |
* |
|
2337 |
* <pre> |
|
2338 |
* out().toString() </pre> |
|
2339 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
2340 |
* <p> Depending on the specification of {@code toString} for the {@link |
2 | 2341 |
* Appendable}, the returned string may or may not contain the characters |
2342 |
* written to the destination. For instance, buffers typically return |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
2343 |
* their contents in {@code toString()}, but streams cannot since the |
2 | 2344 |
* data is discarded. |
2345 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
2346 |
* @return The result of invoking {@code toString()} on the destination |
2 | 2347 |
* for the output |
2348 |
* |
|
2349 |
* @throws FormatterClosedException |
|
2350 |
* If this formatter has been closed by invoking its {@link |
|
2351 |
* #close()} method |
|
2352 |
*/ |
|
2353 |
public String toString() { |
|
2354 |
ensureOpen(); |
|
2355 |
return a.toString(); |
|
2356 |
} |
|
2357 |
||
2358 |
/** |
|
2359 |
* Flushes this formatter. If the destination implements the {@link |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
2360 |
* java.io.Flushable} interface, its {@code flush} method will be invoked. |
2 | 2361 |
* |
2362 |
* <p> Flushing a formatter writes any buffered output in the destination |
|
2363 |
* to the underlying stream. |
|
2364 |
* |
|
2365 |
* @throws FormatterClosedException |
|
2366 |
* If this formatter has been closed by invoking its {@link |
|
2367 |
* #close()} method |
|
2368 |
*/ |
|
2369 |
public void flush() { |
|
2370 |
ensureOpen(); |
|
2371 |
if (a instanceof Flushable) { |
|
2372 |
try { |
|
2373 |
((Flushable)a).flush(); |
|
2374 |
} catch (IOException ioe) { |
|
2375 |
lastException = ioe; |
|
2376 |
} |
|
2377 |
} |
|
2378 |
} |
|
2379 |
||
2380 |
/** |
|
2381 |
* Closes this formatter. If the destination implements the {@link |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
2382 |
* java.io.Closeable} interface, its {@code close} method will be invoked. |
2 | 2383 |
* |
2384 |
* <p> Closing a formatter allows it to release resources it may be holding |
|
2385 |
* (such as open files). If the formatter is already closed, then invoking |
|
2386 |
* this method has no effect. |
|
2387 |
* |
|
2388 |
* <p> Attempting to invoke any methods except {@link #ioException()} in |
|
2389 |
* this formatter after it has been closed will result in a {@link |
|
2390 |
* FormatterClosedException}. |
|
2391 |
*/ |
|
2392 |
public void close() { |
|
2393 |
if (a == null) |
|
2394 |
return; |
|
2395 |
try { |
|
2396 |
if (a instanceof Closeable) |
|
2397 |
((Closeable)a).close(); |
|
2398 |
} catch (IOException ioe) { |
|
2399 |
lastException = ioe; |
|
2400 |
} finally { |
|
2401 |
a = null; |
|
2402 |
} |
|
2403 |
} |
|
2404 |
||
2405 |
private void ensureOpen() { |
|
2406 |
if (a == null) |
|
2407 |
throw new FormatterClosedException(); |
|
2408 |
} |
|
2409 |
||
2410 |
/** |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
2411 |
* Returns the {@code IOException} last thrown by this formatter's {@link |
2 | 2412 |
* Appendable}. |
2413 |
* |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
2414 |
* <p> If the destination's {@code append()} method never throws |
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
2415 |
* {@code IOException}, then this method will always return {@code null}. |
2 | 2416 |
* |
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
2417 |
* @return The last exception thrown by the Appendable or {@code null} if |
2 | 2418 |
* no such exception exists. |
2419 |
*/ |
|
2420 |
public IOException ioException() { |
|
2421 |
return lastException; |
|
2422 |
} |
|
2423 |
||
2424 |
/** |
|
2425 |
* Writes a formatted string to this object's destination using the |
|
2426 |
* specified format string and arguments. The locale used is the one |
|
2427 |
* defined during the construction of this formatter. |
|
2428 |
* |
|
2429 |
* @param format |
|
2430 |
* A format string as described in <a href="#syntax">Format string |
|
2431 |
* syntax</a>. |
|
2432 |
* |
|
2433 |
* @param args |
|
2434 |
* Arguments referenced by the format specifiers in the format |
|
2435 |
* string. If there are more arguments than format specifiers, the |
|
2436 |
* extra arguments are ignored. The maximum number of arguments is |
|
2437 |
* limited by the maximum dimension of a Java array as defined by |
|
9266
121fb370f179
7032960: API files in java.awt need to be updated for references to JVM Spec with editions/hyperlinks
jjh
parents:
8799
diff
changeset
|
2438 |
* <cite>The Java™ Virtual Machine Specification</cite>. |
2 | 2439 |
* |
2440 |
* @throws IllegalFormatException |
|
2441 |
* If a format string contains an illegal syntax, a format |
|
2442 |
* specifier that is incompatible with the given arguments, |
|
2443 |
* insufficient arguments given the format string, or other |
|
2444 |
* illegal conditions. For specification of all possible |
|
2445 |
* formatting errors, see the <a href="#detail">Details</a> |
|
2446 |
* section of the formatter class specification. |
|
2447 |
* |
|
2448 |
* @throws FormatterClosedException |
|
2449 |
* If this formatter has been closed by invoking its {@link |
|
2450 |
* #close()} method |
|
2451 |
* |
|
2452 |
* @return This formatter |
|
2453 |
*/ |
|
2454 |
public Formatter format(String format, Object ... args) { |
|
2455 |
return format(l, format, args); |
|
2456 |
} |
|
2457 |
||
2458 |
/** |
|
2459 |
* Writes a formatted string to this object's destination using the |
|
2460 |
* specified locale, format string, and arguments. |
|
2461 |
* |
|
2462 |
* @param l |
|
2463 |
* The {@linkplain java.util.Locale locale} to apply during |
|
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
2464 |
* formatting. If {@code l} is {@code null} then no localization |
2 | 2465 |
* is applied. This does not change this object's locale that was |
2466 |
* set during construction. |
|
2467 |
* |
|
2468 |
* @param format |
|
2469 |
* A format string as described in <a href="#syntax">Format string |
|
2470 |
* syntax</a> |
|
2471 |
* |
|
2472 |
* @param args |
|
2473 |
* Arguments referenced by the format specifiers in the format |
|
2474 |
* string. If there are more arguments than format specifiers, the |
|
2475 |
* extra arguments are ignored. The maximum number of arguments is |
|
2476 |
* limited by the maximum dimension of a Java array as defined by |
|
9266
121fb370f179
7032960: API files in java.awt need to be updated for references to JVM Spec with editions/hyperlinks
jjh
parents:
8799
diff
changeset
|
2477 |
* <cite>The Java™ Virtual Machine Specification</cite>. |
2 | 2478 |
* |
2479 |
* @throws IllegalFormatException |
|
2480 |
* If a format string contains an illegal syntax, a format |
|
2481 |
* specifier that is incompatible with the given arguments, |
|
2482 |
* insufficient arguments given the format string, or other |
|
2483 |
* illegal conditions. For specification of all possible |
|
2484 |
* formatting errors, see the <a href="#detail">Details</a> |
|
2485 |
* section of the formatter class specification. |
|
2486 |
* |
|
2487 |
* @throws FormatterClosedException |
|
2488 |
* If this formatter has been closed by invoking its {@link |
|
2489 |
* #close()} method |
|
2490 |
* |
|
2491 |
* @return This formatter |
|
2492 |
*/ |
|
2493 |
public Formatter format(Locale l, String format, Object ... args) { |
|
2494 |
ensureOpen(); |
|
2495 |
||
2496 |
// index of last argument referenced |
|
2497 |
int last = -1; |
|
2498 |
// last ordinary index |
|
2499 |
int lasto = -1; |
|
2500 |
||
26733 | 2501 |
List<FormatString> fsa = parse(format); |
22078
bdec5d53e98c
8030851: Update code in java.util to use newer language features
psandoz
parents:
21368
diff
changeset
|
2502 |
for (FormatString fs : fsa) { |
2 | 2503 |
int index = fs.index(); |
2504 |
try { |
|
2505 |
switch (index) { |
|
2506 |
case -2: // fixed string, "%n", or "%%" |
|
2507 |
fs.print(null, l); |
|
2508 |
break; |
|
2509 |
case -1: // relative index |
|
2510 |
if (last < 0 || (args != null && last > args.length - 1)) |
|
2511 |
throw new MissingFormatArgumentException(fs.toString()); |
|
2512 |
fs.print((args == null ? null : args[last]), l); |
|
2513 |
break; |
|
2514 |
case 0: // ordinary index |
|
2515 |
lasto++; |
|
2516 |
last = lasto; |
|
2517 |
if (args != null && lasto > args.length - 1) |
|
2518 |
throw new MissingFormatArgumentException(fs.toString()); |
|
2519 |
fs.print((args == null ? null : args[lasto]), l); |
|
2520 |
break; |
|
2521 |
default: // explicit index |
|
2522 |
last = index - 1; |
|
2523 |
if (args != null && last > args.length - 1) |
|
2524 |
throw new MissingFormatArgumentException(fs.toString()); |
|
2525 |
fs.print((args == null ? null : args[last]), l); |
|
2526 |
break; |
|
2527 |
} |
|
2528 |
} catch (IOException x) { |
|
2529 |
lastException = x; |
|
2530 |
} |
|
2531 |
} |
|
2532 |
return this; |
|
2533 |
} |
|
2534 |
||
2535 |
// %[argument_index$][flags][width][.precision][t]conversion |
|
2536 |
private static final String formatSpecifier |
|
2537 |
= "%(\\d+\\$)?([-#+ 0,(\\<]*)?(\\d+)?(\\.\\d+)?([tT])?([a-zA-Z%])"; |
|
2538 |
||
2539 |
private static Pattern fsPattern = Pattern.compile(formatSpecifier); |
|
2540 |
||
4185
8d87b7274c30
6898220: Optimize Formatter.parse (including String.printf)
martin
parents:
3416
diff
changeset
|
2541 |
/** |
8d87b7274c30
6898220: Optimize Formatter.parse (including String.printf)
martin
parents:
3416
diff
changeset
|
2542 |
* Finds format specifiers in the format string. |
8d87b7274c30
6898220: Optimize Formatter.parse (including String.printf)
martin
parents:
3416
diff
changeset
|
2543 |
*/ |
26733 | 2544 |
private List<FormatString> parse(String s) { |
7803
56bc97d69d93
6880112: Project Coin: Port JDK core library code to use diamond operator
smarks
parents:
7273
diff
changeset
|
2545 |
ArrayList<FormatString> al = new ArrayList<>(); |
2 | 2546 |
Matcher m = fsPattern.matcher(s); |
4185
8d87b7274c30
6898220: Optimize Formatter.parse (including String.printf)
martin
parents:
3416
diff
changeset
|
2547 |
for (int i = 0, len = s.length(); i < len; ) { |
2 | 2548 |
if (m.find(i)) { |
2549 |
// Anything between the start of the string and the beginning |
|
2550 |
// of the format specifier is either fixed text or contains |
|
2551 |
// an invalid format string. |
|
2552 |
if (m.start() != i) { |
|
2553 |
// Make sure we didn't miss any invalid format specifiers |
|
4185
8d87b7274c30
6898220: Optimize Formatter.parse (including String.printf)
martin
parents:
3416
diff
changeset
|
2554 |
checkText(s, i, m.start()); |
2 | 2555 |
// Assume previous characters were fixed text |
26733 | 2556 |
al.add(new FixedString(s, i, m.start())); |
2 | 2557 |
} |
2558 |
||
26733 | 2559 |
al.add(new FormatSpecifier(s, m)); |
2 | 2560 |
i = m.end(); |
2561 |
} else { |
|
2562 |
// No more valid format specifiers. Check for possible invalid |
|
2563 |
// format specifiers. |
|
4185
8d87b7274c30
6898220: Optimize Formatter.parse (including String.printf)
martin
parents:
3416
diff
changeset
|
2564 |
checkText(s, i, len); |
2 | 2565 |
// The rest of the string is fixed text |
26733 | 2566 |
al.add(new FixedString(s, i, s.length())); |
2 | 2567 |
break; |
2568 |
} |
|
2569 |
} |
|
26733 | 2570 |
return al; |
2 | 2571 |
} |
2572 |
||
4185
8d87b7274c30
6898220: Optimize Formatter.parse (including String.printf)
martin
parents:
3416
diff
changeset
|
2573 |
private static void checkText(String s, int start, int end) { |
8d87b7274c30
6898220: Optimize Formatter.parse (including String.printf)
martin
parents:
3416
diff
changeset
|
2574 |
for (int i = start; i < end; i++) { |
8d87b7274c30
6898220: Optimize Formatter.parse (including String.printf)
martin
parents:
3416
diff
changeset
|
2575 |
// Any '%' found in the region starts an invalid format specifier. |
8d87b7274c30
6898220: Optimize Formatter.parse (including String.printf)
martin
parents:
3416
diff
changeset
|
2576 |
if (s.charAt(i) == '%') { |
8d87b7274c30
6898220: Optimize Formatter.parse (including String.printf)
martin
parents:
3416
diff
changeset
|
2577 |
char c = (i == end - 1) ? '%' : s.charAt(i + 1); |
8d87b7274c30
6898220: Optimize Formatter.parse (including String.printf)
martin
parents:
3416
diff
changeset
|
2578 |
throw new UnknownFormatConversionException(String.valueOf(c)); |
8d87b7274c30
6898220: Optimize Formatter.parse (including String.printf)
martin
parents:
3416
diff
changeset
|
2579 |
} |
2 | 2580 |
} |
2581 |
} |
|
2582 |
||
2583 |
private interface FormatString { |
|
2584 |
int index(); |
|
2585 |
void print(Object arg, Locale l) throws IOException; |
|
2586 |
String toString(); |
|
2587 |
} |
|
2588 |
||
2589 |
private class FixedString implements FormatString { |
|
2590 |
private String s; |
|
26733 | 2591 |
private int start; |
2592 |
private int end; |
|
2593 |
FixedString(String s, int start, int end) { |
|
2594 |
this.s = s; |
|
2595 |
this.start = start; |
|
2596 |
this.end = end; |
|
2597 |
} |
|
2 | 2598 |
public int index() { return -2; } |
2599 |
public void print(Object arg, Locale l) |
|
26733 | 2600 |
throws IOException { a.append(s, start, end); } |
2601 |
public String toString() { return s.substring(start, end); } |
|
2 | 2602 |
} |
2603 |
||
18774 | 2604 |
/** |
2605 |
* Enum for {@code BigDecimal} formatting. |
|
2606 |
*/ |
|
2607 |
public enum BigDecimalLayoutForm { |
|
2608 |
/** |
|
2609 |
* Format the {@code BigDecimal} in computerized scientific notation. |
|
2610 |
*/ |
|
2611 |
SCIENTIFIC, |
|
2612 |
||
2613 |
/** |
|
2614 |
* Format the {@code BigDecimal} as a decimal number. |
|
2615 |
*/ |
|
2616 |
DECIMAL_FLOAT |
|
2617 |
}; |
|
2 | 2618 |
|
2619 |
private class FormatSpecifier implements FormatString { |
|
2620 |
private int index = -1; |
|
2621 |
private Flags f = Flags.NONE; |
|
2622 |
private int width; |
|
2623 |
private int precision; |
|
2624 |
private boolean dt = false; |
|
2625 |
private char c; |
|
2626 |
||
27731
3cba975130c0
8065070: (fmt) Avoid creating substrings when building FormatSpecifier
redestad
parents:
26733
diff
changeset
|
2627 |
private int index(String s, int start, int end) { |
3cba975130c0
8065070: (fmt) Avoid creating substrings when building FormatSpecifier
redestad
parents:
26733
diff
changeset
|
2628 |
if (start >= 0) { |
2 | 2629 |
try { |
27731
3cba975130c0
8065070: (fmt) Avoid creating substrings when building FormatSpecifier
redestad
parents:
26733
diff
changeset
|
2630 |
// skip the trailing '$' |
3cba975130c0
8065070: (fmt) Avoid creating substrings when building FormatSpecifier
redestad
parents:
26733
diff
changeset
|
2631 |
index = Integer.parseInt(s, start, end - 1, 10); |
2 | 2632 |
} catch (NumberFormatException x) { |
2633 |
assert(false); |
|
2634 |
} |
|
2635 |
} else { |
|
2636 |
index = 0; |
|
2637 |
} |
|
2638 |
return index; |
|
2639 |
} |
|
2640 |
||
2641 |
public int index() { |
|
2642 |
return index; |
|
2643 |
} |
|
2644 |
||
26733 | 2645 |
private Flags flags(String s, int start, int end) { |
2646 |
f = Flags.parse(s, start, end); |
|
2 | 2647 |
if (f.contains(Flags.PREVIOUS)) |
2648 |
index = -1; |
|
2649 |
return f; |
|
2650 |
} |
|
2651 |
||
27731
3cba975130c0
8065070: (fmt) Avoid creating substrings when building FormatSpecifier
redestad
parents:
26733
diff
changeset
|
2652 |
private int width(String s, int start, int end) { |
2 | 2653 |
width = -1; |
27731
3cba975130c0
8065070: (fmt) Avoid creating substrings when building FormatSpecifier
redestad
parents:
26733
diff
changeset
|
2654 |
if (start >= 0) { |
2 | 2655 |
try { |
27731
3cba975130c0
8065070: (fmt) Avoid creating substrings when building FormatSpecifier
redestad
parents:
26733
diff
changeset
|
2656 |
width = Integer.parseInt(s, start, end, 10); |
2 | 2657 |
if (width < 0) |
2658 |
throw new IllegalFormatWidthException(width); |
|
2659 |
} catch (NumberFormatException x) { |
|
2660 |
assert(false); |
|
2661 |
} |
|
2662 |
} |
|
2663 |
return width; |
|
2664 |
} |
|
2665 |
||
27731
3cba975130c0
8065070: (fmt) Avoid creating substrings when building FormatSpecifier
redestad
parents:
26733
diff
changeset
|
2666 |
private int precision(String s, int start, int end) { |
2 | 2667 |
precision = -1; |
27731
3cba975130c0
8065070: (fmt) Avoid creating substrings when building FormatSpecifier
redestad
parents:
26733
diff
changeset
|
2668 |
if (start >= 0) { |
2 | 2669 |
try { |
27731
3cba975130c0
8065070: (fmt) Avoid creating substrings when building FormatSpecifier
redestad
parents:
26733
diff
changeset
|
2670 |
// skip the leading '.' |
3cba975130c0
8065070: (fmt) Avoid creating substrings when building FormatSpecifier
redestad
parents:
26733
diff
changeset
|
2671 |
precision = Integer.parseInt(s, start + 1, end, 10); |
2 | 2672 |
if (precision < 0) |
2673 |
throw new IllegalFormatPrecisionException(precision); |
|
2674 |
} catch (NumberFormatException x) { |
|
2675 |
assert(false); |
|
2676 |
} |
|
2677 |
} |
|
2678 |
return precision; |
|
2679 |
} |
|
2680 |
||
26733 | 2681 |
private char conversion(char conv) { |
2682 |
c = conv; |
|
2 | 2683 |
if (!dt) { |
26733 | 2684 |
if (!Conversion.isValid(c)) { |
2 | 2685 |
throw new UnknownFormatConversionException(String.valueOf(c)); |
26733 | 2686 |
} |
2687 |
if (Character.isUpperCase(c)) { |
|
2 | 2688 |
f.add(Flags.UPPERCASE); |
26733 | 2689 |
c = Character.toLowerCase(c); |
2690 |
} |
|
2691 |
if (Conversion.isText(c)) { |
|
2 | 2692 |
index = -2; |
26733 | 2693 |
} |
2 | 2694 |
} |
2695 |
return c; |
|
2696 |
} |
|
2697 |
||
26733 | 2698 |
FormatSpecifier(String s, Matcher m) { |
27731
3cba975130c0
8065070: (fmt) Avoid creating substrings when building FormatSpecifier
redestad
parents:
26733
diff
changeset
|
2699 |
index(s, m.start(1), m.end(1)); |
3cba975130c0
8065070: (fmt) Avoid creating substrings when building FormatSpecifier
redestad
parents:
26733
diff
changeset
|
2700 |
flags(s, m.start(2), m.end(2)); |
3cba975130c0
8065070: (fmt) Avoid creating substrings when building FormatSpecifier
redestad
parents:
26733
diff
changeset
|
2701 |
width(s, m.start(3), m.end(3)); |
3cba975130c0
8065070: (fmt) Avoid creating substrings when building FormatSpecifier
redestad
parents:
26733
diff
changeset
|
2702 |
precision(s, m.start(4), m.end(4)); |
3cba975130c0
8065070: (fmt) Avoid creating substrings when building FormatSpecifier
redestad
parents:
26733
diff
changeset
|
2703 |
|
3cba975130c0
8065070: (fmt) Avoid creating substrings when building FormatSpecifier
redestad
parents:
26733
diff
changeset
|
2704 |
int tTStart = m.start(5); |
3cba975130c0
8065070: (fmt) Avoid creating substrings when building FormatSpecifier
redestad
parents:
26733
diff
changeset
|
2705 |
if (tTStart >= 0) { |
2 | 2706 |
dt = true; |
27731
3cba975130c0
8065070: (fmt) Avoid creating substrings when building FormatSpecifier
redestad
parents:
26733
diff
changeset
|
2707 |
if (s.charAt(tTStart) == 'T') { |
2 | 2708 |
f.add(Flags.UPPERCASE); |
26733 | 2709 |
} |
2 | 2710 |
} |
27731
3cba975130c0
8065070: (fmt) Avoid creating substrings when building FormatSpecifier
redestad
parents:
26733
diff
changeset
|
2711 |
conversion(s.charAt(m.start(6))); |
2 | 2712 |
|
2713 |
if (dt) |
|
2714 |
checkDateTime(); |
|
2715 |
else if (Conversion.isGeneral(c)) |
|
2716 |
checkGeneral(); |
|
2717 |
else if (Conversion.isCharacter(c)) |
|
2718 |
checkCharacter(); |
|
2719 |
else if (Conversion.isInteger(c)) |
|
2720 |
checkInteger(); |
|
2721 |
else if (Conversion.isFloat(c)) |
|
2722 |
checkFloat(); |
|
2723 |
else if (Conversion.isText(c)) |
|
2724 |
checkText(); |
|
2725 |
else |
|
2726 |
throw new UnknownFormatConversionException(String.valueOf(c)); |
|
2727 |
} |
|
2728 |
||
2729 |
public void print(Object arg, Locale l) throws IOException { |
|
2730 |
if (dt) { |
|
2731 |
printDateTime(arg, l); |
|
2732 |
return; |
|
2733 |
} |
|
2734 |
switch(c) { |
|
2735 |
case Conversion.DECIMAL_INTEGER: |
|
2736 |
case Conversion.OCTAL_INTEGER: |
|
2737 |
case Conversion.HEXADECIMAL_INTEGER: |
|
2738 |
printInteger(arg, l); |
|
2739 |
break; |
|
2740 |
case Conversion.SCIENTIFIC: |
|
2741 |
case Conversion.GENERAL: |
|
2742 |
case Conversion.DECIMAL_FLOAT: |
|
2743 |
case Conversion.HEXADECIMAL_FLOAT: |
|
2744 |
printFloat(arg, l); |
|
2745 |
break; |
|
2746 |
case Conversion.CHARACTER: |
|
2747 |
case Conversion.CHARACTER_UPPER: |
|
2748 |
printCharacter(arg); |
|
2749 |
break; |
|
2750 |
case Conversion.BOOLEAN: |
|
2751 |
printBoolean(arg); |
|
2752 |
break; |
|
2753 |
case Conversion.STRING: |
|
2754 |
printString(arg, l); |
|
2755 |
break; |
|
2756 |
case Conversion.HASHCODE: |
|
2757 |
printHashCode(arg); |
|
2758 |
break; |
|
2759 |
case Conversion.LINE_SEPARATOR: |
|
4355
12d58d6de82f
6900043: Add method to return line.separator property
martin
parents:
4185
diff
changeset
|
2760 |
a.append(System.lineSeparator()); |
2 | 2761 |
break; |
2762 |
case Conversion.PERCENT_SIGN: |
|
2763 |
a.append('%'); |
|
2764 |
break; |
|
2765 |
default: |
|
2766 |
assert false; |
|
2767 |
} |
|
2768 |
} |
|
2769 |
||
2770 |
private void printInteger(Object arg, Locale l) throws IOException { |
|
2771 |
if (arg == null) |
|
2772 |
print("null"); |
|
2773 |
else if (arg instanceof Byte) |
|
2774 |
print(((Byte)arg).byteValue(), l); |
|
2775 |
else if (arg instanceof Short) |
|
2776 |
print(((Short)arg).shortValue(), l); |
|
2777 |
else if (arg instanceof Integer) |
|
2778 |
print(((Integer)arg).intValue(), l); |
|
2779 |
else if (arg instanceof Long) |
|
2780 |
print(((Long)arg).longValue(), l); |
|
2781 |
else if (arg instanceof BigInteger) |
|
2782 |
print(((BigInteger)arg), l); |
|
2783 |
else |
|
2784 |
failConversion(c, arg); |
|
2785 |
} |
|
2786 |
||
2787 |
private void printFloat(Object arg, Locale l) throws IOException { |
|
2788 |
if (arg == null) |
|
2789 |
print("null"); |
|
2790 |
else if (arg instanceof Float) |
|
2791 |
print(((Float)arg).floatValue(), l); |
|
2792 |
else if (arg instanceof Double) |
|
2793 |
print(((Double)arg).doubleValue(), l); |
|
2794 |
else if (arg instanceof BigDecimal) |
|
2795 |
print(((BigDecimal)arg), l); |
|
2796 |
else |
|
2797 |
failConversion(c, arg); |
|
2798 |
} |
|
2799 |
||
2800 |
private void printDateTime(Object arg, Locale l) throws IOException { |
|
2801 |
if (arg == null) { |
|
2802 |
print("null"); |
|
2803 |
return; |
|
2804 |
} |
|
2805 |
Calendar cal = null; |
|
2806 |
||
2807 |
// Instead of Calendar.setLenient(true), perhaps we should |
|
2808 |
// wrap the IllegalArgumentException that might be thrown? |
|
2809 |
if (arg instanceof Long) { |
|
2810 |
// Note that the following method uses an instance of the |
|
2811 |
// default time zone (TimeZone.getDefaultRef(). |
|
2812 |
cal = Calendar.getInstance(l == null ? Locale.US : l); |
|
2813 |
cal.setTimeInMillis((Long)arg); |
|
2814 |
} else if (arg instanceof Date) { |
|
2815 |
// Note that the following method uses an instance of the |
|
2816 |
// default time zone (TimeZone.getDefaultRef(). |
|
2817 |
cal = Calendar.getInstance(l == null ? Locale.US : l); |
|
2818 |
cal.setTime((Date)arg); |
|
2819 |
} else if (arg instanceof Calendar) { |
|
18143
b6ef7bd945ce
7032154: Performance tuning of sun.misc.FloatingDecimal/FormattedFloatingDecimal
bpb
parents:
16852
diff
changeset
|
2820 |
cal = (Calendar) ((Calendar) arg).clone(); |
2 | 2821 |
cal.setLenient(true); |
15289 | 2822 |
} else if (arg instanceof TemporalAccessor) { |
18143
b6ef7bd945ce
7032154: Performance tuning of sun.misc.FloatingDecimal/FormattedFloatingDecimal
bpb
parents:
16852
diff
changeset
|
2823 |
print((TemporalAccessor) arg, c, l); |
15289 | 2824 |
return; |
2 | 2825 |
} else { |
2826 |
failConversion(c, arg); |
|
2827 |
} |
|
2828 |
// Use the provided locale so that invocations of |
|
2829 |
// localizedMagnitude() use optimizations for null. |
|
2830 |
print(cal, c, l); |
|
2831 |
} |
|
2832 |
||
2833 |
private void printCharacter(Object arg) throws IOException { |
|
2834 |
if (arg == null) { |
|
2835 |
print("null"); |
|
2836 |
return; |
|
2837 |
} |
|
2838 |
String s = null; |
|
2839 |
if (arg instanceof Character) { |
|
2840 |
s = ((Character)arg).toString(); |
|
2841 |
} else if (arg instanceof Byte) { |
|
2842 |
byte i = ((Byte)arg).byteValue(); |
|
2843 |
if (Character.isValidCodePoint(i)) |
|
2844 |
s = new String(Character.toChars(i)); |
|
2845 |
else |
|
2846 |
throw new IllegalFormatCodePointException(i); |
|
2847 |
} else if (arg instanceof Short) { |
|
2848 |
short i = ((Short)arg).shortValue(); |
|
2849 |
if (Character.isValidCodePoint(i)) |
|
2850 |
s = new String(Character.toChars(i)); |
|
2851 |
else |
|
2852 |
throw new IllegalFormatCodePointException(i); |
|
2853 |
} else if (arg instanceof Integer) { |
|
2854 |
int i = ((Integer)arg).intValue(); |
|
2855 |
if (Character.isValidCodePoint(i)) |
|
2856 |
s = new String(Character.toChars(i)); |
|
2857 |
else |
|
2858 |
throw new IllegalFormatCodePointException(i); |
|
2859 |
} else { |
|
2860 |
failConversion(c, arg); |
|
2861 |
} |
|
2862 |
print(s); |
|
2863 |
} |
|
2864 |
||
2865 |
private void printString(Object arg, Locale l) throws IOException { |
|
3416
0dd4f82becda
5063507: (fmt) missing exception for "%#s" format specifier
sherman
parents:
1939
diff
changeset
|
2866 |
if (arg instanceof Formattable) { |
4185
8d87b7274c30
6898220: Optimize Formatter.parse (including String.printf)
martin
parents:
3416
diff
changeset
|
2867 |
Formatter fmt = Formatter.this; |
8d87b7274c30
6898220: Optimize Formatter.parse (including String.printf)
martin
parents:
3416
diff
changeset
|
2868 |
if (fmt.locale() != l) |
8d87b7274c30
6898220: Optimize Formatter.parse (including String.printf)
martin
parents:
3416
diff
changeset
|
2869 |
fmt = new Formatter(fmt.out(), l); |
2 | 2870 |
((Formattable)arg).formatTo(fmt, f.valueOf(), width, precision); |
2871 |
} else { |
|
3416
0dd4f82becda
5063507: (fmt) missing exception for "%#s" format specifier
sherman
parents:
1939
diff
changeset
|
2872 |
if (f.contains(Flags.ALTERNATE)) |
0dd4f82becda
5063507: (fmt) missing exception for "%#s" format specifier
sherman
parents:
1939
diff
changeset
|
2873 |
failMismatch(Flags.ALTERNATE, 's'); |
0dd4f82becda
5063507: (fmt) missing exception for "%#s" format specifier
sherman
parents:
1939
diff
changeset
|
2874 |
if (arg == null) |
0dd4f82becda
5063507: (fmt) missing exception for "%#s" format specifier
sherman
parents:
1939
diff
changeset
|
2875 |
print("null"); |
0dd4f82becda
5063507: (fmt) missing exception for "%#s" format specifier
sherman
parents:
1939
diff
changeset
|
2876 |
else |
0dd4f82becda
5063507: (fmt) missing exception for "%#s" format specifier
sherman
parents:
1939
diff
changeset
|
2877 |
print(arg.toString()); |
2 | 2878 |
} |
2879 |
} |
|
2880 |
||
2881 |
private void printBoolean(Object arg) throws IOException { |
|
2882 |
String s; |
|
2883 |
if (arg != null) |
|
2884 |
s = ((arg instanceof Boolean) |
|
2885 |
? ((Boolean)arg).toString() |
|
2886 |
: Boolean.toString(true)); |
|
2887 |
else |
|
2888 |
s = Boolean.toString(false); |
|
2889 |
print(s); |
|
2890 |
} |
|
2891 |
||
2892 |
private void printHashCode(Object arg) throws IOException { |
|
2893 |
String s = (arg == null |
|
2894 |
? "null" |
|
2895 |
: Integer.toHexString(arg.hashCode())); |
|
2896 |
print(s); |
|
2897 |
} |
|
2898 |
||
2899 |
private void print(String s) throws IOException { |
|
2900 |
if (precision != -1 && precision < s.length()) |
|
2901 |
s = s.substring(0, precision); |
|
2902 |
if (f.contains(Flags.UPPERCASE)) |
|
2903 |
s = s.toUpperCase(); |
|
26733 | 2904 |
appendJustified(a, s); |
2 | 2905 |
} |
2906 |
||
26733 | 2907 |
private Appendable appendJustified(Appendable a, CharSequence cs) throws IOException { |
2908 |
if (width == -1) { |
|
2909 |
return a.append(cs); |
|
2910 |
} |
|
2911 |
boolean padRight = f.contains(Flags.LEFT_JUSTIFY); |
|
2912 |
int sp = width - cs.length(); |
|
2913 |
if (padRight) { |
|
2914 |
a.append(cs); |
|
2915 |
} |
|
2916 |
for (int i = 0; i < sp; i++) { |
|
2917 |
a.append(' '); |
|
2918 |
} |
|
2919 |
if (!padRight) { |
|
2920 |
a.append(cs); |
|
2921 |
} |
|
2922 |
return a; |
|
2 | 2923 |
} |
2924 |
||
2925 |
public String toString() { |
|
11135
fb2447d0a09c
5063455: (fmt) MissingFormatArgumentException.getFormatSpecifier() incorrect return value
sherman
parents:
10608
diff
changeset
|
2926 |
StringBuilder sb = new StringBuilder("%"); |
2 | 2927 |
// Flags.UPPERCASE is set internally for legal conversions. |
2928 |
Flags dupf = f.dup().remove(Flags.UPPERCASE); |
|
2929 |
sb.append(dupf.toString()); |
|
2930 |
if (index > 0) |
|
2931 |
sb.append(index).append('$'); |
|
2932 |
if (width != -1) |
|
2933 |
sb.append(width); |
|
2934 |
if (precision != -1) |
|
2935 |
sb.append('.').append(precision); |
|
2936 |
if (dt) |
|
2937 |
sb.append(f.contains(Flags.UPPERCASE) ? 'T' : 't'); |
|
2938 |
sb.append(f.contains(Flags.UPPERCASE) |
|
2939 |
? Character.toUpperCase(c) : c); |
|
2940 |
return sb.toString(); |
|
2941 |
} |
|
2942 |
||
2943 |
private void checkGeneral() { |
|
2944 |
if ((c == Conversion.BOOLEAN || c == Conversion.HASHCODE) |
|
2945 |
&& f.contains(Flags.ALTERNATE)) |
|
2946 |
failMismatch(Flags.ALTERNATE, c); |
|
2947 |
// '-' requires a width |
|
2948 |
if (width == -1 && f.contains(Flags.LEFT_JUSTIFY)) |
|
2949 |
throw new MissingFormatWidthException(toString()); |
|
2950 |
checkBadFlags(Flags.PLUS, Flags.LEADING_SPACE, Flags.ZERO_PAD, |
|
2951 |
Flags.GROUP, Flags.PARENTHESES); |
|
2952 |
} |
|
2953 |
||
2954 |
private void checkDateTime() { |
|
2955 |
if (precision != -1) |
|
2956 |
throw new IllegalFormatPrecisionException(precision); |
|
2957 |
if (!DateTime.isValid(c)) |
|
2958 |
throw new UnknownFormatConversionException("t" + c); |
|
2959 |
checkBadFlags(Flags.ALTERNATE, Flags.PLUS, Flags.LEADING_SPACE, |
|
2960 |
Flags.ZERO_PAD, Flags.GROUP, Flags.PARENTHESES); |
|
2961 |
// '-' requires a width |
|
2962 |
if (width == -1 && f.contains(Flags.LEFT_JUSTIFY)) |
|
2963 |
throw new MissingFormatWidthException(toString()); |
|
2964 |
} |
|
2965 |
||
2966 |
private void checkCharacter() { |
|
2967 |
if (precision != -1) |
|
2968 |
throw new IllegalFormatPrecisionException(precision); |
|
2969 |
checkBadFlags(Flags.ALTERNATE, Flags.PLUS, Flags.LEADING_SPACE, |
|
2970 |
Flags.ZERO_PAD, Flags.GROUP, Flags.PARENTHESES); |
|
2971 |
// '-' requires a width |
|
2972 |
if (width == -1 && f.contains(Flags.LEFT_JUSTIFY)) |
|
2973 |
throw new MissingFormatWidthException(toString()); |
|
2974 |
} |
|
2975 |
||
2976 |
private void checkInteger() { |
|
2977 |
checkNumeric(); |
|
2978 |
if (precision != -1) |
|
2979 |
throw new IllegalFormatPrecisionException(precision); |
|
2980 |
||
2981 |
if (c == Conversion.DECIMAL_INTEGER) |
|
2982 |
checkBadFlags(Flags.ALTERNATE); |
|
2983 |
else if (c == Conversion.OCTAL_INTEGER) |
|
2984 |
checkBadFlags(Flags.GROUP); |
|
2985 |
else |
|
2986 |
checkBadFlags(Flags.GROUP); |
|
2987 |
} |
|
2988 |
||
2989 |
private void checkBadFlags(Flags ... badFlags) { |
|
22078
bdec5d53e98c
8030851: Update code in java.util to use newer language features
psandoz
parents:
21368
diff
changeset
|
2990 |
for (Flags badFlag : badFlags) |
bdec5d53e98c
8030851: Update code in java.util to use newer language features
psandoz
parents:
21368
diff
changeset
|
2991 |
if (f.contains(badFlag)) |
bdec5d53e98c
8030851: Update code in java.util to use newer language features
psandoz
parents:
21368
diff
changeset
|
2992 |
failMismatch(badFlag, c); |
2 | 2993 |
} |
2994 |
||
2995 |
private void checkFloat() { |
|
2996 |
checkNumeric(); |
|
2997 |
if (c == Conversion.DECIMAL_FLOAT) { |
|
2998 |
} else if (c == Conversion.HEXADECIMAL_FLOAT) { |
|
2999 |
checkBadFlags(Flags.PARENTHESES, Flags.GROUP); |
|
3000 |
} else if (c == Conversion.SCIENTIFIC) { |
|
3001 |
checkBadFlags(Flags.GROUP); |
|
3002 |
} else if (c == Conversion.GENERAL) { |
|
3003 |
checkBadFlags(Flags.ALTERNATE); |
|
3004 |
} |
|
3005 |
} |
|
3006 |
||
3007 |
private void checkNumeric() { |
|
3008 |
if (width != -1 && width < 0) |
|
3009 |
throw new IllegalFormatWidthException(width); |
|
3010 |
||
3011 |
if (precision != -1 && precision < 0) |
|
3012 |
throw new IllegalFormatPrecisionException(precision); |
|
3013 |
||
3014 |
// '-' and '0' require a width |
|
3015 |
if (width == -1 |
|
3016 |
&& (f.contains(Flags.LEFT_JUSTIFY) || f.contains(Flags.ZERO_PAD))) |
|
3017 |
throw new MissingFormatWidthException(toString()); |
|
3018 |
||
3019 |
// bad combination |
|
3020 |
if ((f.contains(Flags.PLUS) && f.contains(Flags.LEADING_SPACE)) |
|
3021 |
|| (f.contains(Flags.LEFT_JUSTIFY) && f.contains(Flags.ZERO_PAD))) |
|
3022 |
throw new IllegalFormatFlagsException(f.toString()); |
|
3023 |
} |
|
3024 |
||
3025 |
private void checkText() { |
|
3026 |
if (precision != -1) |
|
3027 |
throw new IllegalFormatPrecisionException(precision); |
|
3028 |
switch (c) { |
|
3029 |
case Conversion.PERCENT_SIGN: |
|
3030 |
if (f.valueOf() != Flags.LEFT_JUSTIFY.valueOf() |
|
3031 |
&& f.valueOf() != Flags.NONE.valueOf()) |
|
3032 |
throw new IllegalFormatFlagsException(f.toString()); |
|
3033 |
// '-' requires a width |
|
3034 |
if (width == -1 && f.contains(Flags.LEFT_JUSTIFY)) |
|
3035 |
throw new MissingFormatWidthException(toString()); |
|
3036 |
break; |
|
3037 |
case Conversion.LINE_SEPARATOR: |
|
3038 |
if (width != -1) |
|
3039 |
throw new IllegalFormatWidthException(width); |
|
3040 |
if (f.valueOf() != Flags.NONE.valueOf()) |
|
3041 |
throw new IllegalFormatFlagsException(f.toString()); |
|
3042 |
break; |
|
3043 |
default: |
|
3044 |
assert false; |
|
3045 |
} |
|
3046 |
} |
|
3047 |
||
3048 |
private void print(byte value, Locale l) throws IOException { |
|
3049 |
long v = value; |
|
3050 |
if (value < 0 |
|
3051 |
&& (c == Conversion.OCTAL_INTEGER |
|
3052 |
|| c == Conversion.HEXADECIMAL_INTEGER)) { |
|
3053 |
v += (1L << 8); |
|
3054 |
assert v >= 0 : v; |
|
3055 |
} |
|
3056 |
print(v, l); |
|
3057 |
} |
|
3058 |
||
3059 |
private void print(short value, Locale l) throws IOException { |
|
3060 |
long v = value; |
|
3061 |
if (value < 0 |
|
3062 |
&& (c == Conversion.OCTAL_INTEGER |
|
3063 |
|| c == Conversion.HEXADECIMAL_INTEGER)) { |
|
3064 |
v += (1L << 16); |
|
3065 |
assert v >= 0 : v; |
|
3066 |
} |
|
3067 |
print(v, l); |
|
3068 |
} |
|
3069 |
||
3070 |
private void print(int value, Locale l) throws IOException { |
|
3071 |
long v = value; |
|
3072 |
if (value < 0 |
|
3073 |
&& (c == Conversion.OCTAL_INTEGER |
|
3074 |
|| c == Conversion.HEXADECIMAL_INTEGER)) { |
|
3075 |
v += (1L << 32); |
|
3076 |
assert v >= 0 : v; |
|
3077 |
} |
|
3078 |
print(v, l); |
|
3079 |
} |
|
3080 |
||
3081 |
private void print(long value, Locale l) throws IOException { |
|
3082 |
||
3083 |
StringBuilder sb = new StringBuilder(); |
|
3084 |
||
3085 |
if (c == Conversion.DECIMAL_INTEGER) { |
|
3086 |
boolean neg = value < 0; |
|
26733 | 3087 |
String valueStr = Long.toString(value, 10); |
2 | 3088 |
|
3089 |
// leading sign indicator |
|
3090 |
leadingSign(sb, neg); |
|
3091 |
||
3092 |
// the value |
|
26733 | 3093 |
localizedMagnitude(sb, valueStr, neg ? 1 : 0, f, adjustWidth(width, f, neg), l); |
2 | 3094 |
|
3095 |
// trailing sign indicator |
|
3096 |
trailingSign(sb, neg); |
|
3097 |
} else if (c == Conversion.OCTAL_INTEGER) { |
|
3098 |
checkBadFlags(Flags.PARENTHESES, Flags.LEADING_SPACE, |
|
3099 |
Flags.PLUS); |
|
3100 |
String s = Long.toOctalString(value); |
|
3101 |
int len = (f.contains(Flags.ALTERNATE) |
|
3102 |
? s.length() + 1 |
|
3103 |
: s.length()); |
|
3104 |
||
3105 |
// apply ALTERNATE (radix indicator for octal) before ZERO_PAD |
|
3106 |
if (f.contains(Flags.ALTERNATE)) |
|
3107 |
sb.append('0'); |
|
26733 | 3108 |
if (f.contains(Flags.ZERO_PAD)) { |
3109 |
trailingZeros(sb, width - len); |
|
3110 |
} |
|
2 | 3111 |
sb.append(s); |
3112 |
} else if (c == Conversion.HEXADECIMAL_INTEGER) { |
|
3113 |
checkBadFlags(Flags.PARENTHESES, Flags.LEADING_SPACE, |
|
3114 |
Flags.PLUS); |
|
3115 |
String s = Long.toHexString(value); |
|
3116 |
int len = (f.contains(Flags.ALTERNATE) |
|
3117 |
? s.length() + 2 |
|
3118 |
: s.length()); |
|
3119 |
||
3120 |
// apply ALTERNATE (radix indicator for hex) before ZERO_PAD |
|
3121 |
if (f.contains(Flags.ALTERNATE)) |
|
3122 |
sb.append(f.contains(Flags.UPPERCASE) ? "0X" : "0x"); |
|
26733 | 3123 |
if (f.contains(Flags.ZERO_PAD)) { |
3124 |
trailingZeros(sb, width - len); |
|
3125 |
} |
|
2 | 3126 |
if (f.contains(Flags.UPPERCASE)) |
3127 |
s = s.toUpperCase(); |
|
3128 |
sb.append(s); |
|
3129 |
} |
|
3130 |
||
3131 |
// justify based on width |
|
26733 | 3132 |
appendJustified(a, sb); |
2 | 3133 |
} |
3134 |
||
3135 |
// neg := val < 0 |
|
3136 |
private StringBuilder leadingSign(StringBuilder sb, boolean neg) { |
|
3137 |
if (!neg) { |
|
3138 |
if (f.contains(Flags.PLUS)) { |
|
3139 |
sb.append('+'); |
|
3140 |
} else if (f.contains(Flags.LEADING_SPACE)) { |
|
3141 |
sb.append(' '); |
|
3142 |
} |
|
3143 |
} else { |
|
3144 |
if (f.contains(Flags.PARENTHESES)) |
|
3145 |
sb.append('('); |
|
3146 |
else |
|
3147 |
sb.append('-'); |
|
3148 |
} |
|
3149 |
return sb; |
|
3150 |
} |
|
3151 |
||
3152 |
// neg := val < 0 |
|
3153 |
private StringBuilder trailingSign(StringBuilder sb, boolean neg) { |
|
3154 |
if (neg && f.contains(Flags.PARENTHESES)) |
|
3155 |
sb.append(')'); |
|
3156 |
return sb; |
|
3157 |
} |
|
3158 |
||
3159 |
private void print(BigInteger value, Locale l) throws IOException { |
|
3160 |
StringBuilder sb = new StringBuilder(); |
|
3161 |
boolean neg = value.signum() == -1; |
|
3162 |
BigInteger v = value.abs(); |
|
3163 |
||
3164 |
// leading sign indicator |
|
3165 |
leadingSign(sb, neg); |
|
3166 |
||
3167 |
// the value |
|
3168 |
if (c == Conversion.DECIMAL_INTEGER) { |
|
26733 | 3169 |
localizedMagnitude(sb, v.toString(), 0, f, adjustWidth(width, f, neg), l); |
2 | 3170 |
} else if (c == Conversion.OCTAL_INTEGER) { |
3171 |
String s = v.toString(8); |
|
3172 |
||
3173 |
int len = s.length() + sb.length(); |
|
3174 |
if (neg && f.contains(Flags.PARENTHESES)) |
|
3175 |
len++; |
|
3176 |
||
3177 |
// apply ALTERNATE (radix indicator for octal) before ZERO_PAD |
|
3178 |
if (f.contains(Flags.ALTERNATE)) { |
|
3179 |
len++; |
|
3180 |
sb.append('0'); |
|
3181 |
} |
|
3182 |
if (f.contains(Flags.ZERO_PAD)) { |
|
26733 | 3183 |
trailingZeros(sb, width - len); |
2 | 3184 |
} |
3185 |
sb.append(s); |
|
3186 |
} else if (c == Conversion.HEXADECIMAL_INTEGER) { |
|
3187 |
String s = v.toString(16); |
|
3188 |
||
3189 |
int len = s.length() + sb.length(); |
|
3190 |
if (neg && f.contains(Flags.PARENTHESES)) |
|
3191 |
len++; |
|
3192 |
||
3193 |
// apply ALTERNATE (radix indicator for hex) before ZERO_PAD |
|
3194 |
if (f.contains(Flags.ALTERNATE)) { |
|
3195 |
len += 2; |
|
3196 |
sb.append(f.contains(Flags.UPPERCASE) ? "0X" : "0x"); |
|
3197 |
} |
|
26733 | 3198 |
if (f.contains(Flags.ZERO_PAD)) { |
3199 |
trailingZeros(sb, width - len); |
|
3200 |
} |
|
2 | 3201 |
if (f.contains(Flags.UPPERCASE)) |
3202 |
s = s.toUpperCase(); |
|
3203 |
sb.append(s); |
|
3204 |
} |
|
3205 |
||
3206 |
// trailing sign indicator |
|
3207 |
trailingSign(sb, (value.signum() == -1)); |
|
3208 |
||
3209 |
// justify based on width |
|
26733 | 3210 |
appendJustified(a, sb); |
2 | 3211 |
} |
3212 |
||
3213 |
private void print(float value, Locale l) throws IOException { |
|
3214 |
print((double) value, l); |
|
3215 |
} |
|
3216 |
||
3217 |
private void print(double value, Locale l) throws IOException { |
|
3218 |
StringBuilder sb = new StringBuilder(); |
|
3219 |
boolean neg = Double.compare(value, 0.0) == -1; |
|
3220 |
||
3221 |
if (!Double.isNaN(value)) { |
|
3222 |
double v = Math.abs(value); |
|
3223 |
||
3224 |
// leading sign indicator |
|
3225 |
leadingSign(sb, neg); |
|
3226 |
||
3227 |
// the value |
|
3228 |
if (!Double.isInfinite(v)) |
|
3229 |
print(sb, v, l, f, c, precision, neg); |
|
3230 |
else |
|
3231 |
sb.append(f.contains(Flags.UPPERCASE) |
|
3232 |
? "INFINITY" : "Infinity"); |
|
3233 |
||
3234 |
// trailing sign indicator |
|
3235 |
trailingSign(sb, neg); |
|
3236 |
} else { |
|
3237 |
sb.append(f.contains(Flags.UPPERCASE) ? "NAN" : "NaN"); |
|
3238 |
} |
|
3239 |
||
3240 |
// justify based on width |
|
26733 | 3241 |
appendJustified(a, sb); |
2 | 3242 |
} |
3243 |
||
3244 |
// !Double.isInfinite(value) && !Double.isNaN(value) |
|
3245 |
private void print(StringBuilder sb, double value, Locale l, |
|
3246 |
Flags f, char c, int precision, boolean neg) |
|
3247 |
throws IOException |
|
3248 |
{ |
|
3249 |
if (c == Conversion.SCIENTIFIC) { |
|
3250 |
// Create a new FormattedFloatingDecimal with the desired |
|
3251 |
// precision. |
|
3252 |
int prec = (precision == -1 ? 6 : precision); |
|
3253 |
||
3254 |
FormattedFloatingDecimal fd |
|
18143
b6ef7bd945ce
7032154: Performance tuning of sun.misc.FloatingDecimal/FormattedFloatingDecimal
bpb
parents:
16852
diff
changeset
|
3255 |
= FormattedFloatingDecimal.valueOf(value, prec, |
b6ef7bd945ce
7032154: Performance tuning of sun.misc.FloatingDecimal/FormattedFloatingDecimal
bpb
parents:
16852
diff
changeset
|
3256 |
FormattedFloatingDecimal.Form.SCIENTIFIC); |
b6ef7bd945ce
7032154: Performance tuning of sun.misc.FloatingDecimal/FormattedFloatingDecimal
bpb
parents:
16852
diff
changeset
|
3257 |
|
26733 | 3258 |
StringBuilder mant = new StringBuilder().append(fd.getMantissa()); |
3259 |
addZeros(mant, prec); |
|
2 | 3260 |
|
3261 |
// If the precision is zero and the '#' flag is set, add the |
|
3262 |
// requested decimal point. |
|
26733 | 3263 |
if (f.contains(Flags.ALTERNATE) && (prec == 0)) { |
3264 |
mant.append('.'); |
|
3265 |
} |
|
2 | 3266 |
|
3267 |
char[] exp = (value == 0.0) |
|
18143
b6ef7bd945ce
7032154: Performance tuning of sun.misc.FloatingDecimal/FormattedFloatingDecimal
bpb
parents:
16852
diff
changeset
|
3268 |
? new char[] {'+','0','0'} : fd.getExponent(); |
2 | 3269 |
|
3270 |
int newW = width; |
|
26733 | 3271 |
if (width != -1) { |
2 | 3272 |
newW = adjustWidth(width - exp.length - 1, f, neg); |
26733 | 3273 |
} |
3274 |
localizedMagnitude(sb, mant, 0, f, newW, l); |
|
2 | 3275 |
|
3276 |
sb.append(f.contains(Flags.UPPERCASE) ? 'E' : 'e'); |
|
3277 |
||
3278 |
char sign = exp[0]; |
|
3279 |
assert(sign == '+' || sign == '-'); |
|
3280 |
sb.append(sign); |
|
3281 |
||
26733 | 3282 |
localizedMagnitudeExp(sb, exp, 1, l); |
2 | 3283 |
} else if (c == Conversion.DECIMAL_FLOAT) { |
3284 |
// Create a new FormattedFloatingDecimal with the desired |
|
3285 |
// precision. |
|
3286 |
int prec = (precision == -1 ? 6 : precision); |
|
3287 |
||
3288 |
FormattedFloatingDecimal fd |
|
18143
b6ef7bd945ce
7032154: Performance tuning of sun.misc.FloatingDecimal/FormattedFloatingDecimal
bpb
parents:
16852
diff
changeset
|
3289 |
= FormattedFloatingDecimal.valueOf(value, prec, |
b6ef7bd945ce
7032154: Performance tuning of sun.misc.FloatingDecimal/FormattedFloatingDecimal
bpb
parents:
16852
diff
changeset
|
3290 |
FormattedFloatingDecimal.Form.DECIMAL_FLOAT); |
b6ef7bd945ce
7032154: Performance tuning of sun.misc.FloatingDecimal/FormattedFloatingDecimal
bpb
parents:
16852
diff
changeset
|
3291 |
|
26733 | 3292 |
StringBuilder mant = new StringBuilder().append(fd.getMantissa()); |
3293 |
addZeros(mant, prec); |
|
2 | 3294 |
|
3295 |
// If the precision is zero and the '#' flag is set, add the |
|
3296 |
// requested decimal point. |
|
3297 |
if (f.contains(Flags.ALTERNATE) && (prec == 0)) |
|
26733 | 3298 |
mant.append('.'); |
2 | 3299 |
|
3300 |
int newW = width; |
|
3301 |
if (width != -1) |
|
3302 |
newW = adjustWidth(width, f, neg); |
|
26733 | 3303 |
localizedMagnitude(sb, mant, 0, f, newW, l); |
2 | 3304 |
} else if (c == Conversion.GENERAL) { |
3305 |
int prec = precision; |
|
3306 |
if (precision == -1) |
|
3307 |
prec = 6; |
|
3308 |
else if (precision == 0) |
|
3309 |
prec = 1; |
|
3310 |
||
18545
5f4e734fad1b
6469160: (fmt) general (%g) formatting of zero (0.0) with precision 0 or 1 throws ArrayOutOfBoundsException
bpb
parents:
18143
diff
changeset
|
3311 |
char[] exp; |
26733 | 3312 |
StringBuilder mant = new StringBuilder(); |
18545
5f4e734fad1b
6469160: (fmt) general (%g) formatting of zero (0.0) with precision 0 or 1 throws ArrayOutOfBoundsException
bpb
parents:
18143
diff
changeset
|
3313 |
int expRounded; |
5f4e734fad1b
6469160: (fmt) general (%g) formatting of zero (0.0) with precision 0 or 1 throws ArrayOutOfBoundsException
bpb
parents:
18143
diff
changeset
|
3314 |
if (value == 0.0) { |
5f4e734fad1b
6469160: (fmt) general (%g) formatting of zero (0.0) with precision 0 or 1 throws ArrayOutOfBoundsException
bpb
parents:
18143
diff
changeset
|
3315 |
exp = null; |
26733 | 3316 |
mant.append('0'); |
18545
5f4e734fad1b
6469160: (fmt) general (%g) formatting of zero (0.0) with precision 0 or 1 throws ArrayOutOfBoundsException
bpb
parents:
18143
diff
changeset
|
3317 |
expRounded = 0; |
5f4e734fad1b
6469160: (fmt) general (%g) formatting of zero (0.0) with precision 0 or 1 throws ArrayOutOfBoundsException
bpb
parents:
18143
diff
changeset
|
3318 |
} else { |
5f4e734fad1b
6469160: (fmt) general (%g) formatting of zero (0.0) with precision 0 or 1 throws ArrayOutOfBoundsException
bpb
parents:
18143
diff
changeset
|
3319 |
FormattedFloatingDecimal fd |
18143
b6ef7bd945ce
7032154: Performance tuning of sun.misc.FloatingDecimal/FormattedFloatingDecimal
bpb
parents:
16852
diff
changeset
|
3320 |
= FormattedFloatingDecimal.valueOf(value, prec, |
b6ef7bd945ce
7032154: Performance tuning of sun.misc.FloatingDecimal/FormattedFloatingDecimal
bpb
parents:
16852
diff
changeset
|
3321 |
FormattedFloatingDecimal.Form.GENERAL); |
18545
5f4e734fad1b
6469160: (fmt) general (%g) formatting of zero (0.0) with precision 0 or 1 throws ArrayOutOfBoundsException
bpb
parents:
18143
diff
changeset
|
3322 |
exp = fd.getExponent(); |
26733 | 3323 |
mant.append(fd.getMantissa()); |
18545
5f4e734fad1b
6469160: (fmt) general (%g) formatting of zero (0.0) with precision 0 or 1 throws ArrayOutOfBoundsException
bpb
parents:
18143
diff
changeset
|
3324 |
expRounded = fd.getExponentRounded(); |
5f4e734fad1b
6469160: (fmt) general (%g) formatting of zero (0.0) with precision 0 or 1 throws ArrayOutOfBoundsException
bpb
parents:
18143
diff
changeset
|
3325 |
} |
5f4e734fad1b
6469160: (fmt) general (%g) formatting of zero (0.0) with precision 0 or 1 throws ArrayOutOfBoundsException
bpb
parents:
18143
diff
changeset
|
3326 |
|
2 | 3327 |
if (exp != null) { |
3328 |
prec -= 1; |
|
3329 |
} else { |
|
18545
5f4e734fad1b
6469160: (fmt) general (%g) formatting of zero (0.0) with precision 0 or 1 throws ArrayOutOfBoundsException
bpb
parents:
18143
diff
changeset
|
3330 |
prec -= expRounded + 1; |
2 | 3331 |
} |
3332 |
||
26733 | 3333 |
addZeros(mant, prec); |
2 | 3334 |
// If the precision is zero and the '#' flag is set, add the |
3335 |
// requested decimal point. |
|
26733 | 3336 |
if (f.contains(Flags.ALTERNATE) && (prec == 0)) { |
3337 |
mant.append('.'); |
|
3338 |
} |
|
2 | 3339 |
|
3340 |
int newW = width; |
|
3341 |
if (width != -1) { |
|
3342 |
if (exp != null) |
|
3343 |
newW = adjustWidth(width - exp.length - 1, f, neg); |
|
3344 |
else |
|
3345 |
newW = adjustWidth(width, f, neg); |
|
3346 |
} |
|
26733 | 3347 |
localizedMagnitude(sb, mant, 0, f, newW, l); |
2 | 3348 |
|
3349 |
if (exp != null) { |
|
3350 |
sb.append(f.contains(Flags.UPPERCASE) ? 'E' : 'e'); |
|
3351 |
||
3352 |
char sign = exp[0]; |
|
3353 |
assert(sign == '+' || sign == '-'); |
|
3354 |
sb.append(sign); |
|
3355 |
||
26733 | 3356 |
localizedMagnitudeExp(sb, exp, 1, l); |
2 | 3357 |
} |
3358 |
} else if (c == Conversion.HEXADECIMAL_FLOAT) { |
|
3359 |
int prec = precision; |
|
3360 |
if (precision == -1) |
|
3361 |
// assume that we want all of the digits |
|
3362 |
prec = 0; |
|
3363 |
else if (precision == 0) |
|
3364 |
prec = 1; |
|
3365 |
||
3366 |
String s = hexDouble(value, prec); |
|
3367 |
||
26733 | 3368 |
StringBuilder va = new StringBuilder(); |
2 | 3369 |
boolean upper = f.contains(Flags.UPPERCASE); |
3370 |
sb.append(upper ? "0X" : "0x"); |
|
3371 |
||
26733 | 3372 |
if (f.contains(Flags.ZERO_PAD)) { |
3373 |
trailingZeros(sb, width - s.length() - 2); |
|
3374 |
} |
|
2 | 3375 |
|
3376 |
int idx = s.indexOf('p'); |
|
3377 |
if (upper) { |
|
26733 | 3378 |
String tmp = s.substring(0, idx); |
2 | 3379 |
// don't localize hex |
3380 |
tmp = tmp.toUpperCase(Locale.US); |
|
26733 | 3381 |
va.append(tmp); |
3382 |
} else { |
|
3383 |
va.append(s, 0, idx); |
|
2 | 3384 |
} |
26733 | 3385 |
if (prec != 0) { |
3386 |
addZeros(va, prec); |
|
3387 |
} |
|
3388 |
sb.append(va); |
|
2 | 3389 |
sb.append(upper ? 'P' : 'p'); |
26733 | 3390 |
sb.append(s, idx+1, s.length()); |
2 | 3391 |
} |
3392 |
} |
|
3393 |
||
3394 |
// Add zeros to the requested precision. |
|
26733 | 3395 |
private void addZeros(StringBuilder sb, int prec) { |
2 | 3396 |
// Look for the dot. If we don't find one, the we'll need to add |
3397 |
// it before we add the zeros. |
|
26733 | 3398 |
int len = sb.length(); |
2 | 3399 |
int i; |
26733 | 3400 |
for (i = 0; i < len; i++) { |
3401 |
if (sb.charAt(i) == '.') { |
|
2 | 3402 |
break; |
26733 | 3403 |
} |
2 | 3404 |
} |
3405 |
boolean needDot = false; |
|
26733 | 3406 |
if (i == len) { |
2 | 3407 |
needDot = true; |
3408 |
} |
|
3409 |
||
3410 |
// Determine existing precision. |
|
26733 | 3411 |
int outPrec = len - i - (needDot ? 0 : 1); |
2 | 3412 |
assert (outPrec <= prec); |
26733 | 3413 |
if (outPrec == prec) { |
3414 |
return; |
|
3415 |
} |
|
2 | 3416 |
|
3417 |
// Add dot if previously determined to be necessary. |
|
3418 |
if (needDot) { |
|
26733 | 3419 |
sb.append('.'); |
2 | 3420 |
} |
3421 |
||
3422 |
// Add zeros. |
|
26733 | 3423 |
trailingZeros(sb, prec - outPrec); |
2 | 3424 |
} |
3425 |
||
3426 |
// Method assumes that d > 0. |
|
3427 |
private String hexDouble(double d, int prec) { |
|
3428 |
// Let Double.toHexString handle simple cases |
|
26733 | 3429 |
if (!Double.isFinite(d) || d == 0.0 || prec == 0 || prec >= 13) { |
2 | 3430 |
// remove "0x" |
3431 |
return Double.toHexString(d).substring(2); |
|
26733 | 3432 |
} else { |
2 | 3433 |
assert(prec >= 1 && prec <= 12); |
3434 |
||
10598
efd29b4b3e67
7091682: Move sun.misc.FpUtils code into java.lang.Math
darcy
parents:
9689
diff
changeset
|
3435 |
int exponent = Math.getExponent(d); |
2 | 3436 |
boolean subnormal |
3437 |
= (exponent == DoubleConsts.MIN_EXPONENT - 1); |
|
3438 |
||
3439 |
// If this is subnormal input so normalize (could be faster to |
|
3440 |
// do as integer operation). |
|
3441 |
if (subnormal) { |
|
10598
efd29b4b3e67
7091682: Move sun.misc.FpUtils code into java.lang.Math
darcy
parents:
9689
diff
changeset
|
3442 |
scaleUp = Math.scalb(1.0, 54); |
2 | 3443 |
d *= scaleUp; |
3444 |
// Calculate the exponent. This is not just exponent + 54 |
|
3445 |
// since the former is not the normalized exponent. |
|
10598
efd29b4b3e67
7091682: Move sun.misc.FpUtils code into java.lang.Math
darcy
parents:
9689
diff
changeset
|
3446 |
exponent = Math.getExponent(d); |
2 | 3447 |
assert exponent >= DoubleConsts.MIN_EXPONENT && |
3448 |
exponent <= DoubleConsts.MAX_EXPONENT: exponent; |
|
3449 |
} |
|
3450 |
||
3451 |
int precision = 1 + prec*4; |
|
3452 |
int shiftDistance |
|
3453 |
= DoubleConsts.SIGNIFICAND_WIDTH - precision; |
|
3454 |
assert(shiftDistance >= 1 && shiftDistance < DoubleConsts.SIGNIFICAND_WIDTH); |
|
3455 |
||
3456 |
long doppel = Double.doubleToLongBits(d); |
|
3457 |
// Deterime the number of bits to keep. |
|
3458 |
long newSignif |
|
3459 |
= (doppel & (DoubleConsts.EXP_BIT_MASK |
|
3460 |
| DoubleConsts.SIGNIF_BIT_MASK)) |
|
3461 |
>> shiftDistance; |
|
3462 |
// Bits to round away. |
|
3463 |
long roundingBits = doppel & ~(~0L << shiftDistance); |
|
3464 |
||
3465 |
// To decide how to round, look at the low-order bit of the |
|
3466 |
// working significand, the highest order discarded bit (the |
|
3467 |
// round bit) and whether any of the lower order discarded bits |
|
3468 |
// are nonzero (the sticky bit). |
|
3469 |
||
3470 |
boolean leastZero = (newSignif & 0x1L) == 0L; |
|
3471 |
boolean round |
|
3472 |
= ((1L << (shiftDistance - 1) ) & roundingBits) != 0L; |
|
3473 |
boolean sticky = shiftDistance > 1 && |
|
3474 |
(~(1L<< (shiftDistance - 1)) & roundingBits) != 0; |
|
3475 |
if((leastZero && round && sticky) || (!leastZero && round)) { |
|
3476 |
newSignif++; |
|
3477 |
} |
|
3478 |
||
3479 |
long signBit = doppel & DoubleConsts.SIGN_BIT_MASK; |
|
3480 |
newSignif = signBit | (newSignif << shiftDistance); |
|
3481 |
double result = Double.longBitsToDouble(newSignif); |
|
3482 |
||
3483 |
if (Double.isInfinite(result) ) { |
|
3484 |
// Infinite result generated by rounding |
|
3485 |
return "1.0p1024"; |
|
3486 |
} else { |
|
3487 |
String res = Double.toHexString(result).substring(2); |
|
3488 |
if (!subnormal) |
|
3489 |
return res; |
|
3490 |
else { |
|
3491 |
// Create a normalized subnormal string. |
|
3492 |
int idx = res.indexOf('p'); |
|
3493 |
if (idx == -1) { |
|
3494 |
// No 'p' character in hex string. |
|
3495 |
assert false; |
|
3496 |
return null; |
|
3497 |
} else { |
|
3498 |
// Get exponent and append at the end. |
|
3499 |
String exp = res.substring(idx + 1); |
|
3500 |
int iexp = Integer.parseInt(exp) -54; |
|
3501 |
return res.substring(0, idx) + "p" |
|
3502 |
+ Integer.toString(iexp); |
|
3503 |
} |
|
3504 |
} |
|
3505 |
} |
|
3506 |
} |
|
3507 |
} |
|
3508 |
||
3509 |
private void print(BigDecimal value, Locale l) throws IOException { |
|
3510 |
if (c == Conversion.HEXADECIMAL_FLOAT) |
|
3511 |
failConversion(c, value); |
|
3512 |
StringBuilder sb = new StringBuilder(); |
|
3513 |
boolean neg = value.signum() == -1; |
|
3514 |
BigDecimal v = value.abs(); |
|
3515 |
// leading sign indicator |
|
3516 |
leadingSign(sb, neg); |
|
3517 |
||
3518 |
// the value |
|
3519 |
print(sb, v, l, f, c, precision, neg); |
|
3520 |
||
3521 |
// trailing sign indicator |
|
3522 |
trailingSign(sb, neg); |
|
3523 |
||
3524 |
// justify based on width |
|
26733 | 3525 |
appendJustified(a, sb); |
2 | 3526 |
} |
3527 |
||
3528 |
// value > 0 |
|
3529 |
private void print(StringBuilder sb, BigDecimal value, Locale l, |
|
3530 |
Flags f, char c, int precision, boolean neg) |
|
3531 |
throws IOException |
|
3532 |
{ |
|
3533 |
if (c == Conversion.SCIENTIFIC) { |
|
3534 |
// Create a new BigDecimal with the desired precision. |
|
3535 |
int prec = (precision == -1 ? 6 : precision); |
|
3536 |
int scale = value.scale(); |
|
3537 |
int origPrec = value.precision(); |
|
3538 |
int nzeros = 0; |
|
3539 |
int compPrec; |
|
3540 |
||
3541 |
if (prec > origPrec - 1) { |
|
3542 |
compPrec = origPrec; |
|
3543 |
nzeros = prec - (origPrec - 1); |
|
3544 |
} else { |
|
3545 |
compPrec = prec + 1; |
|
3546 |
} |
|
3547 |
||
3548 |
MathContext mc = new MathContext(compPrec); |
|
3549 |
BigDecimal v |
|
3550 |
= new BigDecimal(value.unscaledValue(), scale, mc); |
|
3551 |
||
3552 |
BigDecimalLayout bdl |
|
3553 |
= new BigDecimalLayout(v.unscaledValue(), v.scale(), |
|
3554 |
BigDecimalLayoutForm.SCIENTIFIC); |
|
3555 |
||
26733 | 3556 |
StringBuilder mant = bdl.mantissa(); |
2 | 3557 |
|
3558 |
// Add a decimal point if necessary. The mantissa may not |
|
3559 |
// contain a decimal point if the scale is zero (the internal |
|
3560 |
// representation has no fractional part) or the original |
|
3561 |
// precision is one. Append a decimal point if '#' is set or if |
|
3562 |
// we require zero padding to get to the requested precision. |
|
3563 |
if ((origPrec == 1 || !bdl.hasDot()) |
|
26733 | 3564 |
&& (nzeros > 0 || (f.contains(Flags.ALTERNATE)))) { |
3565 |
mant.append('.'); |
|
3566 |
} |
|
2 | 3567 |
|
3568 |
// Add trailing zeros in the case precision is greater than |
|
3569 |
// the number of available digits after the decimal separator. |
|
26733 | 3570 |
trailingZeros(mant, nzeros); |
3571 |
||
3572 |
StringBuilder exp = bdl.exponent(); |
|
2 | 3573 |
int newW = width; |
26733 | 3574 |
if (width != -1) { |
3575 |
newW = adjustWidth(width - exp.length() - 1, f, neg); |
|
3576 |
} |
|
3577 |
localizedMagnitude(sb, mant, 0, f, newW, l); |
|
2 | 3578 |
|
3579 |
sb.append(f.contains(Flags.UPPERCASE) ? 'E' : 'e'); |
|
3580 |
||
3581 |
Flags flags = f.dup().remove(Flags.GROUP); |
|
26733 | 3582 |
char sign = exp.charAt(0); |
2 | 3583 |
assert(sign == '+' || sign == '-'); |
26733 | 3584 |
sb.append(sign); |
3585 |
||
3586 |
sb.append(localizedMagnitude(null, exp, 1, flags, -1, l)); |
|
2 | 3587 |
} else if (c == Conversion.DECIMAL_FLOAT) { |
3588 |
// Create a new BigDecimal with the desired precision. |
|
3589 |
int prec = (precision == -1 ? 6 : precision); |
|
3590 |
int scale = value.scale(); |
|
1823
23d42a96635e
6476425: (fmt)java.util.Formatter.print() throws IllegalArgumentException on large BigDecima
sherman
parents:
2
diff
changeset
|
3591 |
|
23d42a96635e
6476425: (fmt)java.util.Formatter.print() throws IllegalArgumentException on large BigDecima
sherman
parents:
2
diff
changeset
|
3592 |
if (scale > prec) { |
8799
99032bb1a2b9
6796662: (fmt spec) Formatter spec on BigDecimal output should not reference Float a
sherman
parents:
8166
diff
changeset
|
3593 |
// more "scale" digits than the requested "precision" |
1823
23d42a96635e
6476425: (fmt)java.util.Formatter.print() throws IllegalArgumentException on large BigDecima
sherman
parents:
2
diff
changeset
|
3594 |
int compPrec = value.precision(); |
23d42a96635e
6476425: (fmt)java.util.Formatter.print() throws IllegalArgumentException on large BigDecima
sherman
parents:
2
diff
changeset
|
3595 |
if (compPrec <= scale) { |
23d42a96635e
6476425: (fmt)java.util.Formatter.print() throws IllegalArgumentException on large BigDecima
sherman
parents:
2
diff
changeset
|
3596 |
// case of 0.xxxxxx |
23d42a96635e
6476425: (fmt)java.util.Formatter.print() throws IllegalArgumentException on large BigDecima
sherman
parents:
2
diff
changeset
|
3597 |
value = value.setScale(prec, RoundingMode.HALF_UP); |
23d42a96635e
6476425: (fmt)java.util.Formatter.print() throws IllegalArgumentException on large BigDecima
sherman
parents:
2
diff
changeset
|
3598 |
} else { |
23d42a96635e
6476425: (fmt)java.util.Formatter.print() throws IllegalArgumentException on large BigDecima
sherman
parents:
2
diff
changeset
|
3599 |
compPrec -= (scale - prec); |
23d42a96635e
6476425: (fmt)java.util.Formatter.print() throws IllegalArgumentException on large BigDecima
sherman
parents:
2
diff
changeset
|
3600 |
value = new BigDecimal(value.unscaledValue(), |
23d42a96635e
6476425: (fmt)java.util.Formatter.print() throws IllegalArgumentException on large BigDecima
sherman
parents:
2
diff
changeset
|
3601 |
scale, |
23d42a96635e
6476425: (fmt)java.util.Formatter.print() throws IllegalArgumentException on large BigDecima
sherman
parents:
2
diff
changeset
|
3602 |
new MathContext(compPrec)); |
23d42a96635e
6476425: (fmt)java.util.Formatter.print() throws IllegalArgumentException on large BigDecima
sherman
parents:
2
diff
changeset
|
3603 |
} |
23d42a96635e
6476425: (fmt)java.util.Formatter.print() throws IllegalArgumentException on large BigDecima
sherman
parents:
2
diff
changeset
|
3604 |
} |
23d42a96635e
6476425: (fmt)java.util.Formatter.print() throws IllegalArgumentException on large BigDecima
sherman
parents:
2
diff
changeset
|
3605 |
BigDecimalLayout bdl = new BigDecimalLayout( |
23d42a96635e
6476425: (fmt)java.util.Formatter.print() throws IllegalArgumentException on large BigDecima
sherman
parents:
2
diff
changeset
|
3606 |
value.unscaledValue(), |
23d42a96635e
6476425: (fmt)java.util.Formatter.print() throws IllegalArgumentException on large BigDecima
sherman
parents:
2
diff
changeset
|
3607 |
value.scale(), |
2 | 3608 |
BigDecimalLayoutForm.DECIMAL_FLOAT); |
3609 |
||
26733 | 3610 |
StringBuilder mant = bdl.mantissa(); |
2 | 3611 |
int nzeros = (bdl.scale() < prec ? prec - bdl.scale() : 0); |
3612 |
||
3613 |
// Add a decimal point if necessary. The mantissa may not |
|
3614 |
// contain a decimal point if the scale is zero (the internal |
|
3615 |
// representation has no fractional part). Append a decimal |
|
3616 |
// point if '#' is set or we require zero padding to get to the |
|
3617 |
// requested precision. |
|
26733 | 3618 |
if (bdl.scale() == 0 && (f.contains(Flags.ALTERNATE) |
3619 |
|| nzeros > 0)) { |
|
3620 |
mant.append('.'); |
|
3621 |
} |
|
2 | 3622 |
|
3623 |
// Add trailing zeros if the precision is greater than the |
|
3624 |
// number of available digits after the decimal separator. |
|
26733 | 3625 |
trailingZeros(mant, nzeros); |
3626 |
||
3627 |
localizedMagnitude(sb, mant, 0, f, adjustWidth(width, f, neg), l); |
|
2 | 3628 |
} else if (c == Conversion.GENERAL) { |
3629 |
int prec = precision; |
|
3630 |
if (precision == -1) |
|
3631 |
prec = 6; |
|
3632 |
else if (precision == 0) |
|
3633 |
prec = 1; |
|
3634 |
||
3635 |
BigDecimal tenToTheNegFour = BigDecimal.valueOf(1, 4); |
|
3636 |
BigDecimal tenToThePrec = BigDecimal.valueOf(1, -prec); |
|
3637 |
if ((value.equals(BigDecimal.ZERO)) |
|
3638 |
|| ((value.compareTo(tenToTheNegFour) != -1) |
|
3639 |
&& (value.compareTo(tenToThePrec) == -1))) { |
|
3640 |
||
3641 |
int e = - value.scale() |
|
3642 |
+ (value.unscaledValue().toString().length() - 1); |
|
3643 |
||
3644 |
// xxx.yyy |
|
3645 |
// g precision (# sig digits) = #x + #y |
|
3646 |
// f precision = #y |
|
3647 |
// exponent = #x - 1 |
|
3648 |
// => f precision = g precision - exponent - 1 |
|
3649 |
// 0.000zzz |
|
3650 |
// g precision (# sig digits) = #z |
|
3651 |
// f precision = #0 (after '.') + #z |
|
3652 |
// exponent = - #0 (after '.') - 1 |
|
3653 |
// => f precision = g precision - exponent - 1 |
|
3654 |
prec = prec - e - 1; |
|
3655 |
||
3656 |
print(sb, value, l, f, Conversion.DECIMAL_FLOAT, prec, |
|
3657 |
neg); |
|
3658 |
} else { |
|
3659 |
print(sb, value, l, f, Conversion.SCIENTIFIC, prec - 1, neg); |
|
3660 |
} |
|
3661 |
} else if (c == Conversion.HEXADECIMAL_FLOAT) { |
|
3662 |
// This conversion isn't supported. The error should be |
|
3663 |
// reported earlier. |
|
3664 |
assert false; |
|
3665 |
} |
|
3666 |
} |
|
3667 |
||
3668 |
private class BigDecimalLayout { |
|
3669 |
private StringBuilder mant; |
|
3670 |
private StringBuilder exp; |
|
3671 |
private boolean dot = false; |
|
3672 |
private int scale; |
|
3673 |
||
3674 |
public BigDecimalLayout(BigInteger intVal, int scale, BigDecimalLayoutForm form) { |
|
3675 |
layout(intVal, scale, form); |
|
3676 |
} |
|
3677 |
||
3678 |
public boolean hasDot() { |
|
3679 |
return dot; |
|
3680 |
} |
|
3681 |
||
3682 |
public int scale() { |
|
3683 |
return scale; |
|
3684 |
} |
|
3685 |
||
26733 | 3686 |
public StringBuilder mantissa() { |
3687 |
return mant; |
|
2 | 3688 |
} |
3689 |
||
3690 |
// The exponent will be formatted as a sign ('+' or '-') followed |
|
3691 |
// by the exponent zero-padded to include at least two digits. |
|
26733 | 3692 |
public StringBuilder exponent() { |
3693 |
return exp; |
|
2 | 3694 |
} |
3695 |
||
3696 |
private void layout(BigInteger intVal, int scale, BigDecimalLayoutForm form) { |
|
26733 | 3697 |
String coeff = intVal.toString(); |
2 | 3698 |
this.scale = scale; |
3699 |
||
3700 |
// Construct a buffer, with sufficient capacity for all cases. |
|
3701 |
// If E-notation is needed, length will be: +1 if negative, +1 |
|
3702 |
// if '.' needed, +2 for "E+", + up to 10 for adjusted |
|
3703 |
// exponent. Otherwise it could have +1 if negative, plus |
|
3704 |
// leading "0.00000" |
|
26733 | 3705 |
int len = coeff.length(); |
3706 |
mant = new StringBuilder(len + 14); |
|
2 | 3707 |
|
3708 |
if (scale == 0) { |
|
3709 |
if (len > 1) { |
|
26733 | 3710 |
mant.append(coeff.charAt(0)); |
2 | 3711 |
if (form == BigDecimalLayoutForm.SCIENTIFIC) { |
3712 |
mant.append('.'); |
|
3713 |
dot = true; |
|
26733 | 3714 |
mant.append(coeff, 1, len); |
2 | 3715 |
exp = new StringBuilder("+"); |
26733 | 3716 |
if (len < 10) { |
3717 |
exp.append('0').append(len - 1); |
|
3718 |
} else { |
|
2 | 3719 |
exp.append(len - 1); |
26733 | 3720 |
} |
2 | 3721 |
} else { |
26733 | 3722 |
mant.append(coeff, 1, len); |
2 | 3723 |
} |
3724 |
} else { |
|
3725 |
mant.append(coeff); |
|
26733 | 3726 |
if (form == BigDecimalLayoutForm.SCIENTIFIC) { |
2 | 3727 |
exp = new StringBuilder("+00"); |
26733 | 3728 |
} |
2 | 3729 |
} |
3730 |
return; |
|
3731 |
} |
|
26733 | 3732 |
long adjusted = -(long) scale + (len - 1); |
2 | 3733 |
if (form == BigDecimalLayoutForm.DECIMAL_FLOAT) { |
3734 |
// count of padding zeros |
|
26733 | 3735 |
int pad = scale - len; |
2 | 3736 |
if (pad >= 0) { |
3737 |
// 0.xxx form |
|
3738 |
mant.append("0."); |
|
3739 |
dot = true; |
|
26733 | 3740 |
trailingZeros(mant, pad); |
2 | 3741 |
mant.append(coeff); |
3742 |
} else { |
|
26733 | 3743 |
if (-pad < len) { |
2 | 3744 |
// xx.xx form |
3745 |
mant.append(coeff, 0, -pad); |
|
3746 |
mant.append('.'); |
|
3747 |
dot = true; |
|
26733 | 3748 |
mant.append(coeff, -pad, -pad + scale); |
2 | 3749 |
} else { |
3750 |
// xx form |
|
26733 | 3751 |
mant.append(coeff, 0, len); |
3752 |
trailingZeros(mant, -scale); |
|
2 | 3753 |
this.scale = 0; |
3754 |
} |
|
3755 |
} |
|
3756 |
} else { |
|
3757 |
// x.xxx form |
|
26733 | 3758 |
mant.append(coeff.charAt(0)); |
3759 |
if (len > 1) { |
|
2 | 3760 |
mant.append('.'); |
3761 |
dot = true; |
|
26733 | 3762 |
mant.append(coeff, 1, len); |
2 | 3763 |
} |
3764 |
exp = new StringBuilder(); |
|
3765 |
if (adjusted != 0) { |
|
3766 |
long abs = Math.abs(adjusted); |
|
3767 |
// require sign |
|
3768 |
exp.append(adjusted < 0 ? '-' : '+'); |
|
26733 | 3769 |
if (abs < 10) { |
2 | 3770 |
exp.append('0'); |
26733 | 3771 |
} |
2 | 3772 |
exp.append(abs); |
3773 |
} else { |
|
3774 |
exp.append("+00"); |
|
3775 |
} |
|
3776 |
} |
|
3777 |
} |
|
3778 |
} |
|
3779 |
||
3780 |
private int adjustWidth(int width, Flags f, boolean neg) { |
|
3781 |
int newW = width; |
|
3782 |
if (newW != -1 && neg && f.contains(Flags.PARENTHESES)) |
|
3783 |
newW--; |
|
3784 |
return newW; |
|
3785 |
} |
|
3786 |
||
26733 | 3787 |
// Add trailing zeros |
3788 |
private void trailingZeros(StringBuilder sb, int nzeros) { |
|
3789 |
for (int i = 0; i < nzeros; i++) { |
|
3790 |
sb.append('0'); |
|
3791 |
} |
|
2 | 3792 |
} |
3793 |
||
26733 | 3794 |
private void print(Calendar t, char c, Locale l) throws IOException { |
2 | 3795 |
StringBuilder sb = new StringBuilder(); |
3796 |
print(sb, t, c, l); |
|
3797 |
||
3798 |
// justify based on width |
|
26733 | 3799 |
if (f.contains(Flags.UPPERCASE)) { |
3800 |
appendJustified(a, sb.toString().toUpperCase()); |
|
3801 |
} else { |
|
3802 |
appendJustified(a, sb); |
|
3803 |
} |
|
2 | 3804 |
} |
3805 |
||
26733 | 3806 |
private Appendable print(StringBuilder sb, Calendar t, char c, Locale l) |
3807 |
throws IOException { |
|
2 | 3808 |
if (sb == null) |
3809 |
sb = new StringBuilder(); |
|
3810 |
switch (c) { |
|
3811 |
case DateTime.HOUR_OF_DAY_0: // 'H' (00 - 23) |
|
3812 |
case DateTime.HOUR_0: // 'I' (01 - 12) |
|
3813 |
case DateTime.HOUR_OF_DAY: // 'k' (0 - 23) -- like H |
|
3814 |
case DateTime.HOUR: { // 'l' (1 - 12) -- like I |
|
3815 |
int i = t.get(Calendar.HOUR_OF_DAY); |
|
3816 |
if (c == DateTime.HOUR_0 || c == DateTime.HOUR) |
|
3817 |
i = (i == 0 || i == 12 ? 12 : i % 12); |
|
3818 |
Flags flags = (c == DateTime.HOUR_OF_DAY_0 |
|
3819 |
|| c == DateTime.HOUR_0 |
|
3820 |
? Flags.ZERO_PAD |
|
3821 |
: Flags.NONE); |
|
3822 |
sb.append(localizedMagnitude(null, i, flags, 2, l)); |
|
3823 |
break; |
|
3824 |
} |
|
3825 |
case DateTime.MINUTE: { // 'M' (00 - 59) |
|
3826 |
int i = t.get(Calendar.MINUTE); |
|
3827 |
Flags flags = Flags.ZERO_PAD; |
|
3828 |
sb.append(localizedMagnitude(null, i, flags, 2, l)); |
|
3829 |
break; |
|
3830 |
} |
|
3831 |
case DateTime.NANOSECOND: { // 'N' (000000000 - 999999999) |
|
3832 |
int i = t.get(Calendar.MILLISECOND) * 1000000; |
|
3833 |
Flags flags = Flags.ZERO_PAD; |
|
3834 |
sb.append(localizedMagnitude(null, i, flags, 9, l)); |
|
3835 |
break; |
|
3836 |
} |
|
3837 |
case DateTime.MILLISECOND: { // 'L' (000 - 999) |
|
3838 |
int i = t.get(Calendar.MILLISECOND); |
|
3839 |
Flags flags = Flags.ZERO_PAD; |
|
3840 |
sb.append(localizedMagnitude(null, i, flags, 3, l)); |
|
3841 |
break; |
|
3842 |
} |
|
3843 |
case DateTime.MILLISECOND_SINCE_EPOCH: { // 'Q' (0 - 99...?) |
|
3844 |
long i = t.getTimeInMillis(); |
|
3845 |
Flags flags = Flags.NONE; |
|
3846 |
sb.append(localizedMagnitude(null, i, flags, width, l)); |
|
3847 |
break; |
|
3848 |
} |
|
3849 |
case DateTime.AM_PM: { // 'p' (am or pm) |
|
3850 |
// Calendar.AM = 0, Calendar.PM = 1, LocaleElements defines upper |
|
3851 |
String[] ampm = { "AM", "PM" }; |
|
3852 |
if (l != null && l != Locale.US) { |
|
3853 |
DateFormatSymbols dfs = DateFormatSymbols.getInstance(l); |
|
3854 |
ampm = dfs.getAmPmStrings(); |
|
3855 |
} |
|
3856 |
String s = ampm[t.get(Calendar.AM_PM)]; |
|
3857 |
sb.append(s.toLowerCase(l != null ? l : Locale.US)); |
|
3858 |
break; |
|
3859 |
} |
|
3860 |
case DateTime.SECONDS_SINCE_EPOCH: { // 's' (0 - 99...?) |
|
3861 |
long i = t.getTimeInMillis() / 1000; |
|
3862 |
Flags flags = Flags.NONE; |
|
3863 |
sb.append(localizedMagnitude(null, i, flags, width, l)); |
|
3864 |
break; |
|
3865 |
} |
|
3866 |
case DateTime.SECOND: { // 'S' (00 - 60 - leap second) |
|
3867 |
int i = t.get(Calendar.SECOND); |
|
3868 |
Flags flags = Flags.ZERO_PAD; |
|
3869 |
sb.append(localizedMagnitude(null, i, flags, 2, l)); |
|
3870 |
break; |
|
3871 |
} |
|
3872 |
case DateTime.ZONE_NUMERIC: { // 'z' ({-|+}####) - ls minus? |
|
3873 |
int i = t.get(Calendar.ZONE_OFFSET) + t.get(Calendar.DST_OFFSET); |
|
3874 |
boolean neg = i < 0; |
|
3875 |
sb.append(neg ? '-' : '+'); |
|
3876 |
if (neg) |
|
3877 |
i = -i; |
|
3878 |
int min = i / 60000; |
|
3879 |
// combine minute and hour into a single integer |
|
3880 |
int offset = (min / 60) * 100 + (min % 60); |
|
3881 |
Flags flags = Flags.ZERO_PAD; |
|
3882 |
||
3883 |
sb.append(localizedMagnitude(null, offset, flags, 4, l)); |
|
3884 |
break; |
|
3885 |
} |
|
3886 |
case DateTime.ZONE: { // 'Z' (symbol) |
|
3887 |
TimeZone tz = t.getTimeZone(); |
|
3888 |
sb.append(tz.getDisplayName((t.get(Calendar.DST_OFFSET) != 0), |
|
3889 |
TimeZone.SHORT, |
|
3890 |
(l == null) ? Locale.US : l)); |
|
3891 |
break; |
|
3892 |
} |
|
3893 |
||
3894 |
// Date |
|
3895 |
case DateTime.NAME_OF_DAY_ABBREV: // 'a' |
|
3896 |
case DateTime.NAME_OF_DAY: { // 'A' |
|
3897 |
int i = t.get(Calendar.DAY_OF_WEEK); |
|
3898 |
Locale lt = ((l == null) ? Locale.US : l); |
|
3899 |
DateFormatSymbols dfs = DateFormatSymbols.getInstance(lt); |
|
3900 |
if (c == DateTime.NAME_OF_DAY) |
|
3901 |
sb.append(dfs.getWeekdays()[i]); |
|
3902 |
else |
|
3903 |
sb.append(dfs.getShortWeekdays()[i]); |
|
3904 |
break; |
|
3905 |
} |
|
3906 |
case DateTime.NAME_OF_MONTH_ABBREV: // 'b' |
|
3907 |
case DateTime.NAME_OF_MONTH_ABBREV_X: // 'h' -- same b |
|
3908 |
case DateTime.NAME_OF_MONTH: { // 'B' |
|
3909 |
int i = t.get(Calendar.MONTH); |
|
3910 |
Locale lt = ((l == null) ? Locale.US : l); |
|
3911 |
DateFormatSymbols dfs = DateFormatSymbols.getInstance(lt); |
|
3912 |
if (c == DateTime.NAME_OF_MONTH) |
|
3913 |
sb.append(dfs.getMonths()[i]); |
|
3914 |
else |
|
3915 |
sb.append(dfs.getShortMonths()[i]); |
|
3916 |
break; |
|
3917 |
} |
|
3918 |
case DateTime.CENTURY: // 'C' (00 - 99) |
|
3919 |
case DateTime.YEAR_2: // 'y' (00 - 99) |
|
3920 |
case DateTime.YEAR_4: { // 'Y' (0000 - 9999) |
|
3921 |
int i = t.get(Calendar.YEAR); |
|
3922 |
int size = 2; |
|
3923 |
switch (c) { |
|
3924 |
case DateTime.CENTURY: |
|
3925 |
i /= 100; |
|
3926 |
break; |
|
3927 |
case DateTime.YEAR_2: |
|
3928 |
i %= 100; |
|
3929 |
break; |
|
3930 |
case DateTime.YEAR_4: |
|
3931 |
size = 4; |
|
3932 |
break; |
|
3933 |
} |
|
3934 |
Flags flags = Flags.ZERO_PAD; |
|
3935 |
sb.append(localizedMagnitude(null, i, flags, size, l)); |
|
3936 |
break; |
|
3937 |
} |
|
3938 |
case DateTime.DAY_OF_MONTH_0: // 'd' (01 - 31) |
|
3939 |
case DateTime.DAY_OF_MONTH: { // 'e' (1 - 31) -- like d |
|
3940 |
int i = t.get(Calendar.DATE); |
|
3941 |
Flags flags = (c == DateTime.DAY_OF_MONTH_0 |
|
3942 |
? Flags.ZERO_PAD |
|
3943 |
: Flags.NONE); |
|
3944 |
sb.append(localizedMagnitude(null, i, flags, 2, l)); |
|
3945 |
break; |
|
3946 |
} |
|
3947 |
case DateTime.DAY_OF_YEAR: { // 'j' (001 - 366) |
|
3948 |
int i = t.get(Calendar.DAY_OF_YEAR); |
|
3949 |
Flags flags = Flags.ZERO_PAD; |
|
3950 |
sb.append(localizedMagnitude(null, i, flags, 3, l)); |
|
3951 |
break; |
|
3952 |
} |
|
3953 |
case DateTime.MONTH: { // 'm' (01 - 12) |
|
3954 |
int i = t.get(Calendar.MONTH) + 1; |
|
3955 |
Flags flags = Flags.ZERO_PAD; |
|
3956 |
sb.append(localizedMagnitude(null, i, flags, 2, l)); |
|
3957 |
break; |
|
3958 |
} |
|
3959 |
||
3960 |
// Composites |
|
3961 |
case DateTime.TIME: // 'T' (24 hour hh:mm:ss - %tH:%tM:%tS) |
|
3962 |
case DateTime.TIME_24_HOUR: { // 'R' (hh:mm same as %H:%M) |
|
3963 |
char sep = ':'; |
|
3964 |
print(sb, t, DateTime.HOUR_OF_DAY_0, l).append(sep); |
|
3965 |
print(sb, t, DateTime.MINUTE, l); |
|
3966 |
if (c == DateTime.TIME) { |
|
3967 |
sb.append(sep); |
|
3968 |
print(sb, t, DateTime.SECOND, l); |
|
3969 |
} |
|
3970 |
break; |
|
3971 |
} |
|
3972 |
case DateTime.TIME_12_HOUR: { // 'r' (hh:mm:ss [AP]M) |
|
3973 |
char sep = ':'; |
|
3974 |
print(sb, t, DateTime.HOUR_0, l).append(sep); |
|
3975 |
print(sb, t, DateTime.MINUTE, l).append(sep); |
|
3976 |
print(sb, t, DateTime.SECOND, l).append(' '); |
|
3977 |
// this may be in wrong place for some locales |
|
3978 |
StringBuilder tsb = new StringBuilder(); |
|
3979 |
print(tsb, t, DateTime.AM_PM, l); |
|
26733 | 3980 |
|
2 | 3981 |
sb.append(tsb.toString().toUpperCase(l != null ? l : Locale.US)); |
3982 |
break; |
|
3983 |
} |
|
3984 |
case DateTime.DATE_TIME: { // 'c' (Sat Nov 04 12:02:33 EST 1999) |
|
3985 |
char sep = ' '; |
|
3986 |
print(sb, t, DateTime.NAME_OF_DAY_ABBREV, l).append(sep); |
|
3987 |
print(sb, t, DateTime.NAME_OF_MONTH_ABBREV, l).append(sep); |
|
3988 |
print(sb, t, DateTime.DAY_OF_MONTH_0, l).append(sep); |
|
3989 |
print(sb, t, DateTime.TIME, l).append(sep); |
|
3990 |
print(sb, t, DateTime.ZONE, l).append(sep); |
|
3991 |
print(sb, t, DateTime.YEAR_4, l); |
|
3992 |
break; |
|
3993 |
} |
|
3994 |
case DateTime.DATE: { // 'D' (mm/dd/yy) |
|
3995 |
char sep = '/'; |
|
3996 |
print(sb, t, DateTime.MONTH, l).append(sep); |
|
3997 |
print(sb, t, DateTime.DAY_OF_MONTH_0, l).append(sep); |
|
3998 |
print(sb, t, DateTime.YEAR_2, l); |
|
3999 |
break; |
|
4000 |
} |
|
4001 |
case DateTime.ISO_STANDARD_DATE: { // 'F' (%Y-%m-%d) |
|
4002 |
char sep = '-'; |
|
4003 |
print(sb, t, DateTime.YEAR_4, l).append(sep); |
|
4004 |
print(sb, t, DateTime.MONTH, l).append(sep); |
|
4005 |
print(sb, t, DateTime.DAY_OF_MONTH_0, l); |
|
4006 |
break; |
|
4007 |
} |
|
4008 |
default: |
|
4009 |
assert false; |
|
4010 |
} |
|
4011 |
return sb; |
|
4012 |
} |
|
4013 |
||
15289 | 4014 |
private void print(TemporalAccessor t, char c, Locale l) throws IOException { |
4015 |
StringBuilder sb = new StringBuilder(); |
|
4016 |
print(sb, t, c, l); |
|
4017 |
// justify based on width |
|
26733 | 4018 |
if (f.contains(Flags.UPPERCASE)) { |
4019 |
appendJustified(a, sb.toString().toUpperCase()); |
|
4020 |
} else { |
|
4021 |
appendJustified(a, sb); |
|
4022 |
} |
|
15289 | 4023 |
} |
4024 |
||
4025 |
private Appendable print(StringBuilder sb, TemporalAccessor t, char c, |
|
4026 |
Locale l) throws IOException { |
|
4027 |
if (sb == null) |
|
4028 |
sb = new StringBuilder(); |
|
4029 |
try { |
|
4030 |
switch (c) { |
|
4031 |
case DateTime.HOUR_OF_DAY_0: { // 'H' (00 - 23) |
|
4032 |
int i = t.get(ChronoField.HOUR_OF_DAY); |
|
4033 |
sb.append(localizedMagnitude(null, i, Flags.ZERO_PAD, 2, l)); |
|
4034 |
break; |
|
4035 |
} |
|
4036 |
case DateTime.HOUR_OF_DAY: { // 'k' (0 - 23) -- like H |
|
4037 |
int i = t.get(ChronoField.HOUR_OF_DAY); |
|
4038 |
sb.append(localizedMagnitude(null, i, Flags.NONE, 2, l)); |
|
4039 |
break; |
|
4040 |
} |
|
4041 |
case DateTime.HOUR_0: { // 'I' (01 - 12) |
|
4042 |
int i = t.get(ChronoField.CLOCK_HOUR_OF_AMPM); |
|
4043 |
sb.append(localizedMagnitude(null, i, Flags.ZERO_PAD, 2, l)); |
|
4044 |
break; |
|
4045 |
} |
|
4046 |
case DateTime.HOUR: { // 'l' (1 - 12) -- like I |
|
4047 |
int i = t.get(ChronoField.CLOCK_HOUR_OF_AMPM); |
|
4048 |
sb.append(localizedMagnitude(null, i, Flags.NONE, 2, l)); |
|
4049 |
break; |
|
4050 |
} |
|
4051 |
case DateTime.MINUTE: { // 'M' (00 - 59) |
|
4052 |
int i = t.get(ChronoField.MINUTE_OF_HOUR); |
|
4053 |
Flags flags = Flags.ZERO_PAD; |
|
4054 |
sb.append(localizedMagnitude(null, i, flags, 2, l)); |
|
4055 |
break; |
|
4056 |
} |
|
4057 |
case DateTime.NANOSECOND: { // 'N' (000000000 - 999999999) |
|
4058 |
int i = t.get(ChronoField.MILLI_OF_SECOND) * 1000000; |
|
4059 |
Flags flags = Flags.ZERO_PAD; |
|
4060 |
sb.append(localizedMagnitude(null, i, flags, 9, l)); |
|
4061 |
break; |
|
4062 |
} |
|
4063 |
case DateTime.MILLISECOND: { // 'L' (000 - 999) |
|
4064 |
int i = t.get(ChronoField.MILLI_OF_SECOND); |
|
4065 |
Flags flags = Flags.ZERO_PAD; |
|
4066 |
sb.append(localizedMagnitude(null, i, flags, 3, l)); |
|
4067 |
break; |
|
4068 |
} |
|
4069 |
case DateTime.MILLISECOND_SINCE_EPOCH: { // 'Q' (0 - 99...?) |
|
4070 |
long i = t.getLong(ChronoField.INSTANT_SECONDS) * 1000L + |
|
4071 |
t.getLong(ChronoField.MILLI_OF_SECOND); |
|
4072 |
Flags flags = Flags.NONE; |
|
4073 |
sb.append(localizedMagnitude(null, i, flags, width, l)); |
|
4074 |
break; |
|
4075 |
} |
|
4076 |
case DateTime.AM_PM: { // 'p' (am or pm) |
|
4077 |
// Calendar.AM = 0, Calendar.PM = 1, LocaleElements defines upper |
|
4078 |
String[] ampm = { "AM", "PM" }; |
|
4079 |
if (l != null && l != Locale.US) { |
|
4080 |
DateFormatSymbols dfs = DateFormatSymbols.getInstance(l); |
|
4081 |
ampm = dfs.getAmPmStrings(); |
|
4082 |
} |
|
4083 |
String s = ampm[t.get(ChronoField.AMPM_OF_DAY)]; |
|
4084 |
sb.append(s.toLowerCase(l != null ? l : Locale.US)); |
|
4085 |
break; |
|
4086 |
} |
|
4087 |
case DateTime.SECONDS_SINCE_EPOCH: { // 's' (0 - 99...?) |
|
4088 |
long i = t.getLong(ChronoField.INSTANT_SECONDS); |
|
4089 |
Flags flags = Flags.NONE; |
|
4090 |
sb.append(localizedMagnitude(null, i, flags, width, l)); |
|
4091 |
break; |
|
4092 |
} |
|
4093 |
case DateTime.SECOND: { // 'S' (00 - 60 - leap second) |
|
4094 |
int i = t.get(ChronoField.SECOND_OF_MINUTE); |
|
4095 |
Flags flags = Flags.ZERO_PAD; |
|
4096 |
sb.append(localizedMagnitude(null, i, flags, 2, l)); |
|
4097 |
break; |
|
4098 |
} |
|
4099 |
case DateTime.ZONE_NUMERIC: { // 'z' ({-|+}####) - ls minus? |
|
4100 |
int i = t.get(ChronoField.OFFSET_SECONDS); |
|
4101 |
boolean neg = i < 0; |
|
4102 |
sb.append(neg ? '-' : '+'); |
|
4103 |
if (neg) |
|
4104 |
i = -i; |
|
4105 |
int min = i / 60; |
|
4106 |
// combine minute and hour into a single integer |
|
4107 |
int offset = (min / 60) * 100 + (min % 60); |
|
4108 |
Flags flags = Flags.ZERO_PAD; |
|
4109 |
sb.append(localizedMagnitude(null, offset, flags, 4, l)); |
|
4110 |
break; |
|
4111 |
} |
|
4112 |
case DateTime.ZONE: { // 'Z' (symbol) |
|
20795 | 4113 |
ZoneId zid = t.query(TemporalQueries.zone()); |
15289 | 4114 |
if (zid == null) { |
4115 |
throw new IllegalFormatConversionException(c, t.getClass()); |
|
4116 |
} |
|
4117 |
if (!(zid instanceof ZoneOffset) && |
|
4118 |
t.isSupported(ChronoField.INSTANT_SECONDS)) { |
|
4119 |
Instant instant = Instant.from(t); |
|
4120 |
sb.append(TimeZone.getTimeZone(zid.getId()) |
|
4121 |
.getDisplayName(zid.getRules().isDaylightSavings(instant), |
|
4122 |
TimeZone.SHORT, |
|
4123 |
(l == null) ? Locale.US : l)); |
|
4124 |
break; |
|
4125 |
} |
|
4126 |
sb.append(zid.getId()); |
|
4127 |
break; |
|
4128 |
} |
|
4129 |
// Date |
|
4130 |
case DateTime.NAME_OF_DAY_ABBREV: // 'a' |
|
4131 |
case DateTime.NAME_OF_DAY: { // 'A' |
|
4132 |
int i = t.get(ChronoField.DAY_OF_WEEK) % 7 + 1; |
|
4133 |
Locale lt = ((l == null) ? Locale.US : l); |
|
4134 |
DateFormatSymbols dfs = DateFormatSymbols.getInstance(lt); |
|
4135 |
if (c == DateTime.NAME_OF_DAY) |
|
4136 |
sb.append(dfs.getWeekdays()[i]); |
|
4137 |
else |
|
4138 |
sb.append(dfs.getShortWeekdays()[i]); |
|
4139 |
break; |
|
4140 |
} |
|
4141 |
case DateTime.NAME_OF_MONTH_ABBREV: // 'b' |
|
4142 |
case DateTime.NAME_OF_MONTH_ABBREV_X: // 'h' -- same b |
|
4143 |
case DateTime.NAME_OF_MONTH: { // 'B' |
|
4144 |
int i = t.get(ChronoField.MONTH_OF_YEAR) - 1; |
|
4145 |
Locale lt = ((l == null) ? Locale.US : l); |
|
4146 |
DateFormatSymbols dfs = DateFormatSymbols.getInstance(lt); |
|
4147 |
if (c == DateTime.NAME_OF_MONTH) |
|
4148 |
sb.append(dfs.getMonths()[i]); |
|
4149 |
else |
|
4150 |
sb.append(dfs.getShortMonths()[i]); |
|
4151 |
break; |
|
4152 |
} |
|
4153 |
case DateTime.CENTURY: // 'C' (00 - 99) |
|
4154 |
case DateTime.YEAR_2: // 'y' (00 - 99) |
|
4155 |
case DateTime.YEAR_4: { // 'Y' (0000 - 9999) |
|
19426
daf0425c0ca6
8022193: java/time/test/java/util/TestFormatter.java failed in th locale.
rriggs
parents:
19196
diff
changeset
|
4156 |
int i = t.get(ChronoField.YEAR_OF_ERA); |
15289 | 4157 |
int size = 2; |
4158 |
switch (c) { |
|
4159 |
case DateTime.CENTURY: |
|
4160 |
i /= 100; |
|
4161 |
break; |
|
4162 |
case DateTime.YEAR_2: |
|
4163 |
i %= 100; |
|
4164 |
break; |
|
4165 |
case DateTime.YEAR_4: |
|
4166 |
size = 4; |
|
4167 |
break; |
|
4168 |
} |
|
4169 |
Flags flags = Flags.ZERO_PAD; |
|
4170 |
sb.append(localizedMagnitude(null, i, flags, size, l)); |
|
4171 |
break; |
|
4172 |
} |
|
4173 |
case DateTime.DAY_OF_MONTH_0: // 'd' (01 - 31) |
|
4174 |
case DateTime.DAY_OF_MONTH: { // 'e' (1 - 31) -- like d |
|
4175 |
int i = t.get(ChronoField.DAY_OF_MONTH); |
|
4176 |
Flags flags = (c == DateTime.DAY_OF_MONTH_0 |
|
4177 |
? Flags.ZERO_PAD |
|
4178 |
: Flags.NONE); |
|
4179 |
sb.append(localizedMagnitude(null, i, flags, 2, l)); |
|
4180 |
break; |
|
4181 |
} |
|
4182 |
case DateTime.DAY_OF_YEAR: { // 'j' (001 - 366) |
|
4183 |
int i = t.get(ChronoField.DAY_OF_YEAR); |
|
4184 |
Flags flags = Flags.ZERO_PAD; |
|
4185 |
sb.append(localizedMagnitude(null, i, flags, 3, l)); |
|
4186 |
break; |
|
4187 |
} |
|
4188 |
case DateTime.MONTH: { // 'm' (01 - 12) |
|
4189 |
int i = t.get(ChronoField.MONTH_OF_YEAR); |
|
4190 |
Flags flags = Flags.ZERO_PAD; |
|
4191 |
sb.append(localizedMagnitude(null, i, flags, 2, l)); |
|
4192 |
break; |
|
4193 |
} |
|
4194 |
||
4195 |
// Composites |
|
4196 |
case DateTime.TIME: // 'T' (24 hour hh:mm:ss - %tH:%tM:%tS) |
|
4197 |
case DateTime.TIME_24_HOUR: { // 'R' (hh:mm same as %H:%M) |
|
4198 |
char sep = ':'; |
|
4199 |
print(sb, t, DateTime.HOUR_OF_DAY_0, l).append(sep); |
|
4200 |
print(sb, t, DateTime.MINUTE, l); |
|
4201 |
if (c == DateTime.TIME) { |
|
4202 |
sb.append(sep); |
|
4203 |
print(sb, t, DateTime.SECOND, l); |
|
4204 |
} |
|
4205 |
break; |
|
4206 |
} |
|
4207 |
case DateTime.TIME_12_HOUR: { // 'r' (hh:mm:ss [AP]M) |
|
4208 |
char sep = ':'; |
|
4209 |
print(sb, t, DateTime.HOUR_0, l).append(sep); |
|
4210 |
print(sb, t, DateTime.MINUTE, l).append(sep); |
|
4211 |
print(sb, t, DateTime.SECOND, l).append(' '); |
|
4212 |
// this may be in wrong place for some locales |
|
4213 |
StringBuilder tsb = new StringBuilder(); |
|
4214 |
print(tsb, t, DateTime.AM_PM, l); |
|
4215 |
sb.append(tsb.toString().toUpperCase(l != null ? l : Locale.US)); |
|
4216 |
break; |
|
4217 |
} |
|
4218 |
case DateTime.DATE_TIME: { // 'c' (Sat Nov 04 12:02:33 EST 1999) |
|
4219 |
char sep = ' '; |
|
4220 |
print(sb, t, DateTime.NAME_OF_DAY_ABBREV, l).append(sep); |
|
4221 |
print(sb, t, DateTime.NAME_OF_MONTH_ABBREV, l).append(sep); |
|
4222 |
print(sb, t, DateTime.DAY_OF_MONTH_0, l).append(sep); |
|
4223 |
print(sb, t, DateTime.TIME, l).append(sep); |
|
4224 |
print(sb, t, DateTime.ZONE, l).append(sep); |
|
4225 |
print(sb, t, DateTime.YEAR_4, l); |
|
4226 |
break; |
|
4227 |
} |
|
4228 |
case DateTime.DATE: { // 'D' (mm/dd/yy) |
|
4229 |
char sep = '/'; |
|
4230 |
print(sb, t, DateTime.MONTH, l).append(sep); |
|
4231 |
print(sb, t, DateTime.DAY_OF_MONTH_0, l).append(sep); |
|
4232 |
print(sb, t, DateTime.YEAR_2, l); |
|
4233 |
break; |
|
4234 |
} |
|
4235 |
case DateTime.ISO_STANDARD_DATE: { // 'F' (%Y-%m-%d) |
|
4236 |
char sep = '-'; |
|
4237 |
print(sb, t, DateTime.YEAR_4, l).append(sep); |
|
4238 |
print(sb, t, DateTime.MONTH, l).append(sep); |
|
4239 |
print(sb, t, DateTime.DAY_OF_MONTH_0, l); |
|
4240 |
break; |
|
4241 |
} |
|
4242 |
default: |
|
4243 |
assert false; |
|
4244 |
} |
|
4245 |
} catch (DateTimeException x) { |
|
4246 |
throw new IllegalFormatConversionException(c, t.getClass()); |
|
4247 |
} |
|
4248 |
return sb; |
|
4249 |
} |
|
4250 |
||
2 | 4251 |
// -- Methods to support throwing exceptions -- |
4252 |
||
4253 |
private void failMismatch(Flags f, char c) { |
|
4254 |
String fs = f.toString(); |
|
4255 |
throw new FormatFlagsConversionMismatchException(fs, c); |
|
4256 |
} |
|
4257 |
||
4258 |
private void failConversion(char c, Object arg) { |
|
4259 |
throw new IllegalFormatConversionException(c, arg.getClass()); |
|
4260 |
} |
|
4261 |
||
4262 |
private char getZero(Locale l) { |
|
4263 |
if ((l != null) && !l.equals(locale())) { |
|
4264 |
DecimalFormatSymbols dfs = DecimalFormatSymbols.getInstance(l); |
|
4265 |
return dfs.getZeroDigit(); |
|
4266 |
} |
|
4267 |
return zero; |
|
4268 |
} |
|
4269 |
||
26733 | 4270 |
private StringBuilder localizedMagnitude(StringBuilder sb, |
4271 |
long value, Flags f, int width, Locale l) { |
|
4272 |
return localizedMagnitude(sb, Long.toString(value, 10), 0, f, width, l); |
|
2 | 4273 |
} |
4274 |
||
26733 | 4275 |
private StringBuilder localizedMagnitude(StringBuilder sb, |
4276 |
CharSequence value, final int offset, Flags f, int width, |
|
4277 |
Locale l) { |
|
4278 |
if (sb == null) { |
|
2 | 4279 |
sb = new StringBuilder(); |
26733 | 4280 |
} |
2 | 4281 |
int begin = sb.length(); |
4282 |
||
4283 |
char zero = getZero(l); |
|
4284 |
||
4285 |
// determine localized grouping separator and size |
|
4286 |
char grpSep = '\0'; |
|
4287 |
int grpSize = -1; |
|
4288 |
char decSep = '\0'; |
|
4289 |
||
26733 | 4290 |
int len = value.length(); |
2 | 4291 |
int dot = len; |
26733 | 4292 |
for (int j = offset; j < len; j++) { |
4293 |
if (value.charAt(j) == '.') { |
|
2 | 4294 |
dot = j; |
4295 |
break; |
|
4296 |
} |
|
4297 |
} |
|
4298 |
||
4299 |
if (dot < len) { |
|
4300 |
if (l == null || l.equals(Locale.US)) { |
|
4301 |
decSep = '.'; |
|
4302 |
} else { |
|
4303 |
DecimalFormatSymbols dfs = DecimalFormatSymbols.getInstance(l); |
|
4304 |
decSep = dfs.getDecimalSeparator(); |
|
4305 |
} |
|
4306 |
} |
|
4307 |
||
4308 |
if (f.contains(Flags.GROUP)) { |
|
4309 |
if (l == null || l.equals(Locale.US)) { |
|
4310 |
grpSep = ','; |
|
4311 |
grpSize = 3; |
|
4312 |
} else { |
|
4313 |
DecimalFormatSymbols dfs = DecimalFormatSymbols.getInstance(l); |
|
4314 |
grpSep = dfs.getGroupingSeparator(); |
|
4315 |
DecimalFormat df = (DecimalFormat) NumberFormat.getIntegerInstance(l); |
|
4316 |
grpSize = df.getGroupingSize(); |
|
4317 |
} |
|
4318 |
} |
|
4319 |
||
4320 |
// localize the digits inserting group separators as necessary |
|
26733 | 4321 |
for (int j = offset; j < len; j++) { |
2 | 4322 |
if (j == dot) { |
4323 |
sb.append(decSep); |
|
4324 |
// no more group separators after the decimal separator |
|
4325 |
grpSep = '\0'; |
|
4326 |
continue; |
|
4327 |
} |
|
4328 |
||
26733 | 4329 |
char c = value.charAt(j); |
2 | 4330 |
sb.append((char) ((c - '0') + zero)); |
26733 | 4331 |
if (grpSep != '\0' && j != dot - 1 && ((dot - j) % grpSize == 1)) { |
2 | 4332 |
sb.append(grpSep); |
26733 | 4333 |
} |
2 | 4334 |
} |
4335 |
||
4336 |
// apply zero padding |
|
26733 | 4337 |
if (width != -1 && f.contains(Flags.ZERO_PAD)) { |
4338 |
for (int k = sb.length(); k < width; k++) { |
|
2 | 4339 |
sb.insert(begin, zero); |
26733 | 4340 |
} |
4341 |
} |
|
2 | 4342 |
|
4343 |
return sb; |
|
4344 |
} |
|
26733 | 4345 |
|
4346 |
// Specialized localization of exponents, where the source value can only |
|
4347 |
// contain characters '0' through '9', starting at index offset, and no |
|
4348 |
// group separators is added for any locale. |
|
4349 |
private void localizedMagnitudeExp(StringBuilder sb, char[] value, |
|
4350 |
final int offset, Locale l) { |
|
4351 |
char zero = getZero(l); |
|
4352 |
||
4353 |
int len = value.length; |
|
4354 |
for (int j = offset; j < len; j++) { |
|
4355 |
char c = value[j]; |
|
4356 |
sb.append((char) ((c - '0') + zero)); |
|
4357 |
} |
|
4358 |
} |
|
2 | 4359 |
} |
4360 |
||
4361 |
private static class Flags { |
|
4362 |
private int flags; |
|
4363 |
||
4364 |
static final Flags NONE = new Flags(0); // '' |
|
4365 |
||
4366 |
// duplicate declarations from Formattable.java |
|
4367 |
static final Flags LEFT_JUSTIFY = new Flags(1<<0); // '-' |
|
4368 |
static final Flags UPPERCASE = new Flags(1<<1); // '^' |
|
4369 |
static final Flags ALTERNATE = new Flags(1<<2); // '#' |
|
4370 |
||
4371 |
// numerics |
|
4372 |
static final Flags PLUS = new Flags(1<<3); // '+' |
|
4373 |
static final Flags LEADING_SPACE = new Flags(1<<4); // ' ' |
|
4374 |
static final Flags ZERO_PAD = new Flags(1<<5); // '0' |
|
4375 |
static final Flags GROUP = new Flags(1<<6); // ',' |
|
4376 |
static final Flags PARENTHESES = new Flags(1<<7); // '(' |
|
4377 |
||
4378 |
// indexing |
|
4379 |
static final Flags PREVIOUS = new Flags(1<<8); // '<' |
|
4380 |
||
4381 |
private Flags(int f) { |
|
4382 |
flags = f; |
|
4383 |
} |
|
4384 |
||
4385 |
public int valueOf() { |
|
4386 |
return flags; |
|
4387 |
} |
|
4388 |
||
4389 |
public boolean contains(Flags f) { |
|
4390 |
return (flags & f.valueOf()) == f.valueOf(); |
|
4391 |
} |
|
4392 |
||
4393 |
public Flags dup() { |
|
4394 |
return new Flags(flags); |
|
4395 |
} |
|
4396 |
||
4397 |
private Flags add(Flags f) { |
|
4398 |
flags |= f.valueOf(); |
|
4399 |
return this; |
|
4400 |
} |
|
4401 |
||
4402 |
public Flags remove(Flags f) { |
|
4403 |
flags &= ~f.valueOf(); |
|
4404 |
return this; |
|
4405 |
} |
|
4406 |
||
26733 | 4407 |
public static Flags parse(String s, int start, int end) { |
2 | 4408 |
Flags f = new Flags(0); |
26733 | 4409 |
for (int i = start; i < end; i++) { |
4410 |
char c = s.charAt(i); |
|
22078
bdec5d53e98c
8030851: Update code in java.util to use newer language features
psandoz
parents:
21368
diff
changeset
|
4411 |
Flags v = parse(c); |
2 | 4412 |
if (f.contains(v)) |
4413 |
throw new DuplicateFormatFlagsException(v.toString()); |
|
4414 |
f.add(v); |
|
4415 |
} |
|
4416 |
return f; |
|
4417 |
} |
|
4418 |
||
4419 |
// parse those flags which may be provided by users |
|
4420 |
private static Flags parse(char c) { |
|
4421 |
switch (c) { |
|
4422 |
case '-': return LEFT_JUSTIFY; |
|
4423 |
case '#': return ALTERNATE; |
|
4424 |
case '+': return PLUS; |
|
4425 |
case ' ': return LEADING_SPACE; |
|
4426 |
case '0': return ZERO_PAD; |
|
4427 |
case ',': return GROUP; |
|
4428 |
case '(': return PARENTHESES; |
|
4429 |
case '<': return PREVIOUS; |
|
4430 |
default: |
|
4431 |
throw new UnknownFormatFlagsException(String.valueOf(c)); |
|
4432 |
} |
|
4433 |
} |
|
4434 |
||
1939
5153d540b7a8
6799343: (fmt) java.util.Formatter uses plainlink instead of linkplain
darcy
parents:
1823
diff
changeset
|
4435 |
// Returns a string representation of the current {@code Flags}. |
2 | 4436 |
public static String toString(Flags f) { |
4437 |
return f.toString(); |
|
4438 |
} |
|
4439 |
||
4440 |
public String toString() { |
|
4441 |
StringBuilder sb = new StringBuilder(); |
|
4442 |
if (contains(LEFT_JUSTIFY)) sb.append('-'); |
|
4443 |
if (contains(UPPERCASE)) sb.append('^'); |
|
4444 |
if (contains(ALTERNATE)) sb.append('#'); |
|
4445 |
if (contains(PLUS)) sb.append('+'); |
|
4446 |
if (contains(LEADING_SPACE)) sb.append(' '); |
|
4447 |
if (contains(ZERO_PAD)) sb.append('0'); |
|
4448 |
if (contains(GROUP)) sb.append(','); |
|
4449 |
if (contains(PARENTHESES)) sb.append('('); |
|
4450 |
if (contains(PREVIOUS)) sb.append('<'); |
|
4451 |
return sb.toString(); |
|
4452 |
} |
|
4453 |
} |
|
4454 |
||
4455 |
private static class Conversion { |
|
4456 |
// Byte, Short, Integer, Long, BigInteger |
|
4457 |
// (and associated primitives due to autoboxing) |
|
4458 |
static final char DECIMAL_INTEGER = 'd'; |
|
4459 |
static final char OCTAL_INTEGER = 'o'; |
|
4460 |
static final char HEXADECIMAL_INTEGER = 'x'; |
|
4461 |
static final char HEXADECIMAL_INTEGER_UPPER = 'X'; |
|
4462 |
||
4463 |
// Float, Double, BigDecimal |
|
4464 |
// (and associated primitives due to autoboxing) |
|
4465 |
static final char SCIENTIFIC = 'e'; |
|
4466 |
static final char SCIENTIFIC_UPPER = 'E'; |
|
4467 |
static final char GENERAL = 'g'; |
|
4468 |
static final char GENERAL_UPPER = 'G'; |
|
4469 |
static final char DECIMAL_FLOAT = 'f'; |
|
4470 |
static final char HEXADECIMAL_FLOAT = 'a'; |
|
4471 |
static final char HEXADECIMAL_FLOAT_UPPER = 'A'; |
|
4472 |
||
4473 |
// Character, Byte, Short, Integer |
|
4474 |
// (and associated primitives due to autoboxing) |
|
4475 |
static final char CHARACTER = 'c'; |
|
4476 |
static final char CHARACTER_UPPER = 'C'; |
|
4477 |
||
4478 |
// java.util.Date, java.util.Calendar, long |
|
4479 |
static final char DATE_TIME = 't'; |
|
4480 |
static final char DATE_TIME_UPPER = 'T'; |
|
4481 |
||
4482 |
// if (arg.TYPE != boolean) return boolean |
|
4483 |
// if (arg != null) return true; else return false; |
|
4484 |
static final char BOOLEAN = 'b'; |
|
4485 |
static final char BOOLEAN_UPPER = 'B'; |
|
4486 |
// if (arg instanceof Formattable) arg.formatTo() |
|
4487 |
// else arg.toString(); |
|
4488 |
static final char STRING = 's'; |
|
4489 |
static final char STRING_UPPER = 'S'; |
|
4490 |
// arg.hashCode() |
|
4491 |
static final char HASHCODE = 'h'; |
|
4492 |
static final char HASHCODE_UPPER = 'H'; |
|
4493 |
||
4494 |
static final char LINE_SEPARATOR = 'n'; |
|
4495 |
static final char PERCENT_SIGN = '%'; |
|
4496 |
||
4497 |
static boolean isValid(char c) { |
|
4498 |
return (isGeneral(c) || isInteger(c) || isFloat(c) || isText(c) |
|
4499 |
|| c == 't' || isCharacter(c)); |
|
4500 |
} |
|
4501 |
||
4502 |
// Returns true iff the Conversion is applicable to all objects. |
|
4503 |
static boolean isGeneral(char c) { |
|
4504 |
switch (c) { |
|
4505 |
case BOOLEAN: |
|
4506 |
case BOOLEAN_UPPER: |
|
4507 |
case STRING: |
|
4508 |
case STRING_UPPER: |
|
4509 |
case HASHCODE: |
|
4510 |
case HASHCODE_UPPER: |
|
4511 |
return true; |
|
4512 |
default: |
|
4513 |
return false; |
|
4514 |
} |
|
4515 |
} |
|
4516 |
||
4517 |
// Returns true iff the Conversion is applicable to character. |
|
4518 |
static boolean isCharacter(char c) { |
|
4519 |
switch (c) { |
|
4520 |
case CHARACTER: |
|
4521 |
case CHARACTER_UPPER: |
|
4522 |
return true; |
|
4523 |
default: |
|
4524 |
return false; |
|
4525 |
} |
|
4526 |
} |
|
4527 |
||
4528 |
// Returns true iff the Conversion is an integer type. |
|
4529 |
static boolean isInteger(char c) { |
|
4530 |
switch (c) { |
|
4531 |
case DECIMAL_INTEGER: |
|
4532 |
case OCTAL_INTEGER: |
|
4533 |
case HEXADECIMAL_INTEGER: |
|
4534 |
case HEXADECIMAL_INTEGER_UPPER: |
|
4535 |
return true; |
|
4536 |
default: |
|
4537 |
return false; |
|
4538 |
} |
|
4539 |
} |
|
4540 |
||
4541 |
// Returns true iff the Conversion is a floating-point type. |
|
4542 |
static boolean isFloat(char c) { |
|
4543 |
switch (c) { |
|
4544 |
case SCIENTIFIC: |
|
4545 |
case SCIENTIFIC_UPPER: |
|
4546 |
case GENERAL: |
|
4547 |
case GENERAL_UPPER: |
|
4548 |
case DECIMAL_FLOAT: |
|
4549 |
case HEXADECIMAL_FLOAT: |
|
4550 |
case HEXADECIMAL_FLOAT_UPPER: |
|
4551 |
return true; |
|
4552 |
default: |
|
4553 |
return false; |
|
4554 |
} |
|
4555 |
} |
|
4556 |
||
4557 |
// Returns true iff the Conversion does not require an argument |
|
4558 |
static boolean isText(char c) { |
|
4559 |
switch (c) { |
|
4560 |
case LINE_SEPARATOR: |
|
4561 |
case PERCENT_SIGN: |
|
4562 |
return true; |
|
4563 |
default: |
|
4564 |
return false; |
|
4565 |
} |
|
4566 |
} |
|
4567 |
} |
|
4568 |
||
4569 |
private static class DateTime { |
|
4570 |
static final char HOUR_OF_DAY_0 = 'H'; // (00 - 23) |
|
4571 |
static final char HOUR_0 = 'I'; // (01 - 12) |
|
4572 |
static final char HOUR_OF_DAY = 'k'; // (0 - 23) -- like H |
|
4573 |
static final char HOUR = 'l'; // (1 - 12) -- like I |
|
4574 |
static final char MINUTE = 'M'; // (00 - 59) |
|
4575 |
static final char NANOSECOND = 'N'; // (000000000 - 999999999) |
|
4576 |
static final char MILLISECOND = 'L'; // jdk, not in gnu (000 - 999) |
|
4577 |
static final char MILLISECOND_SINCE_EPOCH = 'Q'; // (0 - 99...?) |
|
4578 |
static final char AM_PM = 'p'; // (am or pm) |
|
4579 |
static final char SECONDS_SINCE_EPOCH = 's'; // (0 - 99...?) |
|
4580 |
static final char SECOND = 'S'; // (00 - 60 - leap second) |
|
4581 |
static final char TIME = 'T'; // (24 hour hh:mm:ss) |
|
4582 |
static final char ZONE_NUMERIC = 'z'; // (-1200 - +1200) - ls minus? |
|
4583 |
static final char ZONE = 'Z'; // (symbol) |
|
4584 |
||
4585 |
// Date |
|
4586 |
static final char NAME_OF_DAY_ABBREV = 'a'; // 'a' |
|
4587 |
static final char NAME_OF_DAY = 'A'; // 'A' |
|
4588 |
static final char NAME_OF_MONTH_ABBREV = 'b'; // 'b' |
|
4589 |
static final char NAME_OF_MONTH = 'B'; // 'B' |
|
4590 |
static final char CENTURY = 'C'; // (00 - 99) |
|
4591 |
static final char DAY_OF_MONTH_0 = 'd'; // (01 - 31) |
|
4592 |
static final char DAY_OF_MONTH = 'e'; // (1 - 31) -- like d |
|
4593 |
// * static final char ISO_WEEK_OF_YEAR_2 = 'g'; // cross %y %V |
|
4594 |
// * static final char ISO_WEEK_OF_YEAR_4 = 'G'; // cross %Y %V |
|
4595 |
static final char NAME_OF_MONTH_ABBREV_X = 'h'; // -- same b |
|
4596 |
static final char DAY_OF_YEAR = 'j'; // (001 - 366) |
|
4597 |
static final char MONTH = 'm'; // (01 - 12) |
|
4598 |
// * static final char DAY_OF_WEEK_1 = 'u'; // (1 - 7) Monday |
|
4599 |
// * static final char WEEK_OF_YEAR_SUNDAY = 'U'; // (0 - 53) Sunday+ |
|
4600 |
// * static final char WEEK_OF_YEAR_MONDAY_01 = 'V'; // (01 - 53) Monday+ |
|
4601 |
// * static final char DAY_OF_WEEK_0 = 'w'; // (0 - 6) Sunday |
|
4602 |
// * static final char WEEK_OF_YEAR_MONDAY = 'W'; // (00 - 53) Monday |
|
4603 |
static final char YEAR_2 = 'y'; // (00 - 99) |
|
4604 |
static final char YEAR_4 = 'Y'; // (0000 - 9999) |
|
4605 |
||
4606 |
// Composites |
|
4607 |
static final char TIME_12_HOUR = 'r'; // (hh:mm:ss [AP]M) |
|
4608 |
static final char TIME_24_HOUR = 'R'; // (hh:mm same as %H:%M) |
|
4609 |
// * static final char LOCALE_TIME = 'X'; // (%H:%M:%S) - parse format? |
|
4610 |
static final char DATE_TIME = 'c'; |
|
4611 |
// (Sat Nov 04 12:02:33 EST 1999) |
|
4612 |
static final char DATE = 'D'; // (mm/dd/yy) |
|
4613 |
static final char ISO_STANDARD_DATE = 'F'; // (%Y-%m-%d) |
|
4614 |
// * static final char LOCALE_DATE = 'x'; // (mm/dd/yy) |
|
4615 |
||
4616 |
static boolean isValid(char c) { |
|
4617 |
switch (c) { |
|
4618 |
case HOUR_OF_DAY_0: |
|
4619 |
case HOUR_0: |
|
4620 |
case HOUR_OF_DAY: |
|
4621 |
case HOUR: |
|
4622 |
case MINUTE: |
|
4623 |
case NANOSECOND: |
|
4624 |
case MILLISECOND: |
|
4625 |
case MILLISECOND_SINCE_EPOCH: |
|
4626 |
case AM_PM: |
|
4627 |
case SECONDS_SINCE_EPOCH: |
|
4628 |
case SECOND: |
|
4629 |
case TIME: |
|
4630 |
case ZONE_NUMERIC: |
|
4631 |
case ZONE: |
|
4632 |
||
4633 |
// Date |
|
4634 |
case NAME_OF_DAY_ABBREV: |
|
4635 |
case NAME_OF_DAY: |
|
4636 |
case NAME_OF_MONTH_ABBREV: |
|
4637 |
case NAME_OF_MONTH: |
|
4638 |
case CENTURY: |
|
4639 |
case DAY_OF_MONTH_0: |
|
4640 |
case DAY_OF_MONTH: |
|
4641 |
// * case ISO_WEEK_OF_YEAR_2: |
|
4642 |
// * case ISO_WEEK_OF_YEAR_4: |
|
4643 |
case NAME_OF_MONTH_ABBREV_X: |
|
4644 |
case DAY_OF_YEAR: |
|
4645 |
case MONTH: |
|
4646 |
// * case DAY_OF_WEEK_1: |
|
4647 |
// * case WEEK_OF_YEAR_SUNDAY: |
|
4648 |
// * case WEEK_OF_YEAR_MONDAY_01: |
|
4649 |
// * case DAY_OF_WEEK_0: |
|
4650 |
// * case WEEK_OF_YEAR_MONDAY: |
|
4651 |
case YEAR_2: |
|
4652 |
case YEAR_4: |
|
4653 |
||
4654 |
// Composites |
|
4655 |
case TIME_12_HOUR: |
|
4656 |
case TIME_24_HOUR: |
|
4657 |
// * case LOCALE_TIME: |
|
4658 |
case DATE_TIME: |
|
4659 |
case DATE: |
|
4660 |
case ISO_STANDARD_DATE: |
|
4661 |
// * case LOCALE_DATE: |
|
4662 |
return true; |
|
4663 |
default: |
|
4664 |
return false; |
|
4665 |
} |
|
4666 |
} |
|
4667 |
} |
|
4668 |
} |