Java 类java.text.DecimalFormatSymbols 实例源码

public static String castToString(double d)
{
    double dAbs = Math.abs(d);
    DecimalFormatSymbols decfmtsymb = new DecimalFormatSymbols(java.util.Locale.US);    // US locale represents numbers with a . as comma and without any (ten)thousend separators.
    decfmtsymb.setInfinity("INF");
    decfmtsymb.setNaN("NaN");
    DecimalFormat decfmt = new DecimalFormat((dAbs > 1E7 || dAbs < 1E-3) && dAbs > 0.0 ?
            "0.##############E000" : "0.#############", decfmtsymb);

    String s = decfmt.format(d);
    // 1.234E567 => 1.234E+567
    int e = s.indexOf("E");
    if (e > 0 && s.charAt(e+1) != '-' )
    s = s.substring(0, e) + "E+" + s.substring(e+1);
    return s;
}

private DecimalFormatSymbols readTestObject(File inputFile){
    try (InputStream istream = inputFile.getName().endsWith(".txt") ?
                                   HexDumpReader.getStreamFromHexDump(inputFile) :
                                   new FileInputStream(inputFile)) {
        ObjectInputStream p = new ObjectInputStream(istream);
        DecimalFormatSymbols dfs = (DecimalFormatSymbols)p.readObject();
        return dfs;
    } catch (Exception e) {
        errln("Test Malfunction in DFSSerialization: Exception while reading the object");
        /*
         * logically should not throw this exception as errln throws exception
         * if not thrown yet - but in case errln got changed
         */
        throw new RuntimeException("Test Malfunction: re-throwing the exception", e);
    }
}

private void printTestInfo(int maxCacheSize) {

        DecimalFormat grouped = new DecimalFormat("000,000");
        DecimalFormatSymbols formatSymbols = grouped.getDecimalFormatSymbols();
        formatSymbols.setGroupingSeparator(' ');
        grouped.setDecimalFormatSymbols(formatSymbols);

        System.out.format(
                "Test will use %s bytes of memory of %s available%n"
                + "Available memory is %s with %d bytes pointer size - can save %s pointers%n"
                + "Max cache size: 2^%d = %s elements%n",
                grouped.format(ShrinkAuxiliaryDataTest.getMemoryUsedByTest()),
                grouped.format(Runtime.getRuntime().maxMemory()),
                grouped.format(Runtime.getRuntime().maxMemory()
                        - ShrinkAuxiliaryDataTest.getMemoryUsedByTest()),
                Unsafe.ADDRESS_SIZE,
                grouped.format((Runtime.getRuntime().freeMemory()
                        - ShrinkAuxiliaryDataTest.getMemoryUsedByTest())
                        / Unsafe.ADDRESS_SIZE),
                maxCacheSize,
                grouped.format((int) Math.pow(2, maxCacheSize))
        );
    }

/**
 * Initializes the panel.
 */
private void initialize() {
    this.setLayout(new GridLayout(0, 1, 10, 10));

    DecimalFormatSymbols symbol = new DecimalFormatSymbols();

    symbol.setDecimalSeparator('.');
    DecimalFormat decimalFormat = new DecimalFormat();
    decimalFormat.setDecimalFormatSymbols(symbol);
    mtFieldFormat = decimalFormat;

    Double expected = firstMoment.evaluate(reliabilityFunction);

    JLabel expectedLabel = new JLabel("Expected Value:");
    JPanel propertiesPanel = createPropertiesPanel(expected, expectedLabel);
    JPanel mttfPanel = createMttfPanel(expected, expectedLabel.getPreferredSize());
    JPanel mtPanel = createMtPanel(expectedLabel.getPreferredSize());

    this.add(propertiesPanel);
    this.add(mttfPanel);
    this.add(mtPanel);

    revalidate();
    repaint();
}

