libjava/java/text/NumberFormat.java

   1 /* NumberFormat.java -- Formats and parses numbers
   2    Copyright (C) 1998, 1999, 2000, 2001, 2003, 2004 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package java.text;
  40
  41 import java.io.IOException;
  42 import java.io.InvalidObjectException;
  43 import java.io.ObjectInputStream;
  44 import java.io.ObjectOutputStream;
  45 import java.util.Currency;
  46 import java.util.Locale;
  47 import java.util.MissingResourceException;
  48 import java.util.ResourceBundle;
  49
  50 /**
  51  * This is the abstract superclass of all classes which format and
  52  * parse numeric values such as decimal numbers, integers, currency values,
  53  * and percentages.  These classes perform their parsing and formatting
  54  * in a locale specific manner, accounting for such items as differing
  55  * currency symbols and thousands separators.
  56  * <p>
  57  * To create an instance of a concrete subclass of <code>NumberFormat</code>,
  58  * do not call a class constructor directly.  Instead, use one of the
  59  * static factory methods in this class such as
  60  * <code>getCurrencyInstance</code>.
  61  *
  62  * @author Tom Tromey (tromey@cygnus.com)
  63  * @author Aaron M. Renn (arenn@urbanophile.com)
  64  * @date March 4, 1999
  65  */
  66 /* Written using "Java Class Libraries", 2nd edition, plus online
  67  * API docs for JDK 1.2 from http://www.javasoft.com.
  68  * Status:  Believed complete and correct to 1.2, except getAvailableLocales.
  69  */
  70 public abstract class NumberFormat extends Format implements Cloneable
  71 {
  72   /**
  73    * This is a constant used to create a <code>FieldPosition</code> object
  74    * that will return the integer portion of a formatted number.
  75    */
  76   public static final int INTEGER_FIELD = 0;
  77
  78   /**
  79    * This is a constant used to create a <code>FieldPosition</code> object
  80    * that will return the fractional portion of a formatted number.
  81    */
  82   public static final int FRACTION_FIELD = 1;
  83
  84   public static class Field extends Format.Field
  85   {
  86     static final long serialVersionUID = 7494728892700160890L;
  87
  88     /**
  89      * Attribute set to all characters containing digits of the integer
  90      * part.
  91      */
  92     public static final NumberFormat.Field INTEGER
  93       = new Field("integer");
  94
  95     /**
  96      * Attribute set to all characters containing digits of the fractional
  97      * part.
  98      */
  99     public static final NumberFormat.Field FRACTION
 100       = new Field("fraction");
 101
 102     /**
 103      * Attribute set to all characters containing digits of the exponential
 104      * part.
 105      */
 106     public static final NumberFormat.Field EXPONENT
 107       = new Field("exponent");
 108
 109     /**
 110      * Attribute set to all characters containing a decimal separator.
 111      */
 112     public static final NumberFormat.Field DECIMAL_SEPARATOR
 113       = new Field("decimal separator");
 114
 115     /**
 116      * Attribute set to all characters containing a sign (plus or minus).
 117      */
 118     public static final NumberFormat.Field SIGN
 119       = new Field("sign");
 120
 121     /**
 122      * Attribute set to all characters containing a grouping separator (e.g.
 123      * a comma, a white space,...).
 124      */
 125     public static final NumberFormat.Field GROUPING_SEPARATOR
 126       = new Field("grouping separator");
 127
 128     /**
 129      * Attribute set to all characters containing an exponential symbol (e.g.
 130      * 'E')
 131      */
 132     public static final NumberFormat.Field EXPONENT_SYMBOL
 133       = new Field("exponent symbol");
 134
 135     /**
 136      * Attribute set to all characters containing a percent symbol (e.g. '%')
 137      */
 138     public static final NumberFormat.Field PERCENT
 139       = new Field("percent");
 140
 141     /**
 142      * Attribute set to all characters containing a permille symbol.
 143      */
 144     public static final NumberFormat.Field PERMILLE
 145       = new Field("permille");
 146
 147     /**
 148      * Attribute set to all characters containing the currency unit.
 149      */
 150     public static final NumberFormat.Field CURRENCY
 151       = new Field("currency");
 152
 153     /**
 154      * Attribute set to all characters containing the exponent sign.
 155      */
 156     public static final NumberFormat.Field EXPONENT_SIGN
 157       = new Field("exponent sign");
 158
 159     /**
 160      * Private fields to register all fields contained in this descriptor.
 161      */
 162     private static final NumberFormat.Field[] allFields =
 163     {
 164       INTEGER, FRACTION, EXPONENT, DECIMAL_SEPARATOR, SIGN,
 165       GROUPING_SEPARATOR, EXPONENT_SYMBOL, PERCENT,
 166       PERMILLE, CURRENCY, EXPONENT_SIGN
 167     };
 168
 169     /**
 170      * This constructor is only used by the deserializer. Without it,
 171      * it would fail to construct a valid object.
 172      */
 173     private Field()
 174     {
 175       super("");
 176     }
 177
 178     /**
 179      * Create a Field instance with the specified field name.
 180      *
 181      * @param field_name Field name for the new Field instance.
 182      */
 183     protected Field(String field_name)
 184     {
 185       super (field_name);
 186     }
 187
 188     /**
 189      * This function is used by the deserializer to know which object
 190      * to use when it encounters an encoded NumberFormat.Field in a
 191      * serialization stream. If the stream is valid it should return
 192      * one of the above field. In the other case we throw an exception.
 193      *
 194      * @return a valid official NumberFormat.Field instance.
 195      *
 196      * @throws InvalidObjectException if the field name is invalid.
 197      */
 198     protected Object readResolve() throws InvalidObjectException
 199     {
 200       String s = getName();
 201       for (int i = 0; i < allFields.length; i++)
 202         if (s.equals(allFields[i].getName()))
 203           return allFields[i];
 204
 205       throw new InvalidObjectException("no such NumberFormat field called "
 206                                        + s);
 207     }
 208   }
 209
 210   /**
 211    * This method is a specialization of the format method that performs
 212    * a simple formatting of the specified <code>long</code> number.
 213    *
 214    * @param number The <code>long</code> to format.
 215    *
 216    * @return The formatted number
 217    */
 218   public final String format (long number)
 219   {
 220     StringBuffer sbuf = new StringBuffer(50);
 221     format (number, sbuf, null);
 222     return sbuf.toString();
 223   }
 224
 225   public final StringBuffer format (Object obj, StringBuffer sbuf,
 226                                     FieldPosition pos)
 227   {
 228     if (obj instanceof Number)
 229       return format(((Number) obj).doubleValue(), sbuf, pos);
 230     else
 231       throw new IllegalArgumentException
 232         ("Cannot format given Object as a Number");
 233   }
 234
 235   /**
 236    * This method formats the specified <code>double</code> and appends it to
 237    * a <code>StringBuffer</code>.
 238    *
 239    * @param number The <code>double</code> to format.
 240    * @param sb The <code>StringBuffer</code> to append the formatted number to.
 241    * @param pos The desired <code>FieldPosition</code>.
 242    *
 243    * @return The <code>StringBuffer</code> with the appended number.
 244    */
 245   public abstract StringBuffer format (double number,
 246                                        StringBuffer sbuf, FieldPosition pos);
 247
 248   /**
 249    * This method formats the specified <code>long</code> and appends it to
 250    * a <code>StringBuffer</code>.
 251    *
 252    * @param number The <code>long</code> to format.
 253    * @param sb The <code>StringBuffer</code> to append the formatted number to.
 254    * @param pos The desired <code>FieldPosition</code>.
 255    *
 256    * @return The <code>StringBuffer</code> with the appended number.
 257    */
 258   public abstract StringBuffer format (long number,
 259                                        StringBuffer sbuf, FieldPosition pos);
 260
 261   /**
 262    * This method tests the specified object for equality against this object.
 263    * This will be <code>true</code> if the following conditions are met:
 264    * <p>
 265    * <ul>
 266    * <li>The specified object is not <code>null</code>.
 267    * <li>The specified object is an instance of <code>NumberFormat</code>.
 268    * </ul>
 269    * <p>
 270    * Since this method does not test much, it is highly advised that
 271    * concrete subclasses override this method.
 272    *
 273    * @param obj The <code>Object</code> to test against equality with
 274    *            this object.
 275    *
 276    * @return <code>true</code> if the specified object is equal to
 277    * this object, <code>false</code> otherwise.
 278    */
 279   public boolean equals (Object obj)
 280   {
 281     if (! (obj instanceof NumberFormat))
 282       return false;
 283     NumberFormat nf = (NumberFormat) obj;
 284     return (groupingUsed == nf.groupingUsed
 285             && maximumFractionDigits == nf.maximumFractionDigits
 286             && maximumIntegerDigits == nf.maximumIntegerDigits
 287             && minimumFractionDigits == nf.minimumFractionDigits
 288             && minimumIntegerDigits == nf.minimumIntegerDigits
 289             && parseIntegerOnly == nf.parseIntegerOnly);
 290   }
 291
 292   /**
 293    * This method returns a list of locales for which concrete instances
 294    * of <code>NumberFormat</code> subclasses may be created.
 295    *
 296    * @return The list of available locales.
 297    */
 298   public static Locale[] getAvailableLocales ()
 299   {
 300     Locale[] list = new Locale[1];
 301     list[0] = Locale.US;
 302     return list;
 303   }
 304
 305   private static NumberFormat computeInstance(Locale loc, String resource,
 306                                               String def)
 307   {
 308     ResourceBundle res;
 309     try
 310       {
 311         res = ResourceBundle.getBundle("gnu.java.locale.LocaleInformation",
 312                 loc, ClassLoader.getSystemClassLoader());
 313       }
 314     catch (MissingResourceException x)
 315       {
 316         res = null;
 317       }
 318     String fmt;
 319     try
 320       {
 321         fmt = res == null ? def : res.getString(resource);
 322       }
 323     catch (MissingResourceException x)
 324       {
 325         fmt = def;
 326       }
 327     DecimalFormatSymbols dfs = new DecimalFormatSymbols (loc);
 328     return new DecimalFormat (fmt, dfs);
 329   }
 330
 331   /**
 332    * This method returns an instance of <code>NumberFormat</code> suitable
 333    * for formatting and parsing currency values in the default locale.
 334    *
 335    * @return An instance of <code>NumberFormat</code> for handling currencies.
 336    */
 337   public static final NumberFormat getCurrencyInstance ()
 338   {
 339     return getCurrencyInstance (Locale.getDefault());
 340   }
 341
 342   /**
 343    * This method returns an instance of <code>NumberFormat</code> suitable
 344    * for formatting and parsing currency values in the specified locale.
 345    *
 346    * @return An instance of <code>NumberFormat</code> for handling currencies.
 347    */
 348   public static NumberFormat getCurrencyInstance (Locale loc)
 349   {
 350     return computeInstance (loc, "currencyFormat", "$#,##0.00;($#,##0.00)");
 351   }
 352
 353   /**
 354    * This method returns a default instance for the default locale. This
 355    * will be a concrete subclass of <code>NumberFormat</code>, but the
 356    * actual class returned is dependent on the locale.
 357    *
 358    * @return An instance of the default <code>NumberFormat</code> class.
 359    */
 360   public static final NumberFormat getInstance ()
 361   {
 362     return getInstance (Locale.getDefault());
 363   }
 364
 365   /**
 366    * This method returns a default instance for the specified locale. This
 367    * will be a concrete subclass of <code>NumberFormat</code>, but the
 368    * actual class returned is dependent on the locale.
 369    *
 370    * @param locale The desired locale.
 371    *
 372    * @return An instance of the default <code>NumberFormat</code> class.
 373    */
 374   public static NumberFormat getInstance (Locale loc)
 375   {
 376     // For now always return a number instance.
 377     return getNumberInstance (loc);
 378   }
 379
 380   /**
 381    * This method returns the maximum number of digits allowed in the fraction
 382    * portion of a number.
 383    *
 384    * @return The maximum number of digits allowed in the fraction
 385    * portion of a number.
 386    */
 387   public int getMaximumFractionDigits ()
 388   {
 389     return maximumFractionDigits;
 390   }
 391
 392   /**
 393    * This method returns the maximum number of digits allowed in the integer
 394    * portion of a number.
 395    *
 396    * @return The maximum number of digits allowed in the integer
 397    * portion of a number.
 398    */
 399   public int getMaximumIntegerDigits ()
 400   {
 401     return maximumIntegerDigits;
 402   }
 403
 404   /**
 405    * This method returns the minimum number of digits allowed in the fraction
 406    * portion of a number.
 407    *
 408    * @return The minimum number of digits allowed in the fraction
 409    * portion of a number.
 410    */
 411   public int getMinimumFractionDigits ()
 412   {
 413     return minimumFractionDigits;
 414   }
 415
 416   /**
 417    * This method returns the minimum number of digits allowed in the integer
 418    * portion of a number.
 419    *
 420    * @return The minimum number of digits allowed in the integer
 421    * portion of a number.
 422    */
 423   public int getMinimumIntegerDigits ()
 424   {
 425     return minimumIntegerDigits;
 426   }
 427
 428   /**
 429    * This method returns a default instance for the specified locale. This
 430    * will be a concrete subclass of <code>NumberFormat</code>, but the
 431    * actual class returned is dependent on the locale.
 432    *
 433    * @param locale The desired locale.
 434    *
 435    * @return An instance of the default <code>NumberFormat</code> class.
 436    */
 437   public static final NumberFormat getNumberInstance ()
 438   {
 439     return getNumberInstance (Locale.getDefault());
 440   }
 441
 442   /**
 443    * This method returns a general purpose number formatting and parsing
 444    * class for the default locale.  This will be a concrete subclass of
 445    * <code>NumberFormat</code>, but the actual class returned is dependent
 446    * on the locale.
 447    *
 448    * @return An instance of a generic number formatter for the default locale.
 449    */
 450   public static NumberFormat getNumberInstance (Locale loc)
 451   {
 452     return computeInstance (loc, "numberFormat", "#,##0.###");
 453   }
 454
 455   /**
 456    * This method returns an integer formatting and parsing class for the
 457    * default locale. This will be a concrete subclass of <code>NumberFormat</code>,
 458    * but the actual class returned is dependent on the locale.
 459    *
 460    * @return An instance of an integer number formatter for the default locale.
 461    * @since 1.4
 462    */
 463   public static final NumberFormat getIntegerInstance()
 464   {
 465     return getIntegerInstance (Locale.getDefault());
 466   }
 467
 468   /**
 469    * This method returns an integer formatting and parsing class for the
 470    * default locale. This will be a concrete subclass of <code>NumberFormat</code>,
 471    * but the actual class returned is dependent on the locale.
 472    *
 473    * @param locale the desired locale.
 474    *
 475    * @return An instance of an integer number formatter for the desired locale.
 476    * @since 1.4
 477    */
 478   public static NumberFormat getIntegerInstance(Locale locale)
 479   {
 480     NumberFormat format = computeInstance (locale, "numberFormat", "#,##0");
 481     format.setParseIntegerOnly (true);
 482     return format;
 483   }
 484
 485   /**
 486    * This method returns an instance of <code>NumberFormat</code> suitable
 487    * for formatting and parsing percentage values in the default locale.
 488    *
 489    * @return An instance of <code>NumberFormat</code> for handling percentages.
 490    */
 491   public static final NumberFormat getPercentInstance ()
 492   {
 493     return getPercentInstance (Locale.getDefault());
 494   }
 495
 496   /**
 497    * This method returns an instance of <code>NumberFormat</code> suitable
 498    * for formatting and parsing percentage values in the specified locale.
 499    *
 500    * @param locale The desired locale.
 501    *
 502    * @return An instance of <code>NumberFormat</code> for handling percentages.
 503    */
 504   public static NumberFormat getPercentInstance (Locale loc)
 505   {
 506     return computeInstance (loc, "percentFormat", "#,##0%");
 507   }
 508
 509   /**
 510    * This method returns a hash value for this object.
 511    *
 512    * @return The hash code.
 513    */
 514   public int hashCode ()
 515   {
 516     int hash = super.hashCode();
 517     hash ^= (maximumFractionDigits + maximumIntegerDigits
 518              + minimumFractionDigits + minimumIntegerDigits);
 519     if (groupingUsed)
 520       hash ^= 0xf0f0;
 521     if (parseIntegerOnly)
 522       hash ^= 0x0f0f;
 523     return hash;
 524   }
 525
 526   /**
 527    * This method tests whether or not grouping is in use.  Grouping is
 528    * a method of marking separations in numbers, such as thousand separators
 529    * in the US English locale.  The grouping positions and symbols are all
 530    * locale specific.  As an example, with grouping disabled, the number one
 531    * million would appear as "1000000".  With grouping enabled, this number
 532    * might appear as "1,000,000".  (Both of these assume the US English
 533    * locale).
 534    *
 535    * @return <code>true</code> if grouping is enabled,
 536    * <code>false</code> otherwise.
 537    */
 538   public boolean isGroupingUsed ()
 539   {
 540     return groupingUsed;
 541   }
 542
 543   /**
 544    * This method tests whether or not only integer values should be parsed.
 545    * If this class is parsing only integers, parsing stops at the decimal
 546    * point.
 547    *
 548    * @return <code>true</code> if only integers are parsed,
 549    * <code>false</code> otherwise.
 550    */
 551   public boolean isParseIntegerOnly ()
 552   {
 553     return parseIntegerOnly;
 554   }
 555
 556   /**
 557    * This is a default constructor for use by subclasses.
 558    */
 559   public NumberFormat ()
 560   {
 561   }
 562
 563   /**
 564    * This method parses the specified string into a <code>Number</code>.  This
 565    * will be a <code>Long</code> if possible, otherwise it will be a
 566    * <code>Double</code>.    If no number can be parsed, no exception is
 567    * thrown.  Instead, the parse position remains at its initial index.
 568    *
 569    * @param str The string to parse.
 570    * @param pp The desired <code>ParsePosition</code>.
 571    *
 572    * @return The parsed <code>Number</code>
 573    */
 574   public abstract Number parse (String sourceStr, ParsePosition pos);
 575
 576   /**
 577    * This method parses the specified string into a <code>Number</code>.  This
 578    * will be a <code>Long</code> if possible, otherwise it will be a
 579    * <code>Double</code>.  If no number can be parsed, an exception will be
 580    * thrown.
 581    *
 582    * @param str The string to parse.
 583    *
 584    * @return The parsed <code>Number</code>
 585    *
 586    * @exception ParseException If no number can be parsed.
 587    */
 588   public Number parse (String sourceStr) throws ParseException
 589   {
 590     ParsePosition pp = new ParsePosition (0);
 591     Number r = parse (sourceStr, pp);
 592     if (r == null)
 593       {
 594         int index = pp.getErrorIndex();
 595         if (index < 0)
 596           index = pp.getIndex();
 597         throw new ParseException ("couldn't parse number", index);
 598       }
 599     return r;
 600   }
 601
 602   /**
 603    * This method parses the specified string into an <code>Object</code>.  This
 604    * will be a <code>Long</code> if possible, otherwise it will be a
 605    * <code>Double</code>.    If no number can be parsed, no exception is
 606    * thrown.  Instead, the parse position remains at its initial index.
 607    *
 608    * @param str The string to parse.
 609    * @param pp The desired <code>ParsePosition</code>.
 610   *
 611   * @return The parsed <code>Object</code>
 612   */
 613   public final Object parseObject (String sourceStr, ParsePosition pos)
 614   {
 615     return parse (sourceStr, pos);
 616   }
 617
 618   /**
 619    * This method sets the grouping behavior of this formatter.  Grouping is
 620    * a method of marking separations in numbers, such as thousand separators
 621    * in the US English locale.  The grouping positions and symbols are all
 622    * locale specific.  As an example, with grouping disabled, the number one
 623    * million would appear as "1000000".  With grouping enabled, this number
 624    * might appear as "1,000,000".  (Both of these assume the US English
 625    * locale).
 626    *
 627    * @param groupingUsed <code>true</code> to enable grouping,
 628    *                     <code>false</code> to disable it.
 629    */
 630   public void setGroupingUsed (boolean newValue)
 631   {
 632     groupingUsed = newValue;
 633   }
 634
 635   /**
 636    * This method sets the maximum number of digits allowed in the fraction
 637    * portion of a number to the specified value.  If this is less than the
 638    * current minimum allowed digits, the minimum allowed digits value will
 639    * be lowered to be equal to the new maximum allowed digits value.
 640    *
 641    * @param maximumFractionDigits The new maximum fraction digits value.
 642    */
 643   public void setMaximumFractionDigits (int newValue)
 644   {
 645     maximumFractionDigits = newValue;
 646     if (getMinimumFractionDigits () > maximumFractionDigits)
 647       setMinimumFractionDigits (maximumFractionDigits);
 648   }
 649
 650   /**
 651    * This method sets the maximum number of digits allowed in the integer
 652    * portion of a number to the specified value.  If this is less than the
 653    * current minimum allowed digits, the minimum allowed digits value will
 654    * be lowered to be equal to the new maximum allowed digits value.
 655    *
 656    * @param maximumIntegerDigits The new maximum integer digits value.
 657    */
 658   public void setMaximumIntegerDigits (int newValue)
 659   {
 660     maximumIntegerDigits = newValue;
 661     if (getMinimumIntegerDigits () > maximumIntegerDigits)
 662       setMinimumIntegerDigits (maximumIntegerDigits);
 663   }
 664
 665   /**
 666    * This method sets the minimum number of digits allowed in the fraction
 667    * portion of a number to the specified value.  If this is greater than the
 668    * current maximum allowed digits, the maximum allowed digits value will
 669    * be raised to be equal to the new minimum allowed digits value.
 670    *
 671    * @param minimumFractionDigits The new minimum fraction digits value.
 672    */
 673   public void setMinimumFractionDigits (int newValue)
 674   {
 675     minimumFractionDigits = newValue;
 676     if (getMaximumFractionDigits () < minimumFractionDigits)
 677       setMaximumFractionDigits (minimumFractionDigits);
 678   }
 679
 680   /**
 681    * This method sets the minimum number of digits allowed in the integer
 682    * portion of a number to the specified value.  If this is greater than the
 683    * current maximum allowed digits, the maximum allowed digits value will
 684    * be raised to be equal to the new minimum allowed digits value.
 685    *
 686    * @param minimumIntegerDigits The new minimum integer digits value.
 687    */
 688   public void setMinimumIntegerDigits (int newValue)
 689   {
 690     minimumIntegerDigits = newValue;
 691     if (getMaximumIntegerDigits () < minimumIntegerDigits)
 692       setMaximumIntegerDigits (minimumIntegerDigits);
 693   }
 694
 695   /**
 696    * This method sets the parsing behavior of this object to parse only
 697    * integers or not.
 698    *
 699    * @param parseIntegerOnly <code>true</code> to parse only integers,
 700    *                         <code>false</code> otherwise.
 701    */
 702   public void setParseIntegerOnly (boolean value)
 703   {
 704     parseIntegerOnly = value;
 705   }
 706
 707   /**
 708    * This method is a specialization of the format method that performs
 709    * a simple formatting of the specified <code>double</code> number.
 710    *
 711    * @param number The <code>double</code> to format.
 712    *
 713    * @return The formatted number
 714    */
 715   public final String format (double number)
 716   {
 717     StringBuffer sbuf = new StringBuffer(50);
 718     format (number, sbuf, null);
 719     return sbuf.toString();
 720   }
 721
 722   // These field names are fixed by the serialization spec.
 723   boolean groupingUsed;
 724   int maximumFractionDigits;
 725   private byte maxFractionDigits;
 726   int maximumIntegerDigits;
 727   private byte maxIntegerDigits;
 728   int minimumFractionDigits;
 729   private byte minFractionDigits;
 730   int minimumIntegerDigits;
 731   private byte minIntegerDigits;
 732   boolean parseIntegerOnly;
 733   private int serialVersionOnStream;
 734   private static final long serialVersionUID = -2308460125733713944L;
 735
 736   private void readObject(ObjectInputStream stream)
 737     throws IOException, ClassNotFoundException
 738   {
 739     stream.defaultReadObject();
 740     if (serialVersionOnStream < 1)
 741       {
 742         maximumFractionDigits = maxFractionDigits;
 743         maximumIntegerDigits = maxIntegerDigits;
 744         minimumFractionDigits = minFractionDigits;
 745         minimumIntegerDigits = minIntegerDigits;
 746         serialVersionOnStream = 1;
 747       }
 748   }
 749
 750   private void writeObject(ObjectOutputStream stream) throws IOException
 751   {
 752     maxFractionDigits = maximumFractionDigits < Byte.MAX_VALUE ?
 753       (byte) maximumFractionDigits : Byte.MAX_VALUE;
 754     maxIntegerDigits = maximumIntegerDigits < Byte.MAX_VALUE ?
 755       (byte) maximumIntegerDigits : Byte.MAX_VALUE;
 756     minFractionDigits = minimumFractionDigits < Byte.MAX_VALUE ?
 757       (byte) minimumFractionDigits : Byte.MAX_VALUE;
 758     minIntegerDigits = minimumIntegerDigits < Byte.MAX_VALUE ?
 759       (byte) minimumIntegerDigits : Byte.MAX_VALUE;
 760     serialVersionOnStream = 1;
 761     stream.defaultWriteObject();
 762   }
 763
 764   /**
 765    * Returns the currency used by this number format when formatting currency
 766    * values.
 767    *
 768    * The default implementation throws UnsupportedOperationException.
 769    *
 770    * @return The used currency object, or null.
 771    *
 772    * @throws UnsupportedOperationException If the number format class doesn't
 773    * implement currency formatting.
 774    *
 775    * @since 1.4
 776    */
 777   public Currency getCurrency()
 778   {
 779     throw new UnsupportedOperationException();
 780   }
 781
 782   /**
 783    * Sets the currency used by this number format when formatting currency
 784    * values.
 785    *
 786    * The default implementation throws UnsupportedOperationException.
 787    *
 788    * @param currency The new currency to be used by this number format.
 789    *
 790    * @throws NullPointerException If currenc is null.
 791    * @throws UnsupportedOperationException If the number format class doesn't
 792    * implement currency formatting.
 793    *
 794    * @since 1.4
 795    */
 796   public void setCurrency(Currency currency)
 797   {
 798     if (currency == null)
 799       throw new NullPointerException("currency may not be null");
 800
 801     throw new UnsupportedOperationException();
 802   }
 803 }