jdk-sandbox: comparison jdk/src/share/classes/java/text/DecimalFormat.java

equal deleted inserted replaced

-:69648476a89e
+:a64012cb49d6
 /*
-* Copyright (c) 1996, 2012, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * <code>applyPattern()</code>, or indirectly using the API methods.  The
 * symbols are stored in a <code>DecimalFormatSymbols</code> object.  When using
 * the <code>NumberFormat</code> factory methods, the pattern and symbols are
 * read from localized <code>ResourceBundle</code>s.
 *
-* <h4>Patterns</h4>
+* <h3>Patterns</h3>
 *
 * <code>DecimalFormat</code> patterns have the following syntax:
 * <blockquote><pre>
 * <i>Pattern:</i>
 *         <i>PositivePattern</i>
 * are not localized.
 *
 * <blockquote>
 * <table border=0 cellspacing=3 cellpadding=0 summary="Chart showing symbol,
 *  location, localized, and meaning.">
-*     <tr bgcolor="#ccccff">
+*     <tr style="background-color: rgb(204, 204, 255);">
 *          <th align=left>Symbol
 *          <th align=left>Location
 *          <th align=left>Localized?
 *          <th align=left>Meaning
 *     <tr valign=top>
 *          <td><code>0</code>
 *          <td>Number
 *          <td>Yes
 *          <td>Digit
-*     <tr valign=top bgcolor="#eeeeff">
+*     <tr style="vertical-align: top; background-color: rgb(238, 238, 255);">
 *          <td><code>#</code>
 *          <td>Number
 *          <td>Yes
 *          <td>Digit, zero shows as absent
 *     <tr valign=top>
 *          <td><code>.</code>
 *          <td>Number
 *          <td>Yes
 *          <td>Decimal separator or monetary decimal separator
-*     <tr valign=top bgcolor="#eeeeff">
+*     <tr style="vertical-align: top; background-color: rgb(238, 238, 255);">
 *          <td><code>-</code>
 *          <td>Number
 *          <td>Yes
 *          <td>Minus sign
 *     <tr valign=top>
 *          <td><code>,</code>
 *          <td>Number
 *          <td>Yes
 *          <td>Grouping separator
-*     <tr valign=top bgcolor="#eeeeff">
+*     <tr style="vertical-align: top; background-color: rgb(238, 238, 255);">
 *          <td><code>E</code>
 *          <td>Number
 *          <td>Yes
 *          <td>Separates mantissa and exponent in scientific notation.
 *              <em>Need not be quoted in prefix or suffix.</em>
 *     <tr valign=top>
 *          <td><code>;</code>
 *          <td>Subpattern boundary
 *          <td>Yes
 *          <td>Separates positive and negative subpatterns
-*     <tr valign=top bgcolor="#eeeeff">
+*     <tr style="vertical-align: top; background-color: rgb(238, 238, 255);">
 *          <td><code>%</code>
 *          <td>Prefix or suffix
 *          <td>Yes
 *          <td>Multiply by 100 and show as percentage
 *     <tr valign=top>
 *          <td><code>&#92;u2030</code>
 *          <td>Prefix or suffix
 *          <td>Yes
 *          <td>Multiply by 1000 and show as per mille value
-*     <tr valign=top bgcolor="#eeeeff">
+*     <tr style="vertical-align: top; background-color: rgb(238, 238, 255);">
 *          <td><code>&#164;</code> (<code>&#92;u00A4</code>)
 *          <td>Prefix or suffix
 *          <td>No
 *          <td>Currency sign, replaced by currency symbol.  If
 *              doubled, replaced by international currency symbol.
 *
 * <h4>Scientific Notation</h4>
 *
 * <p>Numbers in scientific notation are expressed as the product of a mantissa
 * and a power of ten, for example, 1234 can be expressed as 1.234 x 10^3.  The
-* mantissa is often in the range 1.0 <= x < 10.0, but it need not be.
+* mantissa is often in the range 1.0 &le; x {@literal <} 10.0, but it need not
+* be.
 * <code>DecimalFormat</code> can be instructed to format and parse scientific
 * notation <em>only via a pattern</em>; there is currently no factory method
 * that creates a scientific notation format.  In a pattern, the exponent
 * character immediately followed by one or more digit characters indicates
 * scientific notation.  Example: <code>"0.###E0"</code> formats the number
 * If multiple threads access a format concurrently, it must be synchronized
 * externally.
 *
 * <h4>Example</h4>
 *
-* <blockquote><pre>
+* <blockquote><pre>{@code
 * <strong>// Print out a number using the localized number, integer, currency,
 * // and percent format for each locale</strong>
 * Locale[] locales = NumberFormat.getAvailableLocales();
 * double myNumber = -1234.56;
 * NumberFormat form;
-* for (int j=0; j<4; ++j) {
+* for (int j = 0; j < 4; ++j) {
 *     System.out.println("FORMAT");
 *     for (int i = 0; i < locales.length; ++i) {
 *         if (locales[i].getCountry().length() == 0) {
 *            continue; // Skip language-only locales
 *         }
 *         try {
 *             System.out.println(" -> " + form.parse(form.format(myNumber)));
 *         } catch (ParseException e) {}
 *     }
 * }
-* </pre></blockquote>
+* }</pre></blockquote>
 *
 * @see          <a href="http://java.sun.com/docs/books/tutorial/i18n/format/decimalFormat.html">Java Tutorial</a>
 * @see          NumberFormat
 * @see          DecimalFormatSymbols
 * @see          ParsePosition
 * To obtain standard formats for a given locale, use the factory methods
 * on NumberFormat such as getNumberInstance. These factories will
 * return the most appropriate sub-class of NumberFormat for a given
 * locale.
 *
-* @param pattern A non-localized pattern string.
+* @param pattern a non-localized pattern string.
 * @exception NullPointerException if <code>pattern</code> is null
 * @exception IllegalArgumentException if the given pattern is invalid.
 * @see java.text.NumberFormat#getInstance
 * @see java.text.NumberFormat#getNumberInstance
 * @see java.text.NumberFormat#getCurrencyInstance
 }
 /**
 * Get the positive prefix.
 * <P>Examples: +123, $123, sFr123
+*
+* @return the positive prefix
 */
 public String getPositivePrefix () {
 return positivePrefix;
 }
 /**
 * Set the positive prefix.
 * <P>Examples: +123, $123, sFr123
+*
+* @param newValue the new positive prefix
 */
 public void setPositivePrefix (String newValue) {
 positivePrefix = newValue;
 posPrefixPattern = null;
 positivePrefixFieldPositions = null;
 }
 /**
 * Get the negative prefix.
 * <P>Examples: -123, ($123) (with negative suffix), sFr-123
+*
+* @return the negative prefix
 */
 public String getNegativePrefix () {
 return negativePrefix;
 }
 /**
 * Set the negative prefix.
 * <P>Examples: -123, ($123) (with negative suffix), sFr-123
+*
+* @param newValue the new negative prefix
 */
 public void setNegativePrefix (String newValue) {
 negativePrefix = newValue;
 negPrefixPattern = null;
 fastPathCheckNeeded = true;
 }
 /**
 * Get the positive suffix.
 * <P>Example: 123%
+*
+* @return the positive suffix
 */
 public String getPositiveSuffix () {
 return positiveSuffix;
 }
 /**
 * Set the positive suffix.
 * <P>Example: 123%
+*
+* @param newValue the new positive suffix
 */
 public void setPositiveSuffix (String newValue) {
 positiveSuffix = newValue;
 posSuffixPattern = null;
 fastPathCheckNeeded = true;
 }
 /**
 * Get the negative suffix.
 * <P>Examples: -123%, ($123) (with positive suffixes)
+*
+* @return the negative suffix
 */
 public String getNegativeSuffix () {
 return negativeSuffix;
 }
 /**
 * Set the negative suffix.
 * <P>Examples: 123%
+*
+* @param newValue the new negative suffix
 */
 public void setNegativeSuffix (String newValue) {
 negativeSuffix = newValue;
 negSuffixPattern = null;
 fastPathCheckNeeded = true;
 /**
 * Gets the multiplier for use in percent, per mille, and similar
 * formats.
 *
+* @return the multiplier
 * @see #setMultiplier(int)
 */
 public int getMultiplier () {
 return multiplier;
 }
 * have '&#92;u2030'.
 *
 * <P>Example: with multiplier 100, 1.23 is formatted as "123", and
 * "123" is parsed into 1.23.
 *
+* @param newValue the new multiplier
 * @see #getMultiplier
 */
 public void setMultiplier (int newValue) {
 multiplier = newValue;
 bigDecimalMultiplier = null;
 /**
 * Return the grouping size. Grouping size is the number of digits between
 * grouping separators in the integer portion of a number.  For example,
 * in the number "123,456.78", the grouping size is 3.
+*
+* @return the grouping size
 * @see #setGroupingSize
 * @see java.text.NumberFormat#isGroupingUsed
 * @see java.text.DecimalFormatSymbols#getGroupingSeparator
 */
 public int getGroupingSize () {
 * Set the grouping size. Grouping size is the number of digits between
 * grouping separators in the integer portion of a number.  For example,
 * in the number "123,456.78", the grouping size is 3.
 * <br>
 * The value passed in is converted to a byte, which may lose information.
+*
+* @param newValue the new grouping size
 * @see #getGroupingSize
 * @see java.text.NumberFormat#setGroupingUsed
 * @see java.text.DecimalFormatSymbols#setGroupingSeparator
 */
 public void setGroupingSize (int newValue) {
 }
 /**
 * Allows you to get the behavior of the decimal separator with integers.
 * (The decimal separator will always appear with decimals.)
-* <P>Example: Decimal ON: 12345 -> 12345.; OFF: 12345 -> 12345
+* <P>Example: Decimal ON: 12345 &rarr; 12345.; OFF: 12345 &rarr; 12345
+*
+* @return {@code true} if the decimal separator is always shown;
+*         {@code false} otherwise
 */
 public boolean isDecimalSeparatorAlwaysShown() {
 return decimalSeparatorAlwaysShown;
 }
 /**
 * Allows you to set the behavior of the decimal separator with integers.
 * (The decimal separator will always appear with decimals.)
-* <P>Example: Decimal ON: 12345 -> 12345.; OFF: 12345 -> 12345
+* <P>Example: Decimal ON: 12345 &rarr; 12345.; OFF: 12345 &rarr; 12345
+*
+* @param newValue {@code true} if the decimal separator is always shown;
+*                 {@code false} otherwise
 */
 public void setDecimalSeparatorAlwaysShown(boolean newValue) {
 decimalSeparatorAlwaysShown = newValue;
 fastPathCheckNeeded = true;
 }
 /**
 * Returns whether the {@link #parse(java.lang.String, java.text.ParsePosition)}
 * method returns <code>BigDecimal</code>. The default value is false.
+*
+* @return {@code true} if the parse method returns BigDecimal;
+*         {@code false} otherwise
 * @see #setParseBigDecimal
 * @since 1.5
 */
 public boolean isParseBigDecimal() {
 return parseBigDecimal;
 }
 /**
 * Sets whether the {@link #parse(java.lang.String, java.text.ParsePosition)}
 * method returns <code>BigDecimal</code>.
+*
+* @param newValue {@code true} if the parse method returns BigDecimal;
+*                 {@code false} otherwise
 * @see #isParseBigDecimal
 * @since 1.5
 */
 public void setParseBigDecimal(boolean newValue) {
 parseBigDecimal = newValue;
 }
 /**
 * Synthesizes a pattern string that represents the current state
 * of this Format object.
+*
+* @return a pattern string
 * @see #applyPattern
 */
 public String toPattern() {
 return toPattern( false );
 }
 /**
 * Synthesizes a localized pattern string that represents the current
 * state of this Format object.
+*
+* @return a localized pattern string
 * @see #applyPattern
 */
 public String toLocalizedPattern() {
 return toPattern( true );
 }
 * <p>
 * There is no limit to integer digits set
 * by this routine, since that is the typical end-user desire;
 * use setMaximumInteger if you want to set a real value.
 * For negative numbers, use a second pattern, separated by a semicolon
-* <P>Example <code>"#,#00.0#"</code> -> 1,234.56
+* <P>Example <code>"#,#00.0#"</code> &rarr; 1,234.56
 * <P>This means a minimum of 2 integer digits, 1 fraction digit, and
 * a maximum of 2 fraction digits.
 * <p>Example: <code>"#,#00.0#;(#,#00.0#)"</code> for negatives in
 * parentheses.
 * <p>In negative patterns, the minimum and maximum counts are ignored;
 * these are presumed to be set in the positive pattern.
 *
+* @param pattern a new pattern
 * @exception NullPointerException if <code>pattern</code> is null
 * @exception IllegalArgumentException if the given pattern is invalid.
 */
 public void applyPattern(String pattern) {
 applyPattern(pattern, false);
 * <p>
 * There is no limit to integer digits set
 * by this routine, since that is the typical end-user desire;
 * use setMaximumInteger if you want to set a real value.
 * For negative numbers, use a second pattern, separated by a semicolon
-* <P>Example <code>"#,#00.0#"</code> -> 1,234.56
+* <P>Example <code>"#,#00.0#"</code> &rarr; 1,234.56
 * <P>This means a minimum of 2 integer digits, 1 fraction digit, and
 * a maximum of 2 fraction digits.
 * <p>Example: <code>"#,#00.0#;(#,#00.0#)"</code> for negatives in
 * parentheses.
 * <p>In negative patterns, the minimum and maximum counts are ignored;
 * these are presumed to be set in the positive pattern.
 *
+* @param pattern a new pattern
 * @exception NullPointerException if <code>pattern</code> is null
 * @exception IllegalArgumentException if the given pattern is invalid.
 */
 public void applyLocalizedPattern(String pattern) {
 applyPattern(pattern, true);

changeset 19054	a64012cb49d6
parent 16010	2727163b5df5
child 20455	f6f9a0c2796b