private NumberFormat getInstance(Locale locale,
                                        int choice) {
    if (locale == null) {
        throw new NullPointerException();
    }

    LocaleProviderAdapter adapter = LocaleProviderAdapter.forType(type);
    String[] numberPatterns = adapter.getLocaleResources(locale).getNumberPatterns();
    DecimalFormatSymbols symbols = DecimalFormatSymbols.getInstance(locale);
    int entry = (choice == INTEGERSTYLE) ? NUMBERSTYLE : choice;
    DecimalFormat format = new DecimalFormat(numberPatterns[entry], symbols);

    if (choice == INTEGERSTYLE) {
        format.setMaximumFractionDigits(0);
        format.setDecimalSeparatorAlwaysShown(false);
        format.setParseIntegerOnly(true);
    } else if (choice == CURRENCYSTYLE) {
        adjustForCurrencyDefaultFractionDigits(format, symbols);
    }

    return format;
}

/**
 * Returns the format used by
 * {@link #convertToPresentation(Object, ValueContext)} and
 * {@link #convertToModel(Object, ValueContext)}.
 *
 * @param context
 *            value context to use
 * @return A NumberFormat instance
 */
protected NumberFormat getFormat(ValueContext context) {
    String pattern = null;

    Object data = context.getComponent().map(AbstractComponent.class::cast).map(component -> component.getData())
            .orElse(null);
    if (data instanceof ColumnDefinition) {
        pattern = ((ColumnDefinition) data).getFormat()
                .orElse(configurationProvider.getNumberFormatPattern().orElse(null));
    }

    Locale locale = context.getLocale().orElse(configurationProvider.getLocale());

    if (pattern == null) {
        return NumberFormat.getNumberInstance(locale);
    }

    return new DecimalFormat(pattern, new DecimalFormatSymbols(locale));
}

/**
 * Adjusts the minimum and maximum fraction digits to values that
 * are reasonable for the currency's default fraction digits.
 */
private static void adjustForCurrencyDefaultFractionDigits(
        DecimalFormat format, DecimalFormatSymbols symbols) {
    Currency currency = symbols.getCurrency();
    if (currency == null) {
        try {
            currency = Currency.getInstance(symbols.getInternationalCurrencySymbol());
        } catch (IllegalArgumentException e) {
        }
    }
    if (currency != null) {
        int digits = currency.getDefaultFractionDigits();
        if (digits != -1) {
            int oldMinDigits = format.getMinimumFractionDigits();
            // Common patterns are "#.##", "#.00", "#".
            // Try to adjust all of them in a reasonable way.
            if (oldMinDigits == format.getMaximumFractionDigits()) {
                format.setMinimumFractionDigits(digits);
                format.setMaximumFractionDigits(digits);
            } else {
                format.setMinimumFractionDigits(Math.min(digits, oldMinDigits));
                format.setMaximumFractionDigits(digits);
            }
        }
    }
}

private void initializeTextFields() {

        DecimalFormatSymbols symbols = new DecimalFormatSymbols();
        symbols.setDecimalSeparator('.');

        NumberFormat format = new DecimalFormat("0.00", symbols);
        format.setMaximumFractionDigits(2);

        NumberFormatter formatter = new NumberFormatter(format);
        formatter.setMinimum(0.0);
        formatter.setMaximum(10000000.0);
        formatter.setAllowsInvalid(false);

        this.txtPeso = new JFormattedTextField(formatter);
        this.txtPeso.setValue(0.0);

        GridBagConstraints gbc_textField = new GridBagConstraints();
        gbc_textField.gridwidth = 10;
        gbc_textField.insets = new Insets(0, 0, 5, 0);
        gbc_textField.fill = GridBagConstraints.BOTH;
        gbc_textField.gridx = 2;
        gbc_textField.gridy = 10;
        this.panelSecond.add(this.txtPeso, gbc_textField);
        this.txtPeso.setColumns(10);

    }

public String toYearMonthString()
{
    StringBuffer s = new StringBuffer();
    if (bNegative)
        s.append("-");
    s.append("P");
    if (year != 0) 
    {
        s.append(new DecimalFormat("0", new DecimalFormatSymbols(java.util.Locale.US)).format( (long) java.lang.Math.abs(year) ) );
        s.append("Y");
    }
    if (month != 0) 
    {
        s.append(new DecimalFormat("0", new DecimalFormatSymbols(java.util.Locale.US)).format( (long) java.lang.Math.abs(month) ) );
        s.append("M");
    }
    if (s.length() == 1)
        s.append("0M");
    return s.toString();
}

