1 /*
2 * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
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
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
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 *
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.
24 */
25
26 /*
27 * (C) Copyright Taligent, Inc. 1996, 1997 - All Rights Reserved
28 * (C) Copyright IBM Corp. 1996 - 1998 - All Rights Reserved
29 *
30 * The original version of this source code and documentation is copyrighted
31 * and owned by Taligent, Inc., a wholly-owned subsidiary of IBM. These
32 * materials are provided under terms of a License Agreement between Taligent
33 * and Sun. This technology is protected by multiple US and International
34 * patents. This notice and attribution to Taligent may not be removed.
35 * Taligent is a registered trademark of Taligent, Inc.
36 *
37 */
38
39 package java.text;
40
41 import java.io.InvalidObjectException;
42 import java.io.IOException;
43 import java.io.ObjectInputStream;
44 import java.io.ObjectOutputStream;
45 import java.math.BigInteger;
46 import java.math.RoundingMode;
47 import java.text.spi.NumberFormatProvider;
48 import java.util.Currency;
49 import java.util.HashMap;
50 import java.util.Hashtable;
51 import java.util.Locale;
52 import java.util.Map;
53 import java.util.ResourceBundle;
54 import java.util.concurrent.atomic.AtomicInteger;
55 import java.util.concurrent.atomic.AtomicLong;
56 import java.util.spi.LocaleServiceProvider;
57 import sun.util.locale.provider.LocaleProviderAdapter;
58 import sun.util.locale.provider.LocaleServiceProviderPool;
59
60 /**
61 * <code>NumberFormat</code> is the abstract base class for all number
62 * formats. This class provides the interface for formatting and parsing
63 * numbers. <code>NumberFormat</code> also provides methods for determining
64 * which locales have number formats, and what their names are.
65 *
66 * <p>
67 * <code>NumberFormat</code> helps you to format and parse numbers for any locale.
68 * Your code can be completely independent of the locale conventions for
69 * decimal points, thousands-separators, or even the particular decimal
70 * digits used, or whether the number format is even decimal.
71 *
72 * <p>
73 * To format a number for the current Locale, use one of the factory
74 * class methods:
75 * <blockquote>
76 * <pre>{@code
77 * myString = NumberFormat.getInstance().format(myNumber);
78 * }</pre>
79 * </blockquote>
80 * If you are formatting multiple numbers, it is
81 * more efficient to get the format and use it multiple times so that
82 * the system doesn't have to fetch the information about the local
83 * language and country conventions multiple times.
84 * <blockquote>
85 * <pre>{@code
86 * NumberFormat nf = NumberFormat.getInstance();
87 * for (int i = 0; i < myNumber.length; ++i) {
88 * output.println(nf.format(myNumber[i]) + "; ");
89 * }
90 * }</pre>
91 * </blockquote>
92 * To format a number for a different Locale, specify it in the
93 * call to <code>getInstance</code>.
94 * <blockquote>
95 * <pre>{@code
96 * NumberFormat nf = NumberFormat.getInstance(Locale.FRENCH);
97 * }</pre>
98 * </blockquote>
99 * You can also use a <code>NumberFormat</code> to parse numbers:
100 * <blockquote>
101 * <pre>{@code
102 * myNumber = nf.parse(myString);
103 * }</pre>
104 * </blockquote>
105 * Use <code>getInstance</code> or <code>getNumberInstance</code> to get the
106 * normal number format. Use <code>getIntegerInstance</code> to get an
107 * integer number format. Use <code>getCurrencyInstance</code> to get the
108 * currency number format. And use <code>getPercentInstance</code> to get a
109 * format for displaying percentages. With this format, a fraction like
110 * 0.53 is displayed as 53%.
111 *
112 * <p>
113 * You can also control the display of numbers with such methods as
114 * <code>setMinimumFractionDigits</code>.
115 * If you want even more control over the format or parsing,
116 * or want to give your users more control,
117 * you can try casting the <code>NumberFormat</code> you get from the factory methods
118 * to a <code>DecimalFormat</code>. This will work for the vast majority
119 * of locales; just remember to put it in a <code>try</code> block in case you
120 * encounter an unusual one.
121 *
122 * <p>
123 * NumberFormat and DecimalFormat are designed such that some controls
124 * work for formatting and others work for parsing. The following is
125 * the detailed description for each these control methods,
126 * <p>
127 * setParseIntegerOnly : only affects parsing, e.g.
128 * if true, "3456.78" → 3456 (and leaves the parse position just after index 6)
129 * if false, "3456.78" → 3456.78 (and leaves the parse position just after index 8)
130 * This is independent of formatting. If you want to not show a decimal point
131 * where there might be no digits after the decimal point, use
132 * setDecimalSeparatorAlwaysShown.
133 * <p>
134 * setDecimalSeparatorAlwaysShown : only affects formatting, and only where
135 * there might be no digits after the decimal point, such as with a pattern
136 * like "#,##0.##", e.g.,
137 * if true, 3456.00 → "3,456."
138 * if false, 3456.00 → "3456"
139 * This is independent of parsing. If you want parsing to stop at the decimal
140 * point, use setParseIntegerOnly.
141 *
142 * <p>
143 * You can also use forms of the <code>parse</code> and <code>format</code>
144 * methods with <code>ParsePosition</code> and <code>FieldPosition</code> to
145 * allow you to:
146 * <ul>
147 * <li> progressively parse through pieces of a string
148 * <li> align the decimal point and other areas
149 * </ul>
150 * For example, you can align numbers in two ways:
151 * <ol>
152 * <li> If you are using a monospaced font with spacing for alignment,
153 * you can pass the <code>FieldPosition</code> in your format call, with
154 * <code>field</code> = <code>INTEGER_FIELD</code>. On output,
155 * <code>getEndIndex</code> will be set to the offset between the
156 * last character of the integer and the decimal. Add
157 * (desiredSpaceCount - getEndIndex) spaces at the front of the string.
158 *
159 * <li> If you are using proportional fonts,
160 * instead of padding with spaces, measure the width
161 * of the string in pixels from the start to <code>getEndIndex</code>.
162 * Then move the pen by
163 * (desiredPixelWidth - widthToAlignmentPoint) before drawing the text.
164 * It also works where there is no decimal, but possibly additional
165 * characters at the end, e.g., with parentheses in negative
166 * numbers: "(12)" for -12.
167 * </ol>
168 *
169 * <h3><a name="synchronization">Synchronization</a></h3>
170 *
171 * <p>
172 * Number formats are generally not synchronized.
173 * It is recommended to create separate format instances for each thread.
174 * If multiple threads access a format concurrently, it must be synchronized
175 * externally.
176 *
177 * @see DecimalFormat
178 * @see ChoiceFormat
179 * @author Mark Davis
180 * @author Helena Shih
181 */
182 public abstract class NumberFormat extends Format {
183
184 /**
185 * Field constant used to construct a FieldPosition object. Signifies that
186 * the position of the integer part of a formatted number should be returned.
187 * @see java.text.FieldPosition
188 */
189 public static final int INTEGER_FIELD = 0;
190
191 /**
192 * Field constant used to construct a FieldPosition object. Signifies that
193 * the position of the fraction part of a formatted number should be returned.
194 * @see java.text.FieldPosition
195 */
196 public static final int FRACTION_FIELD = 1;
197
198 /**
199 * Sole constructor. (For invocation by subclass constructors, typically
200 * implicit.)
201 */
202 protected NumberFormat() {
203 }
204
205 /**
206 * Formats a number and appends the resulting text to the given string
207 * buffer.
208 * The number can be of any subclass of {@link java.lang.Number}.
209 * <p>
210 * This implementation extracts the number's value using
211 * {@link java.lang.Number#longValue()} for all integral type values that
212 * can be converted to <code>long</code> without loss of information,
213 * including <code>BigInteger</code> values with a
214 * {@link java.math.BigInteger#bitLength() bit length} of less than 64,
215 * and {@link java.lang.Number#doubleValue()} for all other types. It
216 * then calls
217 * {@link #format(long,java.lang.StringBuffer,java.text.FieldPosition)}
218 * or {@link #format(double,java.lang.StringBuffer,java.text.FieldPosition)}.
219 * This may result in loss of magnitude information and precision for
220 * <code>BigInteger</code> and <code>BigDecimal</code> values.
221 * @param number the number to format
222 * @param toAppendTo the <code>StringBuffer</code> to which the formatted
223 * text is to be appended
224 * @param pos On input: an alignment field, if desired.
225 * On output: the offsets of the alignment field.
226 * @return the value passed in as <code>toAppendTo</code>
227 * @exception IllegalArgumentException if <code>number</code> is
228 * null or not an instance of <code>Number</code>.
229 * @exception NullPointerException if <code>toAppendTo</code> or
230 * <code>pos</code> is null
231 * @exception ArithmeticException if rounding is needed with rounding
232 * mode being set to RoundingMode.UNNECESSARY
233 * @see java.text.FieldPosition
234 */
235 @Override
236 public StringBuffer format(Object number,
237 StringBuffer toAppendTo,
238 FieldPosition pos) {
239 if (number instanceof Long || number instanceof Integer ||
240 number instanceof Short || number instanceof Byte ||
241 number instanceof AtomicInteger || number instanceof AtomicLong ||
242 (number instanceof BigInteger &&
243 ((BigInteger)number).bitLength() < 64)) {
244 return format(((Number)number).longValue(), toAppendTo, pos);
245 } else if (number instanceof Number) {
246 return format(((Number)number).doubleValue(), toAppendTo, pos);
247 } else {
248 throw new IllegalArgumentException("Cannot format given Object as a Number");
249 }
250 }
251
252 /**
253 * Parses text from a string to produce a <code>Number</code>.
254 * <p>
255 * The method attempts to parse text starting at the index given by
256 * <code>pos</code>.
257 * If parsing succeeds, then the index of <code>pos</code> is updated
258 * to the index after the last character used (parsing does not necessarily
259 * use all characters up to the end of the string), and the parsed
260 * number is returned. The updated <code>pos</code> can be used to
261 * indicate the starting point for the next call to this method.
262 * If an error occurs, then the index of <code>pos</code> is not
263 * changed, the error index of <code>pos</code> is set to the index of
264 * the character where the error occurred, and null is returned.
265 * <p>
266 * See the {@link #parse(String, ParsePosition)} method for more information
267 * on number parsing.
268 *
269 * @param source A <code>String</code>, part of which should be parsed.
270 * @param pos A <code>ParsePosition</code> object with index and error
271 * index information as described above.
272 * @return A <code>Number</code> parsed from the string. In case of
273 * error, returns null.
274 * @exception NullPointerException if <code>pos</code> is null.
275 * @throws NullPointerException if {@code source} is null.
276 */
277 @Override
278 public final Object parseObject(String source, ParsePosition pos) {
279 return parse(source, pos);
280 }
281
282 /**
283 * Specialization of format.
284 *
285 * @param number the double number to format
286 * @return the formatted String
287 * @exception ArithmeticException if rounding is needed with rounding
288 * mode being set to RoundingMode.UNNECESSARY
289 * @see java.text.Format#format
290 */
291 public final String format(double number) {
292 // Use fast-path for double result if that works
293 String result = fastFormat(number);
294 if (result != null)
295 return result;
296
297 return format(number, new StringBuffer(),
298 DontCareFieldPosition.INSTANCE).toString();
299 }
300
301 /*
302 * fastFormat() is supposed to be implemented in concrete subclasses only.
303 * Default implem always returns null.
304 */
305 String fastFormat(double number) { return null; }
306
307 /**
308 * Specialization of format.
309 *
310 * @param number the long number to format
311 * @return the formatted String
312 * @exception ArithmeticException if rounding is needed with rounding
313 * mode being set to RoundingMode.UNNECESSARY
314 * @see java.text.Format#format
315 */
316 public final String format(long number) {
317 return format(number, new StringBuffer(),
318 DontCareFieldPosition.INSTANCE).toString();
319 }
320
321 /**
322 * Specialization of format.
323 *
324 * @param number the double number to format
325 * @param toAppendTo the StringBuffer to which the formatted text is to be
326 * appended
327 * @param pos the field position
328 * @return the formatted StringBuffer
329 * @exception ArithmeticException if rounding is needed with rounding
330 * mode being set to RoundingMode.UNNECESSARY
331 * @see java.text.Format#format
332 */
333 public abstract StringBuffer format(double number,
334 StringBuffer toAppendTo,
335 FieldPosition pos);
336
337 /**
338 * Specialization of format.
339 *
340 * @param number the long number to format
341 * @param toAppendTo the StringBuffer to which the formatted text is to be
342 * appended
343 * @param pos the field position
344 * @return the formatted StringBuffer
345 * @exception ArithmeticException if rounding is needed with rounding
346 * mode being set to RoundingMode.UNNECESSARY
347 * @see java.text.Format#format
348 */
349 public abstract StringBuffer format(long number,
350 StringBuffer toAppendTo,
351 FieldPosition pos);
352
353 /**
354 * Returns a Long if possible (e.g., within the range [Long.MIN_VALUE,
355 * Long.MAX_VALUE] and with no decimals), otherwise a Double.
356 * If IntegerOnly is set, will stop at a decimal
357 * point (or equivalent; e.g., for rational numbers "1 2/3", will stop
358 * after the 1).
359 * Does not throw an exception; if no object can be parsed, index is
360 * unchanged!
361 *
362 * @param source the String to parse
363 * @param parsePosition the parse position
364 * @return the parsed value
365 * @see java.text.NumberFormat#isParseIntegerOnly
366 * @see java.text.Format#parseObject
367 */
368 public abstract Number parse(String source, ParsePosition parsePosition);
369
370 /**
371 * Parses text from the beginning of the given string to produce a number.
372 * The method may not use the entire text of the given string.
373 * <p>
374 * See the {@link #parse(String, ParsePosition)} method for more information
375 * on number parsing.
376 *
377 * @param source A <code>String</code> whose beginning should be parsed.
378 * @return A <code>Number</code> parsed from the string.
379 * @exception ParseException if the beginning of the specified string
380 * cannot be parsed.
381 */
382 public Number parse(String source) throws ParseException {
383 ParsePosition parsePosition = new ParsePosition(0);
384 Number result = parse(source, parsePosition);
385 if (parsePosition.index == 0) {
386 throw new ParseException("Unparseable number: \"" + source + "\"",
387 parsePosition.errorIndex);
388 }
389 return result;
390 }
391
392 /**
393 * Returns true if this format will parse numbers as integers only.
394 * For example in the English locale, with ParseIntegerOnly true, the
395 * string "1234." would be parsed as the integer value 1234 and parsing
396 * would stop at the "." character. Of course, the exact format accepted
397 * by the parse operation is locale dependant and determined by sub-classes
398 * of NumberFormat.
399 *
400 * @return {@code true} if numbers should be parsed as integers only;
401 * {@code false} otherwise
402 */
403 public boolean isParseIntegerOnly() {
404 return parseIntegerOnly;
405 }
406
407 /**
408 * Sets whether or not numbers should be parsed as integers only.
409 *
410 * @param value {@code true} if numbers should be parsed as integers only;
411 * {@code false} otherwise
412 * @see #isParseIntegerOnly
413 */
414 public void setParseIntegerOnly(boolean value) {
415 parseIntegerOnly = value;
416 }
417
418 //============== Locale Stuff =====================
419
420 /**
421 * Returns a general-purpose number format for the current default
422 * {@link java.util.Locale.Category#FORMAT FORMAT} locale.
423 * This is the same as calling
424 * {@link #getNumberInstance() getNumberInstance()}.
425 *
426 * @return the {@code NumberFormat} instance for general-purpose number
427 * formatting
428 */
429 public static final NumberFormat getInstance() {
430 return getInstance(Locale.getDefault(Locale.Category.FORMAT), NUMBERSTYLE);
431 }
432
433 /**
434 * Returns a general-purpose number format for the specified locale.
435 * This is the same as calling
436 * {@link #getNumberInstance(java.util.Locale) getNumberInstance(inLocale)}.
437 *
438 * @param inLocale the desired locale
439 * @return the {@code NumberFormat} instance for general-purpose number
440 * formatting
441 */
442 public static NumberFormat getInstance(Locale inLocale) {
443 return getInstance(inLocale, NUMBERSTYLE);
444 }
445
446 /**
447 * Returns a general-purpose number format for the current default
448 * {@link java.util.Locale.Category#FORMAT FORMAT} locale.
449 * <p>This is equivalent to calling
450 * {@link #getNumberInstance(Locale)
451 * getNumberInstance(Locale.getDefault(Locale.Category.FORMAT))}.
452 *
453 * @return the {@code NumberFormat} instance for general-purpose number
454 * formatting
455 * @see java.util.Locale#getDefault(java.util.Locale.Category)
456 * @see java.util.Locale.Category#FORMAT
457 */
458 public static final NumberFormat getNumberInstance() {
459 return getInstance(Locale.getDefault(Locale.Category.FORMAT), NUMBERSTYLE);
460 }
461
462 /**
463 * Returns a general-purpose number format for the specified locale.
464 *
465 * @param inLocale the desired locale
466 * @return the {@code NumberFormat} instance for general-purpose number
467 * formatting
468 */
469 public static NumberFormat getNumberInstance(Locale inLocale) {
470 return getInstance(inLocale, NUMBERSTYLE);
471 }
472
473 /**
474 * Returns an integer number format for the current default
475 * {@link java.util.Locale.Category#FORMAT FORMAT} locale. The
476 * returned number format is configured to round floating point numbers
477 * to the nearest integer using half-even rounding (see {@link
478 * java.math.RoundingMode#HALF_EVEN RoundingMode.HALF_EVEN}) for formatting,
479 * and to parse only the integer part of an input string (see {@link
480 * #isParseIntegerOnly isParseIntegerOnly}).
481 * <p>This is equivalent to calling
482 * {@link #getIntegerInstance(Locale)
483 * getIntegerInstance(Locale.getDefault(Locale.Category.FORMAT))}.
484 *
485 * @see #getRoundingMode()
486 * @see java.util.Locale#getDefault(java.util.Locale.Category)
487 * @see java.util.Locale.Category#FORMAT
488 * @return a number format for integer values
489 * @since 1.4
490 */
491 public static final NumberFormat getIntegerInstance() {
492 return getInstance(Locale.getDefault(Locale.Category.FORMAT), INTEGERSTYLE);
493 }
494
495 /**
496 * Returns an integer number format for the specified locale. The
497 * returned number format is configured to round floating point numbers
498 * to the nearest integer using half-even rounding (see {@link
499 * java.math.RoundingMode#HALF_EVEN RoundingMode.HALF_EVEN}) for formatting,
500 * and to parse only the integer part of an input string (see {@link
501 * #isParseIntegerOnly isParseIntegerOnly}).
502 *
503 * @param inLocale the desired locale
504 * @see #getRoundingMode()
505 * @return a number format for integer values
506 * @since 1.4
507 */
508 public static NumberFormat getIntegerInstance(Locale inLocale) {
509 return getInstance(inLocale, INTEGERSTYLE);
510 }
511
512 /**
513 * Returns a currency format for the current default
514 * {@link java.util.Locale.Category#FORMAT FORMAT} locale.
515 * <p>This is equivalent to calling
516 * {@link #getCurrencyInstance(Locale)
517 * getCurrencyInstance(Locale.getDefault(Locale.Category.FORMAT))}.
518 *
519 * @return the {@code NumberFormat} instance for currency formatting
520 * @see java.util.Locale#getDefault(java.util.Locale.Category)
521 * @see java.util.Locale.Category#FORMAT
522 */
523 public static final NumberFormat getCurrencyInstance() {
524 return getInstance(Locale.getDefault(Locale.Category.FORMAT), CURRENCYSTYLE);
525 }
526
527 /**
528 * Returns a currency format for the specified locale.
529 *
530 * @param inLocale the desired locale
531 * @return the {@code NumberFormat} instance for currency formatting
532 */
533 public static NumberFormat getCurrencyInstance(Locale inLocale) {
534 return getInstance(inLocale, CURRENCYSTYLE);
535 }
536
537 /**
538 * Returns a percentage format for the current default
539 * {@link java.util.Locale.Category#FORMAT FORMAT} locale.
540 * <p>This is equivalent to calling
541 * {@link #getPercentInstance(Locale)
542 * getPercentInstance(Locale.getDefault(Locale.Category.FORMAT))}.
543 *
544 * @return the {@code NumberFormat} instance for percentage formatting
545 * @see java.util.Locale#getDefault(java.util.Locale.Category)
546 * @see java.util.Locale.Category#FORMAT
547 */
548 public static final NumberFormat getPercentInstance() {
549 return getInstance(Locale.getDefault(Locale.Category.FORMAT), PERCENTSTYLE);
550 }
551
552 /**
553 * Returns a percentage format for the specified locale.
554 *
555 * @param inLocale the desired locale
556 * @return the {@code NumberFormat} instance for percentage formatting
557 */
558 public static NumberFormat getPercentInstance(Locale inLocale) {
559 return getInstance(inLocale, PERCENTSTYLE);
560 }
561
562 /**
563 * Returns a scientific format for the current default locale.
564 */
565 /*public*/ final static NumberFormat getScientificInstance() {
566 return getInstance(Locale.getDefault(Locale.Category.FORMAT), SCIENTIFICSTYLE);
567 }
568
569 /**
570 * Returns a scientific format for the specified locale.
571 *
572 * @param inLocale the desired locale
573 */
574 /*public*/ static NumberFormat getScientificInstance(Locale inLocale) {
575 return getInstance(inLocale, SCIENTIFICSTYLE);
576 }
577
578 /**
579 * Returns an array of all locales for which the
580 * <code>get*Instance</code> methods of this class can return
581 * localized instances.
582 * The returned array represents the union of locales supported by the Java
583 * runtime and by installed
584 * {@link java.text.spi.NumberFormatProvider NumberFormatProvider} implementations.
585 * It must contain at least a <code>Locale</code> instance equal to
586 * {@link java.util.Locale#US Locale.US}.
587 *
588 * @return An array of locales for which localized
589 * <code>NumberFormat</code> instances are available.
590 */
591 public static Locale[] getAvailableLocales() {
592 LocaleServiceProviderPool pool =
593 LocaleServiceProviderPool.getPool(NumberFormatProvider.class);
594 return pool.getAvailableLocales();
595 }
596
597 /**
598 * Overrides hashCode.
599 */
600 @Override
601 public int hashCode() {
602 return maximumIntegerDigits * 37 + maxFractionDigits;
603 // just enough fields for a reasonable distribution
604 }
605
606 /**
607 * Overrides equals.
608 */
609 @Override
610 public boolean equals(Object obj) {
611 if (obj == null) {
612 return false;
613 }
614 if (this == obj) {
615 return true;
616 }
617 if (getClass() != obj.getClass()) {
618 return false;
619 }
620 NumberFormat other = (NumberFormat) obj;
621 return (maximumIntegerDigits == other.maximumIntegerDigits
622 && minimumIntegerDigits == other.minimumIntegerDigits
623 && maximumFractionDigits == other.maximumFractionDigits
624 && minimumFractionDigits == other.minimumFractionDigits
625 && groupingUsed == other.groupingUsed
626 && parseIntegerOnly == other.parseIntegerOnly);
627 }
628
629 /**
630 * Overrides Cloneable.
631 */
632 @Override
633 public Object clone() {
634 NumberFormat other = (NumberFormat) super.clone();
635 return other;
636 }
637
638 /**
639 * Returns true if grouping is used in this format. For example, in the
640 * English locale, with grouping on, the number 1234567 might be formatted
641 * as "1,234,567". The grouping separator as well as the size of each group
642 * is locale dependant and is determined by sub-classes of NumberFormat.
643 *
644 * @return {@code true} if grouping is used;
645 * {@code false} otherwise
646 * @see #setGroupingUsed
647 */
648 public boolean isGroupingUsed() {
649 return groupingUsed;
650 }
651
652 /**
653 * Set whether or not grouping will be used in this format.
654 *
655 * @param newValue {@code true} if grouping is used;
656 * {@code false} otherwise
657 * @see #isGroupingUsed
658 */
659 public void setGroupingUsed(boolean newValue) {
660 groupingUsed = newValue;
661 }
662
663 /**
664 * Returns the maximum number of digits allowed in the integer portion of a
665 * number.
666 *
667 * @return the maximum number of digits
668 * @see #setMaximumIntegerDigits
669 */
670 public int getMaximumIntegerDigits() {
671 return maximumIntegerDigits;
672 }
673
674 /**
675 * Sets the maximum number of digits allowed in the integer portion of a
676 * number. maximumIntegerDigits must be ≥ minimumIntegerDigits. If the
677 * new value for maximumIntegerDigits is less than the current value
678 * of minimumIntegerDigits, then minimumIntegerDigits will also be set to
679 * the new value.
680 *
681 * @param newValue the maximum number of integer digits to be shown; if
682 * less than zero, then zero is used. The concrete subclass may enforce an
683 * upper limit to this value appropriate to the numeric type being formatted.
684 * @see #getMaximumIntegerDigits
685 */
686 public void setMaximumIntegerDigits(int newValue) {
687 maximumIntegerDigits = Math.max(0,newValue);
688 if (minimumIntegerDigits > maximumIntegerDigits) {
689 minimumIntegerDigits = maximumIntegerDigits;
690 }
691 }
692
693 /**
694 * Returns the minimum number of digits allowed in the integer portion of a
695 * number.
696 *
697 * @return the minimum number of digits
698 * @see #setMinimumIntegerDigits
699 */
700 public int getMinimumIntegerDigits() {
701 return minimumIntegerDigits;
702 }
703
704 /**
705 * Sets the minimum number of digits allowed in the integer portion of a
706 * number. minimumIntegerDigits must be ≤ maximumIntegerDigits. If the
707 * new value for minimumIntegerDigits exceeds the current value
708 * of maximumIntegerDigits, then maximumIntegerDigits will also be set to
709 * the new value
710 *
711 * @param newValue the minimum number of integer digits to be shown; if
712 * less than zero, then zero is used. The concrete subclass may enforce an
713 * upper limit to this value appropriate to the numeric type being formatted.
714 * @see #getMinimumIntegerDigits
715 */
716 public void setMinimumIntegerDigits(int newValue) {
717 minimumIntegerDigits = Math.max(0,newValue);
718 if (minimumIntegerDigits > maximumIntegerDigits) {
719 maximumIntegerDigits = minimumIntegerDigits;
720 }
721 }
722
723 /**
724 * Returns the maximum number of digits allowed in the fraction portion of a
725 * number.
726 *
727 * @return the maximum number of digits.
728 * @see #setMaximumFractionDigits
729 */
730 public int getMaximumFractionDigits() {
731 return maximumFractionDigits;
732 }
733
734 /**
735 * Sets the maximum number of digits allowed in the fraction portion of a
736 * number. maximumFractionDigits must be ≥ minimumFractionDigits. If the
737 * new value for maximumFractionDigits is less than the current value
738 * of minimumFractionDigits, then minimumFractionDigits will also be set to
739 * the new value.
740 *
741 * @param newValue the maximum number of fraction digits to be shown; if
742 * less than zero, then zero is used. The concrete subclass may enforce an
743 * upper limit to this value appropriate to the numeric type being formatted.
744 * @see #getMaximumFractionDigits
745 */
746 public void setMaximumFractionDigits(int newValue) {
747 maximumFractionDigits = Math.max(0,newValue);
748 if (maximumFractionDigits < minimumFractionDigits) {
749 minimumFractionDigits = maximumFractionDigits;
750 }
751 }
752
753 /**
754 * Returns the minimum number of digits allowed in the fraction portion of a
755 * number.
756 *
757 * @return the minimum number of digits
758 * @see #setMinimumFractionDigits
759 */
760 public int getMinimumFractionDigits() {
761 return minimumFractionDigits;
762 }
763
764 /**
765 * Sets the minimum number of digits allowed in the fraction portion of a
766 * number. minimumFractionDigits must be ≤ maximumFractionDigits. If the
767 * new value for minimumFractionDigits exceeds the current value
768 * of maximumFractionDigits, then maximumIntegerDigits will also be set to
769 * the new value
770 *
771 * @param newValue the minimum number of fraction digits to be shown; if
772 * less than zero, then zero is used. The concrete subclass may enforce an
773 * upper limit to this value appropriate to the numeric type being formatted.
774 * @see #getMinimumFractionDigits
775 */
776 public void setMinimumFractionDigits(int newValue) {
777 minimumFractionDigits = Math.max(0,newValue);
778 if (maximumFractionDigits < minimumFractionDigits) {
779 maximumFractionDigits = minimumFractionDigits;
780 }
781 }
782
783 /**
784 * Gets the currency used by this number format when formatting
785 * currency values. The initial value is derived in a locale dependent
786 * way. The returned value may be null if no valid
787 * currency could be determined and no currency has been set using
788 * {@link #setCurrency(java.util.Currency) setCurrency}.
789 * <p>
790 * The default implementation throws
791 * <code>UnsupportedOperationException</code>.
792 *
793 * @return the currency used by this number format, or <code>null</code>
794 * @exception UnsupportedOperationException if the number format class
795 * doesn't implement currency formatting
796 * @since 1.4
797 */
798 public Currency getCurrency() {
799 throw new UnsupportedOperationException();
800 }
801
802 /**
803 * Sets the currency used by this number format when formatting
804 * currency values. This does not update the minimum or maximum
805 * number of fraction digits used by the number format.
806 * <p>
807 * The default implementation throws
808 * <code>UnsupportedOperationException</code>.
809 *
810 * @param currency the new currency to be used by this number format
811 * @exception UnsupportedOperationException if the number format class
812 * doesn't implement currency formatting
813 * @exception NullPointerException if <code>currency</code> is null
814 * @since 1.4
815 */
816 public void setCurrency(Currency currency) {
817 throw new UnsupportedOperationException();
818 }
819
820 /**
821 * Gets the {@link java.math.RoundingMode} used in this NumberFormat.
822 * The default implementation of this method in NumberFormat
823 * always throws {@link java.lang.UnsupportedOperationException}.
824 * Subclasses which handle different rounding modes should override
825 * this method.
826 *
827 * @exception UnsupportedOperationException The default implementation
828 * always throws this exception
829 * @return The <code>RoundingMode</code> used for this NumberFormat.
830 * @see #setRoundingMode(RoundingMode)
831 * @since 1.6
832 */
833 public RoundingMode getRoundingMode() {
834 throw new UnsupportedOperationException();
835 }
836
837 /**
838 * Sets the {@link java.math.RoundingMode} used in this NumberFormat.
839 * The default implementation of this method in NumberFormat always
840 * throws {@link java.lang.UnsupportedOperationException}.
841 * Subclasses which handle different rounding modes should override
842 * this method.
843 *
844 * @exception UnsupportedOperationException The default implementation
845 * always throws this exception
846 * @exception NullPointerException if <code>roundingMode</code> is null
847 * @param roundingMode The <code>RoundingMode</code> to be used
848 * @see #getRoundingMode()
849 * @since 1.6
850 */
851 public void setRoundingMode(RoundingMode roundingMode) {
852 throw new UnsupportedOperationException();
853 }
854
855 // =======================privates===============================
856
857 private static NumberFormat getInstance(Locale desiredLocale,
858 int choice) {
859 LocaleProviderAdapter adapter;
860 adapter = LocaleProviderAdapter.getAdapter(NumberFormatProvider.class,
861 desiredLocale);
862 NumberFormat numberFormat = getInstance(adapter, desiredLocale, choice);
863 if (numberFormat == null) {
864 numberFormat = getInstance(LocaleProviderAdapter.forJRE(),
865 desiredLocale, choice);
866 }
867 return numberFormat;
868 }
869
870 private static NumberFormat getInstance(LocaleProviderAdapter adapter,
871 Locale locale, int choice) {
872 NumberFormatProvider provider = adapter.getNumberFormatProvider();
873 NumberFormat numberFormat = null;
874 switch (choice) {
875 case NUMBERSTYLE:
876 numberFormat = provider.getNumberInstance(locale);
877 break;
878 case PERCENTSTYLE:
879 numberFormat = provider.getPercentInstance(locale);
880 break;
881 case CURRENCYSTYLE:
882 numberFormat = provider.getCurrencyInstance(locale);
883 break;
884 case INTEGERSTYLE:
885 numberFormat = provider.getIntegerInstance(locale);
886 break;
887 }
888 return numberFormat;
889 }
890
891 /**
892 * First, read in the default serializable data.
893 *
894 * Then, if <code>serialVersionOnStream</code> is less than 1, indicating that
895 * the stream was written by JDK 1.1,
896 * set the <code>int</code> fields such as <code>maximumIntegerDigits</code>
897 * to be equal to the <code>byte</code> fields such as <code>maxIntegerDigits</code>,
898 * since the <code>int</code> fields were not present in JDK 1.1.
899 * Finally, set serialVersionOnStream back to the maximum allowed value so that
900 * default serialization will work properly if this object is streamed out again.
901 *
902 * <p>If <code>minimumIntegerDigits</code> is greater than
903 * <code>maximumIntegerDigits</code> or <code>minimumFractionDigits</code>
904 * is greater than <code>maximumFractionDigits</code>, then the stream data
905 * is invalid and this method throws an <code>InvalidObjectException</code>.
906 * In addition, if any of these values is negative, then this method throws
907 * an <code>InvalidObjectException</code>.
908 *
909 * @since 1.2
910 */
911 private void readObject(ObjectInputStream stream)
912 throws IOException, ClassNotFoundException
913 {
914 stream.defaultReadObject();
915 if (serialVersionOnStream < 1) {
916 // Didn't have additional int fields, reassign to use them.
917 maximumIntegerDigits = maxIntegerDigits;
918 minimumIntegerDigits = minIntegerDigits;
919 maximumFractionDigits = maxFractionDigits;
920 minimumFractionDigits = minFractionDigits;
921 }
922 if (minimumIntegerDigits > maximumIntegerDigits ||
923 minimumFractionDigits > maximumFractionDigits ||
924 minimumIntegerDigits < 0 || minimumFractionDigits < 0) {
925 throw new InvalidObjectException("Digit count range invalid");
926 }
927 serialVersionOnStream = currentSerialVersion;
928 }
929
930 /**
931 * Write out the default serializable data, after first setting
932 * the <code>byte</code> fields such as <code>maxIntegerDigits</code> to be
933 * equal to the <code>int</code> fields such as <code>maximumIntegerDigits</code>
934 * (or to <code>Byte.MAX_VALUE</code>, whichever is smaller), for compatibility
935 * with the JDK 1.1 version of the stream format.
936 *
937 * @since 1.2
938 */
939 private void writeObject(ObjectOutputStream stream)
940 throws IOException
941 {
942 maxIntegerDigits = (maximumIntegerDigits > Byte.MAX_VALUE) ?
943 Byte.MAX_VALUE : (byte)maximumIntegerDigits;
944 minIntegerDigits = (minimumIntegerDigits > Byte.MAX_VALUE) ?
945 Byte.MAX_VALUE : (byte)minimumIntegerDigits;
946 maxFractionDigits = (maximumFractionDigits > Byte.MAX_VALUE) ?
947 Byte.MAX_VALUE : (byte)maximumFractionDigits;
948 minFractionDigits = (minimumFractionDigits > Byte.MAX_VALUE) ?
949 Byte.MAX_VALUE : (byte)minimumFractionDigits;
950 stream.defaultWriteObject();
951 }
952
953 // Constants used by factory methods to specify a style of format.
954 private static final int NUMBERSTYLE = 0;
955 private static final int CURRENCYSTYLE = 1;
956 private static final int PERCENTSTYLE = 2;
957 private static final int SCIENTIFICSTYLE = 3;
958 private static final int INTEGERSTYLE = 4;
959
960 /**
961 * True if the grouping (i.e. thousands) separator is used when
962 * formatting and parsing numbers.
963 *
964 * @serial
965 * @see #isGroupingUsed
966 */
967 private boolean groupingUsed = true;
968
969 /**
970 * The maximum number of digits allowed in the integer portion of a
971 * number. <code>maxIntegerDigits</code> must be greater than or equal to
972 * <code>minIntegerDigits</code>.
973 * <p>
974 * <strong>Note:</strong> This field exists only for serialization
975 * compatibility with JDK 1.1. In Java platform 2 v1.2 and higher, the new
976 * <code>int</code> field <code>maximumIntegerDigits</code> is used instead.
977 * When writing to a stream, <code>maxIntegerDigits</code> is set to
978 * <code>maximumIntegerDigits</code> or <code>Byte.MAX_VALUE</code>,
979 * whichever is smaller. When reading from a stream, this field is used
980 * only if <code>serialVersionOnStream</code> is less than 1.
981 *
982 * @serial
983 * @see #getMaximumIntegerDigits
984 */
985 private byte maxIntegerDigits = 40;
986
987 /**
988 * The minimum number of digits allowed in the integer portion of a
989 * number. <code>minimumIntegerDigits</code> must be less than or equal to
990 * <code>maximumIntegerDigits</code>.
991 * <p>
992 * <strong>Note:</strong> This field exists only for serialization
993 * compatibility with JDK 1.1. In Java platform 2 v1.2 and higher, the new
994 * <code>int</code> field <code>minimumIntegerDigits</code> is used instead.
995 * When writing to a stream, <code>minIntegerDigits</code> is set to
996 * <code>minimumIntegerDigits</code> or <code>Byte.MAX_VALUE</code>,
997 * whichever is smaller. When reading from a stream, this field is used
998 * only if <code>serialVersionOnStream</code> is less than 1.
999 *
1000 * @serial
1001 * @see #getMinimumIntegerDigits
1002 */
1003 private byte minIntegerDigits = 1;
1004
1005 /**
1006 * The maximum number of digits allowed in the fractional portion of a
1007 * number. <code>maximumFractionDigits</code> must be greater than or equal to
1008 * <code>minimumFractionDigits</code>.
1009 * <p>
1010 * <strong>Note:</strong> This field exists only for serialization
1011 * compatibility with JDK 1.1. In Java platform 2 v1.2 and higher, the new
1012 * <code>int</code> field <code>maximumFractionDigits</code> is used instead.
1013 * When writing to a stream, <code>maxFractionDigits</code> is set to
1014 * <code>maximumFractionDigits</code> or <code>Byte.MAX_VALUE</code>,
1015 * whichever is smaller. When reading from a stream, this field is used
1016 * only if <code>serialVersionOnStream</code> is less than 1.
1017 *
1018 * @serial
1019 * @see #getMaximumFractionDigits
1020 */
1021 private byte maxFractionDigits = 3; // invariant, >= minFractionDigits
1022
1023 /**
1024 * The minimum number of digits allowed in the fractional portion of a
1025 * number. <code>minimumFractionDigits</code> must be less than or equal to
1026 * <code>maximumFractionDigits</code>.
1027 * <p>
1028 * <strong>Note:</strong> This field exists only for serialization
1029 * compatibility with JDK 1.1. In Java platform 2 v1.2 and higher, the new
1030 * <code>int</code> field <code>minimumFractionDigits</code> is used instead.
1031 * When writing to a stream, <code>minFractionDigits</code> is set to
1032 * <code>minimumFractionDigits</code> or <code>Byte.MAX_VALUE</code>,
1033 * whichever is smaller. When reading from a stream, this field is used
1034 * only if <code>serialVersionOnStream</code> is less than 1.
1035 *
1036 * @serial
1037 * @see #getMinimumFractionDigits
1038 */
1039 private byte minFractionDigits = 0;
1040
1041 /**
1042 * True if this format will parse numbers as integers only.
1043 *
1044 * @serial
1045 * @see #isParseIntegerOnly
1046 */
1047 private boolean parseIntegerOnly = false;
1048
1049 // new fields for 1.2. byte is too small for integer digits.
1050
1051 /**
1052 * The maximum number of digits allowed in the integer portion of a
1053 * number. <code>maximumIntegerDigits</code> must be greater than or equal to
1054 * <code>minimumIntegerDigits</code>.
1055 *
1056 * @serial
1057 * @since 1.2
1058 * @see #getMaximumIntegerDigits
1059 */
1060 private int maximumIntegerDigits = 40;
1061
1062 /**
1063 * The minimum number of digits allowed in the integer portion of a
1064 * number. <code>minimumIntegerDigits</code> must be less than or equal to
1065 * <code>maximumIntegerDigits</code>.
1066 *
1067 * @serial
1068 * @since 1.2
1069 * @see #getMinimumIntegerDigits
1070 */
1071 private int minimumIntegerDigits = 1;
1072
1073 /**
1074 * The maximum number of digits allowed in the fractional portion of a
1075 * number. <code>maximumFractionDigits</code> must be greater than or equal to
1076 * <code>minimumFractionDigits</code>.
1077 *
1078 * @serial
1079 * @since 1.2
1080 * @see #getMaximumFractionDigits
1081 */
1082 private int maximumFractionDigits = 3; // invariant, >= minFractionDigits
1083
1084 /**
1085 * The minimum number of digits allowed in the fractional portion of a
1086 * number. <code>minimumFractionDigits</code> must be less than or equal to
1087 * <code>maximumFractionDigits</code>.
1088 *
1089 * @serial
1090 * @since 1.2
1091 * @see #getMinimumFractionDigits
1092 */
1093 private int minimumFractionDigits = 0;
1094
1095 static final int currentSerialVersion = 1;
1096
1097 /**
1098 * Describes the version of <code>NumberFormat</code> present on the stream.
1099 * Possible values are:
1100 * <ul>
1101 * <li><b>0</b> (or uninitialized): the JDK 1.1 version of the stream format.
1102 * In this version, the <code>int</code> fields such as
1103 * <code>maximumIntegerDigits</code> were not present, and the <code>byte</code>
1104 * fields such as <code>maxIntegerDigits</code> are used instead.
1105 *
1106 * <li><b>1</b>: the 1.2 version of the stream format. The values of the
1107 * <code>byte</code> fields such as <code>maxIntegerDigits</code> are ignored,
1108 * and the <code>int</code> fields such as <code>maximumIntegerDigits</code>
1109 * are used instead.
1110 * </ul>
1111 * When streaming out a <code>NumberFormat</code>, the most recent format
1112 * (corresponding to the highest allowable <code>serialVersionOnStream</code>)
1113 * is always written.
1114 *
1115 * @serial
1116 * @since 1.2
1117 */
1118 private int serialVersionOnStream = currentSerialVersion;
1119
1120 // Removed "implements Cloneable" clause. Needs to update serialization
1121 // ID for backward compatibility.
1122 static final long serialVersionUID = -2308460125733713944L;
1123
1124
1125 //
1126 // class for AttributedCharacterIterator attributes
1127 //
1128 /**
1129 * Defines constants that are used as attribute keys in the
1130 * <code>AttributedCharacterIterator</code> returned
1131 * from <code>NumberFormat.formatToCharacterIterator</code> and as
1132 * field identifiers in <code>FieldPosition</code>.
1133 *
1134 * @since 1.4
1135 */
1136 public static class Field extends Format.Field {
1137
1138 // Proclaim serial compatibility with 1.4 FCS
1139 private static final long serialVersionUID = 7494728892700160890L;
1140
1141 // table of all instances in this class, used by readResolve
1142 private static final Map<String, Field> instanceMap = new HashMap<>(11);
1143
1144 /**
1145 * Creates a Field instance with the specified
1146 * name.
1147 *
1148 * @param name Name of the attribute
1149 */
1150 protected Field(String name) {
1151 super(name);
1152 if (this.getClass() == NumberFormat.Field.class) {
1153 instanceMap.put(name, this);
1154 }
1155 }
1156
1157 /**
1158 * Resolves instances being deserialized to the predefined constants.
1159 *
1160 * @throws InvalidObjectException if the constant could not be resolved.
1161 * @return resolved NumberFormat.Field constant
1162 */
1163 @Override
1164 protected Object readResolve() throws InvalidObjectException {
1165 if (this.getClass() != NumberFormat.Field.class) {
1166 throw new InvalidObjectException("subclass didn't correctly implement readResolve");
1167 }
1168
1169 Object instance = instanceMap.get(getName());
1170 if (instance != null) {
1171 return instance;
1172 } else {
1173 throw new InvalidObjectException("unknown attribute name");
1174 }
1175 }
1176
1177 /**
1178 * Constant identifying the integer field.
1179 */
1180 public static final Field INTEGER = new Field("integer");
1181
1182 /**
1183 * Constant identifying the fraction field.
1184 */
1185 public static final Field FRACTION = new Field("fraction");
1186
1187 /**
1188 * Constant identifying the exponent field.
1189 */
1190 public static final Field EXPONENT = new Field("exponent");
1191
1192 /**
1193 * Constant identifying the decimal separator field.
1194 */
1195 public static final Field DECIMAL_SEPARATOR =
1196 new Field("decimal separator");
1197
1198 /**
1199 * Constant identifying the sign field.
1200 */
1201 public static final Field SIGN = new Field("sign");
1202
1203 /**
1204 * Constant identifying the grouping separator field.
1205 */
1206 public static final Field GROUPING_SEPARATOR =
1207 new Field("grouping separator");
1208
1209 /**
1210 * Constant identifying the exponent symbol field.
1211 */
1212 public static final Field EXPONENT_SYMBOL = new
1213 Field("exponent symbol");
1214
1215 /**
1216 * Constant identifying the percent field.
1217 */
1218 public static final Field PERCENT = new Field("percent");
1219
1220 /**
1221 * Constant identifying the permille field.
1222 */
1223 public static final Field PERMILLE = new Field("per mille");
1224
1225 /**
1226 * Constant identifying the currency field.
1227 */
1228 public static final Field CURRENCY = new Field("currency");
1229
1230 /**
1231 * Constant identifying the exponent sign field.
1232 */
1233 public static final Field EXPONENT_SIGN = new Field("exponent sign");
1234 }
1235 }