No need to reinvent the wheel. DecimalFormat comes with currency support:

String output = DecimalFormat.getCurrencyInstance().format(123.45);

This also comes with full locale support by optionally passing in a Locale:

String output = DecimalFormat.getCurrencyInstance(Locale.GERMANY).format( 123.45);

Here's a test:

System.out.println(DecimalFormat.getCurrencyInstance().format( 123.45) );
System.out.println(DecimalFormat.getCurrencyInstance(Locale.GERMANY).format( 123.45)) ;

Output:

$123.45
123,45 €

Different currencies can also place the currency symbol before or after the string, or have a different number of decimal places (if any). It is not really clear from your question how you want to handle those cases, but assuming you want to preserve those differences, try this.

Instead of just swapping in the currency symbol into your local number format, you could start with the foreign format and substitute the decimal format symbols with your local version. Those also include the currency, so you have to swap that back (don't worry, it's a copy).

public static NumberFormat localStyleForeignFormat(Locale locale) {
    NumberFormat format = NumberFormat.getCurrencyInstance(locale);
    if (format instanceof DecimalFormat) {
        DecimalFormat df = (DecimalFormat) format;
        // use local/default decimal symbols with original currency symbol
        DecimalFormatSymbols dfs = new DecimalFormat().getDecimalFormatSymbols();
        dfs.setCurrency(df.getCurrency());
        df.setDecimalFormatSymbols(dfs);
    }
    return format;
}

This way, you also retain the correct positioning of the currency symbol and the number of decimal places. Some examples, for default-Locale Locale.UK

en_GB   £500,000.00     £500,000.00
fr_FR   500 000,00 €    500,000.00 €
it_IT   € 500.000,00    € 500,000.00
ja_JP   ￥500,000       JPY500,000
hi_IN   रू ५००,०००.००    INR 500,000.00

If you also want to preserve the foreign currency symbol, instead of the local equivalent, use

localDfs.setCurrencySymbol(df.getCurrency().getSymbol(locale));

Try using setCurrency on the instance returned by getCurrencyInstance(Locale.GERMANY)

Broken:

java.text.NumberFormat format = java.text.NumberFormat.getCurrencyInstance(java.util.Locale.GERMANY);
System.out.println(format.format(23));

Output: 23,00 €

Fixed:

java.util.Currency usd = java.util.Currency.getInstance("USD");
java.text.NumberFormat format = java.text.NumberFormat.getCurrencyInstance(java.util.Locale.GERMANY);
format.setCurrency(usd);
System.out.println(format.format(23));

Output: 23,00 USD

Whenever you display a currency, you need two pieces of info: the currency code, and the locale for which you are displaying a result. For example, when you display USD in the en_US locale, you want it to show $, but in the en_AU locale, you want it to show as US$ (because Australia's currency is also called "dollars" and they use the $ symbol for AUD).

The issue you've hit is that the stock Java currency formatters stink when you are displaying a currency in its "non-primary" locale. That is, pretty much everyone in the US would rather see £ and € when showing pounds and euros, but the stock Java libraries show "GBP" and "EUR" when showing those currencies in the en_US locale.

I got around this with the following piece of code. I essentially specify my own symbols to use when displaying international currencies:

public static NumberFormat newCurrencyFormat(Currency currency, Locale displayLocale) {
    NumberFormat retVal = NumberFormat.getCurrencyInstance(displayLocale);
    retVal.setCurrency(currency);

    //The default JDK handles situations well when the currency is the default currency for the locale
    if (currency.equals(Currency.getInstance(displayLocale))) {
        return retVal;
    }

    //otherwise we need to "fix things up" when displaying a non-native currency
    if (retVal instanceof DecimalFormat) {
        DecimalFormat decimalFormat = (DecimalFormat) retVal;
        String correctedI18NSymbol = getCorrectedInternationalCurrencySymbol(currency, displayLocale);
        if (correctedI18NSymbol != null) {
            DecimalFormatSymbols dfs = decimalFormat.getDecimalFormatSymbols(); //this returns a clone of DFS
            dfs.setInternationalCurrencySymbol(correctedI18NSymbol);
            dfs.setCurrencySymbol(correctedI18NSymbol);
            decimalFormat.setDecimalFormatSymbols(dfs);
        }
    }

    return retVal;
}

private static String getCorrectedInternationalCurrencySymbol(Currency currency, Locale displayLocale) {
    ResourceBundle i18nSymbolsResourceBundle =
            ResourceBundle.getBundle("correctedI18nCurrencySymbols", displayLocale);
    if (i18nSymbolsResourceBundle.containsKey(currency.getCurrencyCode())) {
        return i18nSymbolsResourceBundle.getString(currency.getCurrencyCode());
    } else {
        return currency.getCurrencyCode();
    }
}

Then I have my properties file (correctedI18nCurrencySymbols.properties) where I specify currency symbols to use:

# Note that these are the currency symbols to use for the specified code when displaying in a DIFFERENT locale than
# the home locale of the currency. This file can be edited as needed. In addition, if in some case one specific locale
# would use a symbol DIFFERENT than the standard international one listed here, then an additional properties file
# can be added making use of the standard ResourceBundle loading algorithm. For example, if we decided we wanted to
# show US dollars as just $ instead of US$ when in the UK, we could create a file i18nCurrencySymbols_en_GB.properties
# with the entry USD=$
ARS=$AR
AUD=AU$
BOB=$b
BRL=R$
CAD=CAN$
CLP=Ch$
COP=COL$
CRC=\u20A1
HRK=kn
CZK=K\u010D
DOP=RD$
XCD=EC$
EUR=\u20AC
GTQ=Q
GYD=G$
HNL=L
HKD=HK$
HUF=Ft
INR=\u20B9
IDR=Rp
ILS=\u20AA
JMD=J$
JPY=JP\u00A5
KRW=\u20A9
NZD=NZ$
NIO=C$
PAB=B/.
PYG=Gs
PEN=S/.
PHP=\u20B1
PLN=\u007A\u0142
RON=lei
SGD=S$
ZAR=R
TWD=NT$
THB=\u0E3F
TTD=TT$
GBP=\u00A3
USD=US$
UYU=$U
VEF=Bs
VND=\u20AB

@artjomka

I was able to reproduce your problem by setting my default locale to Latvia

Locale.setDefault(new Locale("lv","LV"));
Currency c  = Currency.getInstance("EUR");
System.out.println(c.getSymbol());

This gave me the output of "EUR".

However, by leaving setting my locale to Uk (already my default) I get the symbol for the Euro(€).

Locale.setDefault(Locale.UK);
Currency c  = Currency.getInstance("EUR");
System.out.println(c.getSymbol());

Does it have to use DecimalFormat?

If not, it looks like the following should work:

String currencyString = NumberFormat.getCurrencyInstance().format(currencyNumber);
//Handle the weird exception of formatting whole dollar amounts with no decimal
currencyString = currencyString.replaceAll("\\.00", "");