@Override
protected NumberFormat initialValue() {

    // Always create the formatter for the US locale in order to avoid this bug:
    // https://github.com/indeedeng/java-dogstatsd-client/issues/3
    final NumberFormat numberFormatter = NumberFormat.getInstance(Locale.US);
    numberFormatter.setGroupingUsed(false);
    numberFormatter.setMaximumFractionDigits(6);

    // we need to specify a value for Double.NaN that is recognized by dogStatsD
    if (numberFormatter instanceof DecimalFormat) { // better safe than a runtime error
        final DecimalFormat decimalFormat = (DecimalFormat) numberFormatter;
        final DecimalFormatSymbols symbols = decimalFormat.getDecimalFormatSymbols();
        symbols.setNaN("NaN");
        decimalFormat.setDecimalFormatSymbols(symbols);
    }

    return numberFormatter;
}

private NumberFormat getInstance(Locale locale,
                                        int choice) {
    if (locale == null) {
        throw new NullPointerException();
    }

    LocaleProviderAdapter adapter = LocaleProviderAdapter.forType(type);
    String[] numberPatterns = adapter.getLocaleResources(locale).getNumberPatterns();
    DecimalFormatSymbols symbols = DecimalFormatSymbols.getInstance(locale);
    int entry = (choice == INTEGERSTYLE) ? NUMBERSTYLE : choice;
    DecimalFormat format = new DecimalFormat(numberPatterns[entry], symbols);

    if (choice == INTEGERSTYLE) {
        format.setMaximumFractionDigits(0);
        format.setDecimalSeparatorAlwaysShown(false);
        format.setParseIntegerOnly(true);
    } else if (choice == CURRENCYSTYLE) {
        adjustForCurrencyDefaultFractionDigits(format, symbols);
    }

    return format;
}

public static JSONArray cluster_simplfication(JSONArray coords, double tolerance){
    DecimalFormat df = new DecimalFormat("0.0000");
    DecimalFormatSymbols simbolos = new DecimalFormatSymbols();
    simbolos.setDecimalSeparator('.');
    df.setDecimalFormatSymbols(simbolos);
    double pivotx = coords.getDouble(0);
    double pivoty = coords.getDouble(1);
    JSONArray newcoords = new JSONArray();
    newcoords.put(new Float(df.format(pivotx)));
    newcoords.put(new Float(df.format(pivoty)));
    for(int i=2; i<coords.length(); i++){
        if(Math.sqrt(Math.pow((coords.getDouble(i)-pivotx), 2)+Math.pow((coords.getDouble(i+1)-pivoty), 2)) >= tolerance){
            pivotx = coords.getDouble(i);
            pivoty = coords.getDouble(i+1);
            newcoords.put(new Float(df.format(pivotx)));
            newcoords.put(new Float(df.format(pivoty)));
        }
        i++;
    }
    return newcoords;
}

/**
 * Validates that the given value contains only digits, but not e.g. a
 * character 'd'. Java would interpret the input 3d as double value 3.0.
 * Anyway, this must not succeed.
 * 
 * @param valueToCheck
 *            The value to be checked.
 * @param component
 *            The current component.
 * @return <code>true</code> if the value is valid.
 */
private static boolean validateOnlyDigits(String valueToCheck,
        FacesContext facesContext) {
    Locale locale = LocaleHandler.getLocaleFromString(BaseBean
            .getUserFromSession(facesContext).getLocale());
    DecimalFormatSymbols dfs = new DecimalFormatSymbols(locale);
    boolean decSepFound = false;

    for (char c : valueToCheck.toCharArray()) {
        if (!decSepFound && c == dfs.getDecimalSeparator()) {
            decSepFound = true;
            continue;
        }
        if (c == dfs.getGroupingSeparator()) {
            continue;
        }
        if (!Character.isDigit(c)) {
            return false;
        }
    }

    return true;
}

/** Return a representation of the pattern used by this instance for formatting and
 *  parsing.  The format is similar to, but not the same as the format recognized by the
 *  {@link Builder#pattern} and {@link Builder#localizedPattern} methods.  The pattern
 *  returned by this method is localized, any currency signs expressed are literally, and
 *  optional fractional decimal places are shown grouped in parentheses. */
