Name: dm26566 Date: 04/29/98

public static void main(String[] args)
{
  String pattern = "#0.00";
  DecimalFormat f = new DecimalFormat(pattern);
  System.out.println("new pattern: " +
                     f.toPattern());
}

This prints "#000.0" and "006.74". This used to work perfectly in 1.1.5, but now it doesn't.

Additional Notes from dalem:

This is also a probelm on JDK-1.2beta4-C.
It used to print out "#0.00" in 1.1.5
(Review ID: 29322)
======================================================================

Another test case from another customer:

When using JDK 1.1.6 the values on the screen don't look like the given format.

Example:

import java.text.DecimalFormat;
import java.text.FieldPosition;
import java.text.ParsePosition;

public class NiceFormat extends DecimalFormat
{
    /** Value for an empty Double. */
    private static final Double EMPTY_DOUBLE = new Double (Double.NaN);

    /** The format supported by this class */
    private static final String STANDARD_FORMAT = "#0.000";

    /** Singleton for NiceFormat */
    private static NiceFormat standardFormat;

/** Constructor calls the Super-Class with STANDARD_FORMAT */
private NiceFormat ()
{
super (STANDARD_FORMAT);
}

    /**
* returns the one and only instance for this class
*
     * @return NiceFormat the instance of this class.
     */
    public static NiceFormat getNiceFormat ()
{
        if (standardFormat == null)
            standardFormat = new NiceFormat ();

        return standardFormat;
    }

    /**
* returns the formatted text from the given double
*
     * @param aNumber the number to format.
     * @param aResult the stringbuffer holding the result.
     * @param aFieldPosition position where parsing ends.
* @returns StringBuffer the formatted text.
     */
    public StringBuffer format (double aNumber, StringBuffer aResult,
FieldPosition aFieldPosition)
{
         if (Double.isNaN (aNumber))
            return aResult;
         else
         {
            return super.format (aNumber, aResult, aFieldPosition);
         }
    }

    /**
* methode to parse a String
*
     * @param aText text to be parsed.
* @returns Number the value represented by the given text.
     */
    public Number parse (String aText)
{
        return parse (aText, new ParsePosition (0));
    }

    /**
* parse the String and return the value, if String is empty, return
* the value <code>EMPTY_DOUBLE</code>
*
     * @param aText text to be parsed.
* @param aFieldPosition position, where parsing ends.
* @returns Number the value represented by the given text.
     */
    public Number parse (String aSource, ParsePosition aFieldPosition)
{
        // delete all spaces.
        String source = aSource.trim ();

        // return EMPTY_DOUBLE, if String is empty.
        if (source.length () == 0)
            return EMPTY_DOUBLE;
        else
            return super.parse (aSource,aFieldPosition);
    }

public static void main (String someArguments [])
{
NiceFormat theFormat = NiceFormat.getNiceFormat ();
double theValue = 4.070;

System.out.println ("Value: " + theValue + ", formatted: " + theFormat.format (theValue));
}
}

I expected an output like:
Value: 4.07, formatted: 4,070

but I got:
Value: 4.07, formatted: 0004,070