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 * @throws NullPointerException if {@code source} or {@code pos} is null. 275 */ 276 @Override 277 public final Object parseObject(String source, ParsePosition pos) { 278 return parse(source, pos); 279 } 280 281 /** 282 * Specialization of format. 283 * 284 * @param number the double number to format 285 * @return the formatted String 286 * @exception ArithmeticException if rounding is needed with rounding 287 * mode being set to RoundingMode.UNNECESSARY 288 * @see java.text.Format#format 289 */ 290 public final String format(double number) { 291 // Use fast-path for double result if that works 292 String result = fastFormat(number); 293 if (result != null) 294 return result; 295 296 return format(number, new StringBuffer(), 297 DontCareFieldPosition.INSTANCE).toString(); 298 } 299 300 /* 301 * fastFormat() is supposed to be implemented in concrete subclasses only. 302 * Default implem always returns null. 303 */ 304 String fastFormat(double number) { return null; } 305 306 /** 307 * Specialization of format. 308 * 309 * @param number the long number to format 310 * @return the formatted String 311 * @exception ArithmeticException if rounding is needed with rounding 312 * mode being set to RoundingMode.UNNECESSARY 313 * @see java.text.Format#format 314 */ 315 public final String format(long number) { 316 return format(number, new StringBuffer(), 317 DontCareFieldPosition.INSTANCE).toString(); 318 } 319 320 /** 321 * Specialization of format. 322 * 323 * @param number the double number to format 324 * @param toAppendTo the StringBuffer to which the formatted text is to be 325 * appended 326 * @param pos the field position 327 * @return the formatted StringBuffer 328 * @exception ArithmeticException if rounding is needed with rounding 329 * mode being set to RoundingMode.UNNECESSARY 330 * @see java.text.Format#format 331 */ 332 public abstract StringBuffer format(double number, 333 StringBuffer toAppendTo, 334 FieldPosition pos); 335 336 /** 337 * Specialization of format. 338 * 339 * @param number the long number to format 340 * @param toAppendTo the StringBuffer to which the formatted text is to be 341 * appended 342 * @param pos the field position 343 * @return the formatted StringBuffer 344 * @exception ArithmeticException if rounding is needed with rounding 345 * mode being set to RoundingMode.UNNECESSARY 346 * @see java.text.Format#format 347 */ 348 public abstract StringBuffer format(long number, 349 StringBuffer toAppendTo, 350 FieldPosition pos); 351 352 /** 353 * Returns a Long if possible (e.g., within the range [Long.MIN_VALUE, 354 * Long.MAX_VALUE] and with no decimals), otherwise a Double. 355 * If IntegerOnly is set, will stop at a decimal 356 * point (or equivalent; e.g., for rational numbers "1 2/3", will stop 357 * after the 1). 358 * Does not throw an exception; if no object can be parsed, index is 359 * unchanged! 360 * 361 * @param source the String to parse 362 * @param parsePosition the parse position 363 * @return the parsed value 364 * @see java.text.NumberFormat#isParseIntegerOnly 365 * @see java.text.Format#parseObject 366 */ 367 public abstract Number parse(String source, ParsePosition parsePosition); 368 369 /** 370 * Parses text from the beginning of the given string to produce a number. 371 * The method may not use the entire text of the given string. 372 * <p> 373 * See the {@link #parse(String, ParsePosition)} method for more information 374 * on number parsing. 375 * 376 * @param source A <code>String</code> whose beginning should be parsed. 377 * @return A <code>Number</code> parsed from the string. 378 * @exception ParseException if the beginning of the specified string 379 * cannot be parsed. 380 */ 381 public Number parse(String source) throws ParseException { 382 ParsePosition parsePosition = new ParsePosition(0); 383 Number result = parse(source, parsePosition); 384 if (parsePosition.index == 0) { 385 throw new ParseException("Unparseable number: \"" + source + "\"", 386 parsePosition.errorIndex); 387 } 388 return result; 389 } 390 391 /** 392 * Returns true if this format will parse numbers as integers only. 393 * For example in the English locale, with ParseIntegerOnly true, the 394 * string "1234." would be parsed as the integer value 1234 and parsing 395 * would stop at the "." character. Of course, the exact format accepted 396 * by the parse operation is locale dependant and determined by sub-classes 397 * of NumberFormat. 398 * 399 * @return {@code true} if numbers should be parsed as integers only; 400 * {@code false} otherwise 401 */ 402 public boolean isParseIntegerOnly() { 403 return parseIntegerOnly; 404 } 405 406 /** 407 * Sets whether or not numbers should be parsed as integers only. 408 * 409 * @param value {@code true} if numbers should be parsed as integers only; 410 * {@code false} otherwise 411 * @see #isParseIntegerOnly 412 */ 413 public void setParseIntegerOnly(boolean value) { 414 parseIntegerOnly = value; 415 } 416 417 //============== Locale Stuff ===================== 418 419 /** 420 * Returns a general-purpose number format for the current default 421 * {@link java.util.Locale.Category#FORMAT FORMAT} locale. 422 * This is the same as calling 423 * {@link #getNumberInstance() getNumberInstance()}. 424 * 425 * @return the {@code NumberFormat} instance for general-purpose number 426 * formatting 427 */ 428 public static final NumberFormat getInstance() { 429 return getInstance(Locale.getDefault(Locale.Category.FORMAT), NUMBERSTYLE); 430 } 431 432 /** 433 * Returns a general-purpose number format for the specified locale. 434 * This is the same as calling 435 * {@link #getNumberInstance(java.util.Locale) getNumberInstance(inLocale)}. 436 * 437 * @param inLocale the desired locale 438 * @return the {@code NumberFormat} instance for general-purpose number 439 * formatting 440 */ 441 public static NumberFormat getInstance(Locale inLocale) { 442 return getInstance(inLocale, NUMBERSTYLE); 443 } 444 445 /** 446 * Returns a general-purpose number format for the current default 447 * {@link java.util.Locale.Category#FORMAT FORMAT} locale. 448 * <p>This is equivalent to calling 449 * {@link #getNumberInstance(Locale) 450 * getNumberInstance(Locale.getDefault(Locale.Category.FORMAT))}. 451 * 452 * @return the {@code NumberFormat} instance for general-purpose number 453 * formatting 454 * @see java.util.Locale#getDefault(java.util.Locale.Category) 455 * @see java.util.Locale.Category#FORMAT 456 */ 457 public static final NumberFormat getNumberInstance() { 458 return getInstance(Locale.getDefault(Locale.Category.FORMAT), NUMBERSTYLE); 459 } 460 461 /** 462 * Returns a general-purpose number format for the specified locale. 463 * 464 * @param inLocale the desired locale 465 * @return the {@code NumberFormat} instance for general-purpose number 466 * formatting 467 */ 468 public static NumberFormat getNumberInstance(Locale inLocale) { 469 return getInstance(inLocale, NUMBERSTYLE); 470 } 471 472 /** 473 * Returns an integer number format for the current default 474 * {@link java.util.Locale.Category#FORMAT FORMAT} locale. The 475 * returned number format is configured to round floating point numbers 476 * to the nearest integer using half-even rounding (see {@link 477 * java.math.RoundingMode#HALF_EVEN RoundingMode.HALF_EVEN}) for formatting, 478 * and to parse only the integer part of an input string (see {@link 479 * #isParseIntegerOnly isParseIntegerOnly}). 480 * <p>This is equivalent to calling 481 * {@link #getIntegerInstance(Locale) 482 * getIntegerInstance(Locale.getDefault(Locale.Category.FORMAT))}. 483 * 484 * @see #getRoundingMode() 485 * @see java.util.Locale#getDefault(java.util.Locale.Category) 486 * @see java.util.Locale.Category#FORMAT 487 * @return a number format for integer values 488 * @since 1.4 489 */ 490 public static final NumberFormat getIntegerInstance() { 491 return getInstance(Locale.getDefault(Locale.Category.FORMAT), INTEGERSTYLE); 492 } 493 494 /** 495 * Returns an integer number format for the specified locale. The 496 * returned number format is configured to round floating point numbers 497 * to the nearest integer using half-even rounding (see {@link 498 * java.math.RoundingMode#HALF_EVEN RoundingMode.HALF_EVEN}) for formatting, 499 * and to parse only the integer part of an input string (see {@link 500 * #isParseIntegerOnly isParseIntegerOnly}). 501 * 502 * @param inLocale the desired locale 503 * @see #getRoundingMode() 504 * @return a number format for integer values 505 * @since 1.4 506 */ 507 public static NumberFormat getIntegerInstance(Locale inLocale) { 508 return getInstance(inLocale, INTEGERSTYLE); 509 } 510 511 /** 512 * Returns a currency format for the current default 513 * {@link java.util.Locale.Category#FORMAT FORMAT} locale. 514 * <p>This is equivalent to calling 515 * {@link #getCurrencyInstance(Locale) 516 * getCurrencyInstance(Locale.getDefault(Locale.Category.FORMAT))}. 517 * 518 * @return the {@code NumberFormat} instance for currency formatting 519 * @see java.util.Locale#getDefault(java.util.Locale.Category) 520 * @see java.util.Locale.Category#FORMAT 521 */ 522 public static final NumberFormat getCurrencyInstance() { 523 return getInstance(Locale.getDefault(Locale.Category.FORMAT), CURRENCYSTYLE); 524 } 525 526 /** 527 * Returns a currency format for the specified locale. 528 * 529 * @param inLocale the desired locale 530 * @return the {@code NumberFormat} instance for currency formatting 531 */ 532 public static NumberFormat getCurrencyInstance(Locale inLocale) { 533 return getInstance(inLocale, CURRENCYSTYLE); 534 } 535 536 /** 537 * Returns a percentage format for the current default 538 * {@link java.util.Locale.Category#FORMAT FORMAT} locale. 539 * <p>This is equivalent to calling 540 * {@link #getPercentInstance(Locale) 541 * getPercentInstance(Locale.getDefault(Locale.Category.FORMAT))}. 542 * 543 * @return the {@code NumberFormat} instance for percentage formatting 544 * @see java.util.Locale#getDefault(java.util.Locale.Category) 545 * @see java.util.Locale.Category#FORMAT 546 */ 547 public static final NumberFormat getPercentInstance() { 548 return getInstance(Locale.getDefault(Locale.Category.FORMAT), PERCENTSTYLE); 549 } 550 551 /** 552 * Returns a percentage format for the specified locale. 553 * 554 * @param inLocale the desired locale 555 * @return the {@code NumberFormat} instance for percentage formatting 556 */ 557 public static NumberFormat getPercentInstance(Locale inLocale) { 558 return getInstance(inLocale, PERCENTSTYLE); 559 } 560 561 /** 562 * Returns a scientific format for the current default locale. 563 */ 564 /*public*/ final static NumberFormat getScientificInstance() { 565 return getInstance(Locale.getDefault(Locale.Category.FORMAT), SCIENTIFICSTYLE); 566 } 567 568 /** 569 * Returns a scientific format for the specified locale. 570 * 571 * @param inLocale the desired locale 572 */ 573 /*public*/ static NumberFormat getScientificInstance(Locale inLocale) { 574 return getInstance(inLocale, SCIENTIFICSTYLE); 575 } 576 577 /** 578 * Returns an array of all locales for which the 579 * <code>get*Instance</code> methods of this class can return 580 * localized instances. 581 * The returned array represents the union of locales supported by the Java 582 * runtime and by installed 583 * {@link java.text.spi.NumberFormatProvider NumberFormatProvider} implementations. 584 * It must contain at least a <code>Locale</code> instance equal to 585 * {@link java.util.Locale#US Locale.US}. 586 * 587 * @return An array of locales for which localized 588 * <code>NumberFormat</code> instances are available. 589 */ 590 public static Locale[] getAvailableLocales() { 591 LocaleServiceProviderPool pool = 592 LocaleServiceProviderPool.getPool(NumberFormatProvider.class); 593 return pool.getAvailableLocales(); 594 } 595 596 /** 597 * Overrides hashCode. 598 */ 599 @Override 600 public int hashCode() { 601 return maximumIntegerDigits * 37 + maxFractionDigits; 602 // just enough fields for a reasonable distribution 603 } 604 605 /** 606 * Overrides equals. 607 */ 608 @Override 609 public boolean equals(Object obj) { 610 if (obj == null) { 611 return false; 612 } 613 if (this == obj) { 614 return true; 615 } 616 if (getClass() != obj.getClass()) { 617 return false; 618 } 619 NumberFormat other = (NumberFormat) obj; 620 return (maximumIntegerDigits == other.maximumIntegerDigits 621 && minimumIntegerDigits == other.minimumIntegerDigits 622 && maximumFractionDigits == other.maximumFractionDigits 623 && minimumFractionDigits == other.minimumFractionDigits 624 && groupingUsed == other.groupingUsed 625 && parseIntegerOnly == other.parseIntegerOnly); 626 } 627 628 /** 629 * Overrides Cloneable. 630 */ 631 @Override 632 public Object clone() { 633 NumberFormat other = (NumberFormat) super.clone(); 634 return other; 635 } 636 637 /** 638 * Returns true if grouping is used in this format. For example, in the 639 * English locale, with grouping on, the number 1234567 might be formatted 640 * as "1,234,567". The grouping separator as well as the size of each group 641 * is locale dependant and is determined by sub-classes of NumberFormat. 642 * 643 * @return {@code true} if grouping is used; 644 * {@code false} otherwise 645 * @see #setGroupingUsed 646 */ 647 public boolean isGroupingUsed() { 648 return groupingUsed; 649 } 650 651 /** 652 * Set whether or not grouping will be used in this format. 653 * 654 * @param newValue {@code true} if grouping is used; 655 * {@code false} otherwise 656 * @see #isGroupingUsed 657 */ 658 public void setGroupingUsed(boolean newValue) { 659 groupingUsed = newValue; 660 } 661 662 /** 663 * Returns the maximum number of digits allowed in the integer portion of a 664 * number. 665 * 666 * @return the maximum number of digits 667 * @see #setMaximumIntegerDigits 668 */ 669 public int getMaximumIntegerDigits() { 670 return maximumIntegerDigits; 671 } 672 673 /** 674 * Sets the maximum number of digits allowed in the integer portion of a 675 * number. maximumIntegerDigits must be ≥ minimumIntegerDigits. If the 676 * new value for maximumIntegerDigits is less than the current value 677 * of minimumIntegerDigits, then minimumIntegerDigits will also be set to 678 * the new value. 679 * 680 * @param newValue the maximum number of integer digits to be shown; if 681 * less than zero, then zero is used. The concrete subclass may enforce an 682 * upper limit to this value appropriate to the numeric type being formatted. 683 * @see #getMaximumIntegerDigits 684 */ 685 public void setMaximumIntegerDigits(int newValue) { 686 maximumIntegerDigits = Math.max(0,newValue); 687 if (minimumIntegerDigits > maximumIntegerDigits) { 688 minimumIntegerDigits = maximumIntegerDigits; 689 } 690 } 691 692 /** 693 * Returns the minimum number of digits allowed in the integer portion of a 694 * number. 695 * 696 * @return the minimum number of digits 697 * @see #setMinimumIntegerDigits 698 */ 699 public int getMinimumIntegerDigits() { 700 return minimumIntegerDigits; 701 } 702 703 /** 704 * Sets the minimum number of digits allowed in the integer portion of a 705 * number. minimumIntegerDigits must be ≤ maximumIntegerDigits. If the 706 * new value for minimumIntegerDigits exceeds the current value 707 * of maximumIntegerDigits, then maximumIntegerDigits will also be set to 708 * the new value 709 * 710 * @param newValue the minimum number of integer digits to be shown; if 711 * less than zero, then zero is used. The concrete subclass may enforce an 712 * upper limit to this value appropriate to the numeric type being formatted. 713 * @see #getMinimumIntegerDigits 714 */ 715 public void setMinimumIntegerDigits(int newValue) { 716 minimumIntegerDigits = Math.max(0,newValue); 717 if (minimumIntegerDigits > maximumIntegerDigits) { 718 maximumIntegerDigits = minimumIntegerDigits; 719 } 720 } 721 722 /** 723 * Returns the maximum number of digits allowed in the fraction portion of a 724 * number. 725 * 726 * @return the maximum number of digits. 727 * @see #setMaximumFractionDigits 728 */ 729 public int getMaximumFractionDigits() { 730 return maximumFractionDigits; 731 } 732 733 /** 734 * Sets the maximum number of digits allowed in the fraction portion of a 735 * number. maximumFractionDigits must be ≥ minimumFractionDigits. If the 736 * new value for maximumFractionDigits is less than the current value 737 * of minimumFractionDigits, then minimumFractionDigits will also be set to 738 * the new value. 739 * 740 * @param newValue the maximum number of fraction digits to be shown; if 741 * less than zero, then zero is used. The concrete subclass may enforce an 742 * upper limit to this value appropriate to the numeric type being formatted. 743 * @see #getMaximumFractionDigits 744 */ 745 public void setMaximumFractionDigits(int newValue) { 746 maximumFractionDigits = Math.max(0,newValue); 747 if (maximumFractionDigits < minimumFractionDigits) { 748 minimumFractionDigits = maximumFractionDigits; 749 } 750 } 751 752 /** 753 * Returns the minimum number of digits allowed in the fraction portion of a 754 * number. 755 * 756 * @return the minimum number of digits 757 * @see #setMinimumFractionDigits 758 */ 759 public int getMinimumFractionDigits() { 760 return minimumFractionDigits; 761 } 762 763 /** 764 * Sets the minimum number of digits allowed in the fraction portion of a 765 * number. minimumFractionDigits must be ≤ maximumFractionDigits. If the 766 * new value for minimumFractionDigits exceeds the current value 767 * of maximumFractionDigits, then maximumIntegerDigits will also be set to 768 * the new value 769 * 770 * @param newValue the minimum number of fraction digits to be shown; if 771 * less than zero, then zero is used. The concrete subclass may enforce an 772 * upper limit to this value appropriate to the numeric type being formatted. 773 * @see #getMinimumFractionDigits 774 */ 775 public void setMinimumFractionDigits(int newValue) { 776 minimumFractionDigits = Math.max(0,newValue); 777 if (maximumFractionDigits < minimumFractionDigits) { 778 maximumFractionDigits = minimumFractionDigits; 779 } 780 } 781 782 /** 783 * Gets the currency used by this number format when formatting 784 * currency values. The initial value is derived in a locale dependent 785 * way. The returned value may be null if no valid 786 * currency could be determined and no currency has been set using 787 * {@link #setCurrency(java.util.Currency) setCurrency}. 788 * <p> 789 * The default implementation throws 790 * <code>UnsupportedOperationException</code>. 791 * 792 * @return the currency used by this number format, or <code>null</code> 793 * @exception UnsupportedOperationException if the number format class 794 * doesn't implement currency formatting 795 * @since 1.4 796 */ 797 public Currency getCurrency() { 798 throw new UnsupportedOperationException(); 799 } 800 801 /** 802 * Sets the currency used by this number format when formatting 803 * currency values. This does not update the minimum or maximum 804 * number of fraction digits used by the number format. 805 * <p> 806 * The default implementation throws 807 * <code>UnsupportedOperationException</code>. 808 * 809 * @param currency the new currency to be used by this number format 810 * @exception UnsupportedOperationException if the number format class 811 * doesn't implement currency formatting 812 * @exception NullPointerException if <code>currency</code> is null 813 * @since 1.4 814 */ 815 public void setCurrency(Currency currency) { 816 throw new UnsupportedOperationException(); 817 } 818 819 /** 820 * Gets the {@link java.math.RoundingMode} used in this NumberFormat. 821 * The default implementation of this method in NumberFormat 822 * always throws {@link java.lang.UnsupportedOperationException}. 823 * Subclasses which handle different rounding modes should override 824 * this method. 825 * 826 * @exception UnsupportedOperationException The default implementation 827 * always throws this exception 828 * @return The <code>RoundingMode</code> used for this NumberFormat. 829 * @see #setRoundingMode(RoundingMode) 830 * @since 1.6 831 */ 832 public RoundingMode getRoundingMode() { 833 throw new UnsupportedOperationException(); 834 } 835 836 /** 837 * Sets the {@link java.math.RoundingMode} used in this NumberFormat. 838 * The default implementation of this method in NumberFormat always 839 * throws {@link java.lang.UnsupportedOperationException}. 840 * Subclasses which handle different rounding modes should override 841 * this method. 842 * 843 * @exception UnsupportedOperationException The default implementation 844 * always throws this exception 845 * @exception NullPointerException if <code>roundingMode</code> is null 846 * @param roundingMode The <code>RoundingMode</code> to be used 847 * @see #getRoundingMode() 848 * @since 1.6 849 */ 850 public void setRoundingMode(RoundingMode roundingMode) { 851 throw new UnsupportedOperationException(); 852 } 853 854 // =======================privates=============================== 855 856 private static NumberFormat getInstance(Locale desiredLocale, 857 int choice) { 858 LocaleProviderAdapter adapter; 859 adapter = LocaleProviderAdapter.getAdapter(NumberFormatProvider.class, 860 desiredLocale); 861 NumberFormat numberFormat = getInstance(adapter, desiredLocale, choice); 862 if (numberFormat == null) { 863 numberFormat = getInstance(LocaleProviderAdapter.forJRE(), 864 desiredLocale, choice); 865 } 866 return numberFormat; 867 } 868 869 private static NumberFormat getInstance(LocaleProviderAdapter adapter, 870 Locale locale, int choice) { 871 NumberFormatProvider provider = adapter.getNumberFormatProvider(); 872 NumberFormat numberFormat = null; 873 switch (choice) { 874 case NUMBERSTYLE: 875 numberFormat = provider.getNumberInstance(locale); 876 break; 877 case PERCENTSTYLE: 878 numberFormat = provider.getPercentInstance(locale); 879 break; 880 case CURRENCYSTYLE: 881 numberFormat = provider.getCurrencyInstance(locale); 882 break; 883 case INTEGERSTYLE: 884 numberFormat = provider.getIntegerInstance(locale); 885 break; 886 } 887 return numberFormat; 888 } 889 890 /** 891 * First, read in the default serializable data. 892 * 893 * Then, if <code>serialVersionOnStream</code> is less than 1, indicating that 894 * the stream was written by JDK 1.1, 895 * set the <code>int</code> fields such as <code>maximumIntegerDigits</code> 896 * to be equal to the <code>byte</code> fields such as <code>maxIntegerDigits</code>, 897 * since the <code>int</code> fields were not present in JDK 1.1. 898 * Finally, set serialVersionOnStream back to the maximum allowed value so that 899 * default serialization will work properly if this object is streamed out again. 900 * 901 * <p>If <code>minimumIntegerDigits</code> is greater than 902 * <code>maximumIntegerDigits</code> or <code>minimumFractionDigits</code> 903 * is greater than <code>maximumFractionDigits</code>, then the stream data 904 * is invalid and this method throws an <code>InvalidObjectException</code>. 905 * In addition, if any of these values is negative, then this method throws 906 * an <code>InvalidObjectException</code>. 907 * 908 * @since 1.2 909 */ 910 private void readObject(ObjectInputStream stream) 911 throws IOException, ClassNotFoundException 912 { 913 stream.defaultReadObject(); 914 if (serialVersionOnStream < 1) { 915 // Didn't have additional int fields, reassign to use them. 916 maximumIntegerDigits = maxIntegerDigits; 917 minimumIntegerDigits = minIntegerDigits; 918 maximumFractionDigits = maxFractionDigits; 919 minimumFractionDigits = minFractionDigits; 920 } 921 if (minimumIntegerDigits > maximumIntegerDigits || 922 minimumFractionDigits > maximumFractionDigits || 923 minimumIntegerDigits < 0 || minimumFractionDigits < 0) { 924 throw new InvalidObjectException("Digit count range invalid"); 925 } 926 serialVersionOnStream = currentSerialVersion; 927 } 928 929 /** 930 * Write out the default serializable data, after first setting 931 * the <code>byte</code> fields such as <code>maxIntegerDigits</code> to be 932 * equal to the <code>int</code> fields such as <code>maximumIntegerDigits</code> 933 * (or to <code>Byte.MAX_VALUE</code>, whichever is smaller), for compatibility 934 * with the JDK 1.1 version of the stream format. 935 * 936 * @since 1.2 937 */ 938 private void writeObject(ObjectOutputStream stream) 939 throws IOException 940 { 941 maxIntegerDigits = (maximumIntegerDigits > Byte.MAX_VALUE) ? 942 Byte.MAX_VALUE : (byte)maximumIntegerDigits; 943 minIntegerDigits = (minimumIntegerDigits > Byte.MAX_VALUE) ? 944 Byte.MAX_VALUE : (byte)minimumIntegerDigits; 945 maxFractionDigits = (maximumFractionDigits > Byte.MAX_VALUE) ? 946 Byte.MAX_VALUE : (byte)maximumFractionDigits; 947 minFractionDigits = (minimumFractionDigits > Byte.MAX_VALUE) ? 948 Byte.MAX_VALUE : (byte)minimumFractionDigits; 949 stream.defaultWriteObject(); 950 } 951 952 // Constants used by factory methods to specify a style of format. 953 private static final int NUMBERSTYLE = 0; 954 private static final int CURRENCYSTYLE = 1; 955 private static final int PERCENTSTYLE = 2; 956 private static final int SCIENTIFICSTYLE = 3; 957 private static final int INTEGERSTYLE = 4; 958 959 /** 960 * True if the grouping (i.e. thousands) separator is used when 961 * formatting and parsing numbers. 962 * 963 * @serial 964 * @see #isGroupingUsed 965 */ 966 private boolean groupingUsed = true; 967 968 /** 969 * The maximum number of digits allowed in the integer portion of a 970 * number. <code>maxIntegerDigits</code> must be greater than or equal to 971 * <code>minIntegerDigits</code>. 972 * <p> 973 * <strong>Note:</strong> This field exists only for serialization 974 * compatibility with JDK 1.1. In Java platform 2 v1.2 and higher, the new 975 * <code>int</code> field <code>maximumIntegerDigits</code> is used instead. 976 * When writing to a stream, <code>maxIntegerDigits</code> is set to 977 * <code>maximumIntegerDigits</code> or <code>Byte.MAX_VALUE</code>, 978 * whichever is smaller. When reading from a stream, this field is used 979 * only if <code>serialVersionOnStream</code> is less than 1. 980 * 981 * @serial 982 * @see #getMaximumIntegerDigits 983 */ 984 private byte maxIntegerDigits = 40; 985 986 /** 987 * The minimum number of digits allowed in the integer portion of a 988 * number. <code>minimumIntegerDigits</code> must be less than or equal to 989 * <code>maximumIntegerDigits</code>. 990 * <p> 991 * <strong>Note:</strong> This field exists only for serialization 992 * compatibility with JDK 1.1. In Java platform 2 v1.2 and higher, the new 993 * <code>int</code> field <code>minimumIntegerDigits</code> is used instead. 994 * When writing to a stream, <code>minIntegerDigits</code> is set to 995 * <code>minimumIntegerDigits</code> or <code>Byte.MAX_VALUE</code>, 996 * whichever is smaller. When reading from a stream, this field is used 997 * only if <code>serialVersionOnStream</code> is less than 1. 998 * 999 * @serial 1000 * @see #getMinimumIntegerDigits 1001 */ 1002 private byte minIntegerDigits = 1; 1003 1004 /** 1005 * The maximum number of digits allowed in the fractional portion of a 1006 * number. <code>maximumFractionDigits</code> must be greater than or equal to 1007 * <code>minimumFractionDigits</code>. 1008 * <p> 1009 * <strong>Note:</strong> This field exists only for serialization 1010 * compatibility with JDK 1.1. In Java platform 2 v1.2 and higher, the new 1011 * <code>int</code> field <code>maximumFractionDigits</code> is used instead. 1012 * When writing to a stream, <code>maxFractionDigits</code> is set to 1013 * <code>maximumFractionDigits</code> or <code>Byte.MAX_VALUE</code>, 1014 * whichever is smaller. When reading from a stream, this field is used 1015 * only if <code>serialVersionOnStream</code> is less than 1. 1016 * 1017 * @serial 1018 * @see #getMaximumFractionDigits 1019 */ 1020 private byte maxFractionDigits = 3; // invariant, >= minFractionDigits 1021 1022 /** 1023 * The minimum number of digits allowed in the fractional portion of a 1024 * number. <code>minimumFractionDigits</code> must be less than or equal to 1025 * <code>maximumFractionDigits</code>. 1026 * <p> 1027 * <strong>Note:</strong> This field exists only for serialization 1028 * compatibility with JDK 1.1. In Java platform 2 v1.2 and higher, the new 1029 * <code>int</code> field <code>minimumFractionDigits</code> is used instead. 1030 * When writing to a stream, <code>minFractionDigits</code> is set to 1031 * <code>minimumFractionDigits</code> or <code>Byte.MAX_VALUE</code>, 1032 * whichever is smaller. When reading from a stream, this field is used 1033 * only if <code>serialVersionOnStream</code> is less than 1. 1034 * 1035 * @serial 1036 * @see #getMinimumFractionDigits 1037 */ 1038 private byte minFractionDigits = 0; 1039 1040 /** 1041 * True if this format will parse numbers as integers only. 1042 * 1043 * @serial 1044 * @see #isParseIntegerOnly 1045 */ 1046 private boolean parseIntegerOnly = false; 1047 1048 // new fields for 1.2. byte is too small for integer digits. 1049 1050 /** 1051 * The maximum number of digits allowed in the integer portion of a 1052 * number. <code>maximumIntegerDigits</code> must be greater than or equal to 1053 * <code>minimumIntegerDigits</code>. 1054 * 1055 * @serial 1056 * @since 1.2 1057 * @see #getMaximumIntegerDigits 1058 */ 1059 private int maximumIntegerDigits = 40; 1060 1061 /** 1062 * The minimum number of digits allowed in the integer portion of a 1063 * number. <code>minimumIntegerDigits</code> must be less than or equal to 1064 * <code>maximumIntegerDigits</code>. 1065 * 1066 * @serial 1067 * @since 1.2 1068 * @see #getMinimumIntegerDigits 1069 */ 1070 private int minimumIntegerDigits = 1; 1071 1072 /** 1073 * The maximum number of digits allowed in the fractional portion of a 1074 * number. <code>maximumFractionDigits</code> must be greater than or equal to 1075 * <code>minimumFractionDigits</code>. 1076 * 1077 * @serial 1078 * @since 1.2 1079 * @see #getMaximumFractionDigits 1080 */ 1081 private int maximumFractionDigits = 3; // invariant, >= minFractionDigits 1082 1083 /** 1084 * The minimum number of digits allowed in the fractional portion of a 1085 * number. <code>minimumFractionDigits</code> must be less than or equal to 1086 * <code>maximumFractionDigits</code>. 1087 * 1088 * @serial 1089 * @since 1.2 1090 * @see #getMinimumFractionDigits 1091 */ 1092 private int minimumFractionDigits = 0; 1093 1094 static final int currentSerialVersion = 1; 1095 1096 /** 1097 * Describes the version of <code>NumberFormat</code> present on the stream. 1098 * Possible values are: 1099 * <ul> 1100 * <li><b>0</b> (or uninitialized): the JDK 1.1 version of the stream format. 1101 * In this version, the <code>int</code> fields such as 1102 * <code>maximumIntegerDigits</code> were not present, and the <code>byte</code> 1103 * fields such as <code>maxIntegerDigits</code> are used instead. 1104 * 1105 * <li><b>1</b>: the 1.2 version of the stream format. The values of the 1106 * <code>byte</code> fields such as <code>maxIntegerDigits</code> are ignored, 1107 * and the <code>int</code> fields such as <code>maximumIntegerDigits</code> 1108 * are used instead. 1109 * </ul> 1110 * When streaming out a <code>NumberFormat</code>, the most recent format 1111 * (corresponding to the highest allowable <code>serialVersionOnStream</code>) 1112 * is always written. 1113 * 1114 * @serial 1115 * @since 1.2 1116 */ 1117 private int serialVersionOnStream = currentSerialVersion; 1118 1119 // Removed "implements Cloneable" clause. Needs to update serialization 1120 // ID for backward compatibility. 1121 static final long serialVersionUID = -2308460125733713944L; 1122 1123 1124 // 1125 // class for AttributedCharacterIterator attributes 1126 // 1127 /** 1128 * Defines constants that are used as attribute keys in the 1129 * <code>AttributedCharacterIterator</code> returned 1130 * from <code>NumberFormat.formatToCharacterIterator</code> and as 1131 * field identifiers in <code>FieldPosition</code>. 1132 * 1133 * @since 1.4 1134 */ 1135 public static class Field extends Format.Field { 1136 1137 // Proclaim serial compatibility with 1.4 FCS 1138 private static final long serialVersionUID = 7494728892700160890L; 1139 1140 // table of all instances in this class, used by readResolve 1141 private static final Map<String, Field> instanceMap = new HashMap<>(11); 1142 1143 /** 1144 * Creates a Field instance with the specified 1145 * name. 1146 * 1147 * @param name Name of the attribute 1148 */ 1149 protected Field(String name) { 1150 super(name); 1151 if (this.getClass() == NumberFormat.Field.class) { 1152 instanceMap.put(name, this); 1153 } 1154 } 1155 1156 /** 1157 * Resolves instances being deserialized to the predefined constants. 1158 * 1159 * @throws InvalidObjectException if the constant could not be resolved. 1160 * @return resolved NumberFormat.Field constant 1161 */ 1162 @Override 1163 protected Object readResolve() throws InvalidObjectException { 1164 if (this.getClass() != NumberFormat.Field.class) { 1165 throw new InvalidObjectException("subclass didn't correctly implement readResolve"); 1166 } 1167 1168 Object instance = instanceMap.get(getName()); 1169 if (instance != null) { 1170 return instance; 1171 } else { 1172 throw new InvalidObjectException("unknown attribute name"); 1173 } 1174 } 1175 1176 /** 1177 * Constant identifying the integer field. 1178 */ 1179 public static final Field INTEGER = new Field("integer"); 1180 1181 /** 1182 * Constant identifying the fraction field. 1183 */ 1184 public static final Field FRACTION = new Field("fraction"); 1185 1186 /** 1187 * Constant identifying the exponent field. 1188 */ 1189 public static final Field EXPONENT = new Field("exponent"); 1190 1191 /** 1192 * Constant identifying the decimal separator field. 1193 */ 1194 public static final Field DECIMAL_SEPARATOR = 1195 new Field("decimal separator"); 1196 1197 /** 1198 * Constant identifying the sign field. 1199 */ 1200 public static final Field SIGN = new Field("sign"); 1201 1202 /** 1203 * Constant identifying the grouping separator field. 1204 */ 1205 public static final Field GROUPING_SEPARATOR = 1206 new Field("grouping separator"); 1207 1208 /** 1209 * Constant identifying the exponent symbol field. 1210 */ 1211 public static final Field EXPONENT_SYMBOL = new 1212 Field("exponent symbol"); 1213 1214 /** 1215 * Constant identifying the percent field. 1216 */ 1217 public static final Field PERCENT = new Field("percent"); 1218 1219 /** 1220 * Constant identifying the permille field. 1221 */ 1222 public static final Field PERMILLE = new Field("per mille"); 1223 1224 /** 1225 * Constant identifying the currency field. 1226 */ 1227 public static final Field CURRENCY = new Field("currency"); 1228 1229 /** 1230 * Constant identifying the exponent sign field. 1231 */ 1232 public static final Field EXPONENT_SIGN = new Field("exponent sign"); 1233 } 1234 }