public String pattern() { synchronized(numberFormat) {
    StringBuilder groups = new StringBuilder();
    for (int group : decimalGroups) {
        groups.append("(").append(Strings.repeat("#", group)).append(")");
    }
    DecimalFormatSymbols s = numberFormat.getDecimalFormatSymbols();
    String digit = String.valueOf(s.getDigit());
    String exp = s.getExponentSeparator();
    String groupSep = String.valueOf(s.getGroupingSeparator());
    String moneySep = String.valueOf(s.getMonetaryDecimalSeparator());
    String zero = String.valueOf(s.getZeroDigit());
    String boundary = String.valueOf(s.getPatternSeparator());
    String minus = String.valueOf(s.getMinusSign());
    String decSep = String.valueOf(s.getDecimalSeparator());

    String prefixAndNumber = "(^|" + boundary+ ")" +
        "([^" + Matcher.quoteReplacement(digit + zero + groupSep + decSep + moneySep) + "']*('[^']*')?)*" +
        "[" + Matcher.quoteReplacement(digit + zero + groupSep + decSep + moneySep + exp) + "]+";

    return numberFormat.toLocalizedPattern().
        replaceAll(prefixAndNumber, "$0" + groups.toString()).
           replaceAll("¤¤", Matcher.quoteReplacement(coinCode())).
           replaceAll("¤", Matcher.quoteReplacement(coinSymbol()));
}}

@Test
public void testgetValueToDisplay() throws Exception {
    final DecimalFormatSymbols dfs = new DecimalFormatSymbols(
            priceConverter.getActiveLocale());
    StringBuffer strMoneyBuffer = new StringBuffer();
    strMoneyBuffer.append("123");
    strMoneyBuffer.append(dfs.getDecimalSeparator());
    strMoneyBuffer.append("45");

    Assert.assertEquals(
            strMoneyBuffer.toString(),
            priceConverter.getValueToDisplay(
                    new BigDecimal(strMoneyBuffer.toString()), true));

    strMoneyBuffer.delete(0, strMoneyBuffer.length());
    strMoneyBuffer.append("123");
    strMoneyBuffer.append(dfs.getDecimalSeparator());
    strMoneyBuffer.append("00");

    Assert.assertEquals(
            "123.00",
            priceConverter.getValueToDisplay(
                    priceConverter.parse(strMoneyBuffer.toString()), true));

}

@Override
public Object apply(Object input, Map<String, Object> args, PebbleTemplate self, EvaluationContext context, int lineNumber) throws PebbleException{
    if (input == null) {
        return null;
    }
    if (!(input instanceof Number)) {
        throw new PebbleException(null, "The input for the 'NumberFormat' filter has to be a number.", lineNumber, self.getName());
    }

    Number number = (Number) input;

    Locale locale = context.getLocale();

    if (args.get("format") != null) {
        Format format = new DecimalFormat((String) args.get("format"), new DecimalFormatSymbols(locale));
        return format.format(number);
    } else {
        NumberFormat numberFormat = NumberFormat.getInstance(locale);
        return numberFormat.format(number);
    }
}

/** Return a representation of the pattern used by this instance for formatting and
 *  parsing.  The format is similar to, but not the same as the format recognized by the
 *  {@link Builder#pattern} and {@link Builder#localizedPattern} methods.  The pattern
 *  returned by this method is localized, any currency signs expressed are literally, and
 *  optional fractional decimal places are shown grouped in parentheses. */
