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