/**

public DecimalFormat() {

// Get the pattern for the default locale.

Locale def = Locale.getDefault(Locale.Category.FORMAT);

LocaleProviderAdapter adapter = LocaleProviderAdapter.getAdapter(NumberFormatProvider.class, def);

if (!(adapter instanceof ResourceBundleBasedAdapter)) {

adapter = LocaleProviderAdapter.getResourceBundleBased();

}

String[] all = adapter.getLocaleResources(def).getNumberPatterns();

// Always applyPattern after the symbols are set

this.symbols = DecimalFormatSymbols.getInstance(def);

applyPattern(all[0], false);

}

/**

public DecimalFormat(String pattern) {

// Always applyPattern after the symbols are set

this.symbols = DecimalFormatSymbols.getInstance(Locale.getDefault(Locale.Category.FORMAT));

applyPattern(pattern, false);

}

/**

public DecimalFormat (String pattern, DecimalFormatSymbols symbols) {

// Always applyPattern after the symbols are set

this.symbols = (DecimalFormatSymbols)symbols.clone();

applyPattern(pattern, false);

}

// Overrides

/**

@Override

public final StringBuffer format(Object number,

StringBuffer toAppendTo,

FieldPosition pos) {

if (number instanceof Long || number instanceof Integer ||

number instanceof Short || number instanceof Byte ||

number instanceof AtomicInteger ||

number instanceof AtomicLong ||

(number instanceof BigInteger &&

((BigInteger)number).bitLength () < 64)) {

return format(((Number)number).longValue(), toAppendTo, pos);

} else if (number instanceof BigDecimal) {

return format((BigDecimal)number, toAppendTo, pos);

} else if (number instanceof BigInteger) {

return format((BigInteger)number, toAppendTo, pos);

} else if (number instanceof Number) {

return format(((Number)number).doubleValue(), toAppendTo, pos);

} else {

throw new IllegalArgumentException("Cannot format given Object as a Number");

}

}

/**

@Override

public StringBuffer format(double number, StringBuffer result,

FieldPosition fieldPosition) {

// If fieldPosition is a DontCareFieldPosition instance we can

// try to go to fast-path code.

boolean tryFastPath = false;

if (fieldPosition == DontCareFieldPosition.INSTANCE)

tryFastPath = true;

else {

fieldPosition.setBeginIndex(0);

fieldPosition.setEndIndex(0);

}

if (tryFastPath) {

String tempResult = fastFormat(number);

if (tempResult != null) {

result.append(tempResult);

return result;

}

}

// if fast-path could not work, we fallback to standard code.

return format(number, result, fieldPosition.getFieldDelegate());

}

/**

private StringBuffer format(double number, StringBuffer result,

FieldDelegate delegate) {

if (Double.isNaN(number) ||

(Double.isInfinite(number) && multiplier == 0)) {

int iFieldStart = result.length();

result.append(symbols.getNaN());

delegate.formatted(INTEGER_FIELD, Field.INTEGER, Field.INTEGER,

iFieldStart, result.length(), result);

return result;

}

/* Detecting whether a double is negative is easy with the exception of

boolean isNegative = ((number < 0.0) || (number == 0.0 && 1/number < 0.0)) ^ (multiplier < 0);

if (multiplier != 1) {

number *= multiplier;

}

if (Double.isInfinite(number)) {

if (isNegative) {

append(result, negativePrefix, delegate,

getNegativePrefixFieldPositions(), Field.SIGN);

} else {

append(result, positivePrefix, delegate,

getPositivePrefixFieldPositions(), Field.SIGN);

}

int iFieldStart = result.length();

result.append(symbols.getInfinity());

delegate.formatted(INTEGER_FIELD, Field.INTEGER, Field.INTEGER,

iFieldStart, result.length(), result);

if (isNegative) {

append(result, negativeSuffix, delegate,

getNegativeSuffixFieldPositions(), Field.SIGN);

} else {

append(result, positiveSuffix, delegate,

getPositiveSuffixFieldPositions(), Field.SIGN);

}

return result;

}

if (isNegative) {

number = -number;

}

// at this point we are guaranteed a nonnegative finite number.

assert(number >= 0 && !Double.isInfinite(number));

synchronized(digitList) {

int maxIntDigits = super.getMaximumIntegerDigits();

int minIntDigits = super.getMinimumIntegerDigits();

int maxFraDigits = super.getMaximumFractionDigits();

int minFraDigits = super.getMinimumFractionDigits();

digitList.set(isNegative, number, useExponentialNotation ?

maxIntDigits + maxFraDigits : maxFraDigits,

!useExponentialNotation);

return subformat(result, delegate, isNegative, false,

maxIntDigits, minIntDigits, maxFraDigits, minFraDigits);

}

}

/**

@Override

public StringBuffer format(long number, StringBuffer result,

FieldPosition fieldPosition) {

fieldPosition.setBeginIndex(0);

fieldPosition.setEndIndex(0);

return format(number, result, fieldPosition.getFieldDelegate());

}

/**

private StringBuffer format(long number, StringBuffer result,

FieldDelegate delegate) {

boolean isNegative = (number < 0);

if (isNegative) {

number = -number;

}

// In general, long values always represent real finite numbers, so

// we don't have to check for +/- Infinity or NaN. However, there

// is one case we have to be careful of: The multiplier can push

// a number near MIN_VALUE or MAX_VALUE outside the legal range. We

// check for this before multiplying, and if it happens we use

// BigInteger instead.

boolean useBigInteger = false;

if (number < 0) { // This can only happen if number == Long.MIN_VALUE.

if (multiplier != 0) {

useBigInteger = true;

}

} else if (multiplier != 1 && multiplier != 0) {

long cutoff = Long.MAX_VALUE / multiplier;

if (cutoff < 0) {

cutoff = -cutoff;

}

useBigInteger = (number > cutoff);

}

if (useBigInteger) {

if (isNegative) {

number = -number;

}

BigInteger bigIntegerValue = BigInteger.valueOf(number);

return format(bigIntegerValue, result, delegate, true);

}

number *= multiplier;

if (number == 0) {

isNegative = false;

} else {

if (multiplier < 0) {

number = -number;

isNegative = !isNegative;

}

}

synchronized(digitList) {

int maxIntDigits = super.getMaximumIntegerDigits();

int minIntDigits = super.getMinimumIntegerDigits();

int maxFraDigits = super.getMaximumFractionDigits();

int minFraDigits = super.getMinimumFractionDigits();

digitList.set(isNegative, number,

useExponentialNotation ? maxIntDigits + maxFraDigits : 0);

return subformat(result, delegate, isNegative, true,

maxIntDigits, minIntDigits, maxFraDigits, minFraDigits);

}

}

/**

private StringBuffer format(BigDecimal number, StringBuffer result,

FieldPosition fieldPosition) {

fieldPosition.setBeginIndex(0);

fieldPosition.setEndIndex(0);

return format(number, result, fieldPosition.getFieldDelegate());

}

/**

private StringBuffer format(BigDecimal number, StringBuffer result,

FieldDelegate delegate) {

if (multiplier != 1) {

number = number.multiply(getBigDecimalMultiplier());

}

boolean isNegative = number.signum() == -1;

if (isNegative) {

number = number.negate();

}

synchronized(digitList) {

int maxIntDigits = getMaximumIntegerDigits();

int minIntDigits = getMinimumIntegerDigits();

int maxFraDigits = getMaximumFractionDigits();

int minFraDigits = getMinimumFractionDigits();

int maximumDigits = maxIntDigits + maxFraDigits;

digitList.set(isNegative, number, useExponentialNotation ?

((maximumDigits < 0) ? Integer.MAX_VALUE : maximumDigits) :

maxFraDigits, !useExponentialNotation);

return subformat(result, delegate, isNegative, false,

maxIntDigits, minIntDigits, maxFraDigits, minFraDigits);

}

}

/**

private StringBuffer format(BigInteger number, StringBuffer result,

FieldPosition fieldPosition) {

fieldPosition.setBeginIndex(0);

fieldPosition.setEndIndex(0);

return format(number, result, fieldPosition.getFieldDelegate(), false);

}

/**

private StringBuffer format(BigInteger number, StringBuffer result,

FieldDelegate delegate, boolean formatLong) {

if (multiplier != 1) {

number = number.multiply(getBigIntegerMultiplier());

}

boolean isNegative = number.signum() == -1;

if (isNegative) {

number = number.negate();

}

synchronized(digitList) {

int maxIntDigits, minIntDigits, maxFraDigits, minFraDigits, maximumDigits;

if (formatLong) {

maxIntDigits = super.getMaximumIntegerDigits();

minIntDigits = super.getMinimumIntegerDigits();

maxFraDigits = super.getMaximumFractionDigits();

minFraDigits = super.getMinimumFractionDigits();

maximumDigits = maxIntDigits + maxFraDigits;

} else {

maxIntDigits = getMaximumIntegerDigits();

minIntDigits = getMinimumIntegerDigits();

maxFraDigits = getMaximumFractionDigits();

minFraDigits = getMinimumFractionDigits();

maximumDigits = maxIntDigits + maxFraDigits;

if (maximumDigits < 0) {

maximumDigits = Integer.MAX_VALUE;

}

}

digitList.set(isNegative, number,

useExponentialNotation ? maximumDigits : 0);

return subformat(result, delegate, isNegative, true,

maxIntDigits, minIntDigits, maxFraDigits, minFraDigits);

}

}

/**

@Override

public AttributedCharacterIterator formatToCharacterIterator(Object obj) {

CharacterIteratorFieldDelegate delegate =

new CharacterIteratorFieldDelegate();

StringBuffer sb = new StringBuffer();

if (obj instanceof Double || obj instanceof Float) {

format(((Number)obj).doubleValue(), sb, delegate);

} else if (obj instanceof Long || obj instanceof Integer ||

obj instanceof Short || obj instanceof Byte ||

obj instanceof AtomicInteger || obj instanceof AtomicLong) {

format(((Number)obj).longValue(), sb, delegate);

} else if (obj instanceof BigDecimal) {

format((BigDecimal)obj, sb, delegate);

} else if (obj instanceof BigInteger) {

format((BigInteger)obj, sb, delegate, false);

} else if (obj == null) {

throw new NullPointerException(

"formatToCharacterIterator must be passed non-null object");

} else {

throw new IllegalArgumentException(

"Cannot format given Object as a Number");

}

return delegate.getIterator(sb.toString());

}

// ==== Begin fast-path formating logic for double =========================

/* Fast-path formatting will be used for format(double ...) methods iff a

/**

private void checkAndSetFastPathStatus() {

boolean fastPathWasOn = isFastPath;

if ((roundingMode == RoundingMode.HALF_EVEN) &&

(isGroupingUsed()) &&

(groupingSize == 3) &&

(multiplier == 1) &&

(!decimalSeparatorAlwaysShown) &&

(!useExponentialNotation)) {

// The fast-path algorithm is semi-hardcoded against

// minimumIntegerDigits and maximumIntegerDigits.

isFastPath = ((minimumIntegerDigits == 1) &&

(maximumIntegerDigits >= 10));

// The fast-path algorithm is hardcoded against

// minimumFractionDigits and maximumFractionDigits.

if (isFastPath) {

if (isCurrencyFormat) {

if ((minimumFractionDigits != 2) ||

(maximumFractionDigits != 2))

isFastPath = false;

} else if ((minimumFractionDigits != 0) ||

(maximumFractionDigits != 3))

isFastPath = false;

}

} else

isFastPath = false;