public String pattern() { synchronized(numberFormat) {
    StringBuilder groups = new StringBuilder();
    for (int group : decimalGroups) {
        groups.append("(").append(Strings.repeat("#", group)).append(")");
    }
    DecimalFormatSymbols s = numberFormat.getDecimalFormatSymbols();
    String digit = String.valueOf(s.getDigit());
    String exp = s.getExponentSeparator();
    String groupSep = String.valueOf(s.getGroupingSeparator());
    String moneySep = String.valueOf(s.getMonetaryDecimalSeparator());
    String zero = String.valueOf(s.getZeroDigit());
    String boundary = String.valueOf(s.getPatternSeparator());
    String minus = String.valueOf(s.getMinusSign());
    String decSep = String.valueOf(s.getDecimalSeparator());

    String prefixAndNumber = "(^|" + boundary+ ")" +
        "([^" + Matcher.quoteReplacement(digit + zero + groupSep + decSep + moneySep) + "']*('[^']*')?)*" +
        "[" + Matcher.quoteReplacement(digit + zero + groupSep + decSep + moneySep + exp) + "]+";

    return numberFormat.toLocalizedPattern().
        replaceAll(prefixAndNumber, "$0" + groups.toString()).
           replaceAll("¤¤", Matcher.quoteReplacement(coinCode())).
           replaceAll("¤", Matcher.quoteReplacement(coinSymbol()));
}}

private void _setUpDecimalSymbolFormatProperties(
  DecimalFormatSymbols symbols,
  RequestContext reqCtx,
  Locale locale
  )
{
  if (reqCtx != null)
  {
    char ch = (char) 0;

    if ((ch = reqCtx.getDecimalSeparator()) != (char)0)
      symbols.setDecimalSeparator(ch);

    if ((ch = reqCtx.getNumberGroupingSeparator()) != (char)0)
      symbols.setGroupingSeparator(ch);

  }
  else
  {
    if (_LOG.isWarning())
    {
      _LOG.warning("NULL_REQUESTCONTEXT", locale.toString());
      }
  }
}

private void _setCurrencyInformation(
  RequestContext context,
  DecimalFormatSymbols symbols)
{
  String currencyCode = _getCurrencyCode(context);

  // currencyCode is set we honour currency code.
  if (currencyCode != null)
  {
    symbols.setCurrency(Currency.getInstance(currencyCode));
    return;
  }

  if (getCurrencySymbol() != null)
  {
    symbols.setCurrencySymbol(getCurrencySymbol());

     // Loggin at level INFO - shows up by default - so use fine.
    _LOG.fine("Using currency symbol as currecny code evaluates to null");
  }
  // currency symbol will now default based on the locale.
}

private void _setCurrencyFormattingProperties(
  RequestContext context,
  NumberFormat numberFormatter
 )
{
  // Useless if... should be instanceof DecimalFormat
  // Potential ClassCastException before the change
  //if (numberFormatter instanceof NumberFormat)
  if (numberFormatter instanceof DecimalFormat)
  {
    DecimalFormat dfmt = (DecimalFormat)numberFormatter;
    DecimalFormatSymbols symbols = dfmt.getDecimalFormatSymbols();
    _setCurrencyInformation(context, symbols);
    dfmt.setDecimalFormatSymbols(symbols);
  }
  else
  {  //string cat at compile time.
    _LOG.warning("NUMBER_NOT_DECIMALFORMAT_IGNORE_CURRENCY");
  }
}

private NumberFormat getInstance(Locale locale,
                                        int choice) {
    if (locale == null) {
        throw new NullPointerException();
    }

    LocaleProviderAdapter adapter = LocaleProviderAdapter.forType(type);
    String[] numberPatterns = adapter.getLocaleResources(locale).getNumberPatterns();
    DecimalFormatSymbols symbols = DecimalFormatSymbols.getInstance(locale);
    int entry = (choice == INTEGERSTYLE) ? NUMBERSTYLE : choice;
    DecimalFormat format = new DecimalFormat(numberPatterns[entry], symbols);

    if (choice == INTEGERSTYLE) {
        format.setMaximumFractionDigits(0);
        format.setDecimalSeparatorAlwaysShown(false);
        format.setParseIntegerOnly(true);
    } else if (choice == CURRENCYSTYLE) {
        adjustForCurrencyDefaultFractionDigits(format, symbols);
    }

    return format;
}

public String toString(Object obj){
  DecimalFormatSymbols symbols = new DecimalFormatSymbols(Locale.ROOT);
  symbols.setDecimalSeparator('.');
  symbols.setGroupingSeparator(','); 

  DecimalFormat formatDecimal = new DecimalFormat("#0.00", symbols);
  formatDecimal.setRoundingMode(RoundingMode.HALF_UP);
  return formatDecimal.format((Double) obj);
}

public static String parseToCash( String value) {
    double temp = parseToDouble(value);
    String pattern = "###,###.00";
    DecimalFormatSymbols ds = new DecimalFormatSymbols();
    ds.setDecimalSeparator(',');
    ds.setGroupingSeparator('.');
    DecimalFormat df = new DecimalFormat(pattern,ds);
    df.setGroupingUsed(true);
    return df.format(temp);
}

@Override
public void init() throws OperatorException {
    int localeIndex = getParameterAsInt(PARAMETER_LOCALE);
    Locale selectedLocale = Locale.US;
    if ((localeIndex >= 0) && (localeIndex < availableLocales.size())) {
        selectedLocale = availableLocales.get(getParameterAsInt(PARAMETER_LOCALE));
    }

    int formatType = getParameterAsInt(PARAMETER_FORMAT_TYPE);
    switch (formatType) {
        case FORMAT_TYPE_NUMBER:
            this.numberFormat = NumberFormat.getNumberInstance(selectedLocale);
            break;
        case FORMAT_TYPE_INTEGER:
            this.numberFormat = NumberFormat.getIntegerInstance(selectedLocale);
            break;
        case FORMAT_TYPE_CURRENCY:
            this.numberFormat = NumberFormat.getCurrencyInstance(selectedLocale);
            break;
        case FORMAT_TYPE_PERCENT:
            this.numberFormat = NumberFormat.getPercentInstance(selectedLocale);
            break;
        case FORMAT_TYPE_PATTERN:
            String formatString = getParameterAsString(PARAMETER_PATTERN);
            // the following line only works for Java Versions >= 6
            // this.numberFormat = new DecimalFormat(formatString,
            // DecimalFormatSymbols.getInstance(selectedLocale));
            this.numberFormat = new DecimalFormat(formatString, new DecimalFormatSymbols(selectedLocale));
            break;
    }

    this.numberFormat.setGroupingUsed(getParameterAsBoolean(PARAMETER_USE_GROUPING));
}

public static void setFormatLocale(Locale locale) {
    FORMAT_LOCALE = locale;
    NUMBER_FORMAT = NumberFormat.getInstance(locale);
    INTEGER_FORMAT = NumberFormat.getIntegerInstance(locale);
    PERCENT_FORMAT = NumberFormat.getPercentInstance(locale);
    FORMAT_SYMBOLS = new DecimalFormatSymbols(locale);
}

/**
 * Builds a new CSV measure reader
 * @param measureCsvFile the measure csv file. Muse be a valid file
 * @param logDecimalSeparator the decimal separator
 * @param logCsvDelimiter the CSV delimiter
 */
public VerboseCSVMeasureOutputReader(File measureCsvFile, String logDecimalSeparator, String logCsvDelimiter) {
    this.measureCsvFile = measureCsvFile;
    this.logCsvDelimiter = logCsvDelimiter;
    DecimalFormatSymbols dfs = new DecimalFormatSymbols(Locale.US);
    dfs.setDecimalSeparator(logDecimalSeparator.charAt(0));
    numberParser = new DecimalFormat("#.#", dfs);
    fileSize = measureCsvFile.length();
}

/**
 * Returns this distribution's short description
 * @return distribution's short description
 */
@Override
public String toString() {
    DecimalFormat df = new DecimalFormat("#.############");
    df.setDecimalFormatSymbols(new DecimalFormatSymbols(Locale.ENGLISH));
    Double probability = (Double) parameters[0].getValue();
    return "burst" + "(" + df.format(probability) + "," + parameters[2].getValue() + "," + parameters[4].getValue() + ")";
}

/**
 * Helper method used to formats given number into string according to default rules.
 * @param d double to be converted
 * @return string representation of given number
 */
protected String FormatNumber(double d) {
    DecimalFormat nf = new DecimalFormat();
    nf.setDecimalFormatSymbols(new DecimalFormatSymbols(Locale.ENGLISH));
    String ret = null;
    // If module of number is greater than 1e-3 or lesser than 1e3 uses ordinary notation
    if (Math.abs(d) > 1e-3 && Math.abs(d) < 1e3 || d == 0) {
        nf.applyPattern("#.###");
        ret = nf.format(d);
    } else {
        nf.applyPattern("0.00E00");
        ret = nf.format(d);
    }
    return ret;
}

/**
 * Helper method used to formats given number into string according to default rules.
 * @param d double to be converted
 * @return string representation of given number
 */
protected String FormatNumber(double d) {
    DecimalFormat nf = new DecimalFormat();
    nf.setDecimalFormatSymbols(new DecimalFormatSymbols(Locale.ENGLISH));
    String ret = null;
    // If module of number is greater than 1e-4 or lesser than 1e4 uses ordinary notation
    if (Math.abs(d) > 1e-4 && Math.abs(d) < 1e4 || d == 0) {
        nf.applyPattern("#.####");
        ret = nf.format(d);
    } else {
        nf.applyPattern("0.00E00");
        ret = nf.format(d);
    }
    return ret;
}

public static String format(long amountValue, int exponent, Locale locale) {
    String valueString;
    if (exponent > 0) {
        final String sign = (amountValue < 0) ? "-" : "";
        long absAmountValue = Math.abs(amountValue);
        long power = 1;
        for (int i = 0; i < exponent; i++) {
            power *= 10;
        }
        if (locale != null) {
            DecimalFormatSymbols dfs = DecimalFormatSymbols.getInstance(locale);
            String highValue = NumberFormat.getInstance(locale).format((absAmountValue / power));
            valueString = String.format("%s%s%s%0" + exponent + "d", sign, highValue, dfs.getDecimalSeparator(),
                    (absAmountValue % power));
        } else {
            valueString = String.format("%s%d.%0" + exponent + "d", sign, (absAmountValue / power),
                    (absAmountValue % power));
        }
    } else {
        if (locale != null) {
            valueString = NumberFormat.getInstance(locale).format(amountValue);
        } else {
            valueString = String.valueOf(amountValue);
        }
    }
    return valueString;
}

@Override
public String toString() {
    DecimalFormat format = new DecimalFormat();
    format.setMinimumFractionDigits(precision);
    format.setMaximumFractionDigits(precision);
    DecimalFormatSymbols dfs = format.getDecimalFormatSymbols();
    dfs.setDecimalSeparator(DECIMAL_SEPARATOR);
    format.setDecimalFormatSymbols(dfs);
    format.setGroupingUsed(false);
    return format.format(magnitude) + ((unit == null || unit.isEmpty()) ? "" : "," + getUnit());
}

public static String formatPercentage(double d) {

    // Defining that our percentage is precise down to 0.1%
    DecimalFormat df = new DecimalFormat("0.0");

    // Protecting this method against non-US locales that would not use '.' as decimal separation
    DecimalFormatSymbols decimalFormatSymbols = new DecimalFormatSymbols();
    decimalFormatSymbols.setDecimalSeparator('.');
    df.setDecimalFormatSymbols(decimalFormatSymbols);

    // Making sure that we round the 0.1% properly out of the double value
    df.setRoundingMode(RoundingMode.HALF_UP);
    return df.format(d);
  }

/**
 * Setup user input validation allowed symbols according to current Locale and number type
 */
protected void setupLocaleSymbolsInputValidation() {

    Locale locale = LocalizationContext.getCurrent().filter(l -> l.isLocalized()).flatMap(l -> l.getLocale())
            .orElse(getLocale());
    if (locale == null) {
        // use default
        locale = Locale.getDefault();
    }

    // check grouping
    boolean useGrouping = true;
    if (getInternalField().getConverter() instanceof StringToNumberConverter) {
        NumberFormat nf = ((StringToNumberConverter<?>) getInternalField().getConverter()).getNumberFormat(locale);
        if (nf != null) {
            useGrouping = nf.isGroupingUsed();
        }
    }

    DecimalFormatSymbols dfs = new DecimalFormatSymbols(locale);

    char[] symbols = null;
    if (useGrouping) {
        if (TypeUtils.isDecimalNumber(getType())) {
            symbols = new char[] { dfs.getGroupingSeparator(), dfs.getDecimalSeparator() };
        } else {
            symbols = new char[] { dfs.getGroupingSeparator() };
        }
    } else {
        if (TypeUtils.isDecimalNumber(getType())) {
            symbols = new char[] { dfs.getDecimalSeparator() };
        }
    }

    getInternalField().setAllowedSymbols(symbols);
}

private String printNumber(double value) {
    DecimalFormatSymbols symbols = new DecimalFormatSymbols();
    symbols.setDecimalSeparator('.');
    DecimalFormat formatFloat = new DecimalFormat("0.###", symbols);
    DecimalFormat formatExponent = new DecimalFormat("0.###E0", symbols);

    if (Math.abs(value) > 0.01 && Math.abs(value) < 1000.0 || value == 0.0) {
        return formatFloat.format(value);
    } else {
        return formatExponent.format(value);
    }
}

private String printNumber(double value) {
    DecimalFormatSymbols symbols = new DecimalFormatSymbols();
    symbols.setDecimalSeparator('.');
    DecimalFormat formatFloat = new DecimalFormat("0.###", symbols);
    DecimalFormat formatExponent = new DecimalFormat("0.###E0", symbols);

    if (Math.abs(value) > 0.01 && Math.abs(value) < 1000.0 || value == 0.0) {
        return formatFloat.format(value);
    } else {
        return formatExponent.format(value);
    }
}

public static String printNumber(double value) {
    DecimalFormatSymbols symbols = new DecimalFormatSymbols();
    symbols.setDecimalSeparator('.');
    DecimalFormat formatFloat = new DecimalFormat("0.###", symbols);
    DecimalFormat formatExponent = new DecimalFormat("0.###E0", symbols);

    if (Math.abs(value) > 0.01 && Math.abs(value) < 1000.0 || value == 0.0) {
        return formatFloat.format(value);
    } else {
        return formatExponent.format(value);
    }
}

private static char getZero(Locale l) {
    if ((l != null) && !l.equals(Locale.US)) {
        DecimalFormatSymbols dfs = DecimalFormatSymbols.getInstance(l);
        return dfs.getZeroDigit();
    } else {
        return '0';
    }
}

private static char getZero(Locale l) {
    if ((l != null) && !l.equals(Locale.US)) {
        DecimalFormatSymbols dfs = DecimalFormatSymbols.getInstance(l);
        return dfs.getZeroDigit();
    } else {
        return '0';
    }
}

public String toTimeString(String decimal_format) {
StringBuffer s = new StringBuffer();
s.append( new DecimalFormat("00", new DecimalFormatSymbols(java.util.Locale.US)).format( (long)hour) );
s.append(":");
s.append( new DecimalFormat("00", new DecimalFormatSymbols(java.util.Locale.US)).format( (long)minute) );
s.append(":");
s.append( new DecimalFormat("00", new DecimalFormatSymbols(java.util.Locale.US)).format( (long)second) );
if( partsecond > 0 && partsecond < 1) {
  String sPartSecond = new DecimalFormat(decimal_format, new DecimalFormatSymbols(java.util.Locale.US)).format( partsecond );
  s.append( "." );
  s.append( sPartSecond.substring( 2, sPartSecond.length() ) );
}
if( hasTZ == TZ_UTC ) {
  s.append("Z");
}
else if( hasTZ == TZ_OFFSET ) {
  int absOffsetTZ = offsetTZ;

     if (offsetTZ == 0) {
       s.append("Z");
     }
  else {
       if (offsetTZ < 0) {
      s.append("-");
      absOffsetTZ = -offsetTZ;
    }
    else
      s.append("+");
    s.append(new DecimalFormat("00", new DecimalFormatSymbols(java.util.Locale.US)).format(absOffsetTZ / 60));
    s.append(":");
    s.append(new DecimalFormat("00", new DecimalFormatSymbols(java.util.Locale.US)).format(absOffsetTZ % 60));
     }
}
return s.toString();
 }

/**
 * @return a number formatter instance which prints numbers in a human
 * readable form, like 9_223_372_036_854_775_807.
 */
public static NumberFormat numberFormatter() {
    DecimalFormat df = new DecimalFormat();
    DecimalFormatSymbols dfs = df.getDecimalFormatSymbols();
    dfs.setGroupingSeparator('_');
    dfs.setDecimalSeparator('.');
    df.setDecimalFormatSymbols(dfs);
    return df;
}