The problem is that you are using a static method NumberFormat.getCurrencyInstance() that works that way:

public final static NumberFormat getCurrencyInstance() {
    return getInstance(Locale.getDefault(Locale.Category.FORMAT), CURRENCYSTYLE);
}

As you can see, it returns a NumberFormat object with a default Locale, not the Locale you are setting. That means it depends on user device settings.

So, instead of calling format on that statically returned instance with default Locale:

nf.getCurrencyInstance().format(parsed / 100);

which is effectively the same as:

NumberFormat.getCurrencyInstance().format(parsed / 100);

Use your instance with Locale that you've set:

final NumberFormat nf = NumberFormat.getInstance(Locale.US);
String formatted = nf.format(parsed / 100);

Another approach :

NumberFormat format = NumberFormat.getCurrencyInstance();
format.setMaximumFractionDigits(0);
format.setCurrency(Currency.getInstance("EUR"));

format.format(1000000);

This way, it's displaying 1 000 000 € or 1,000,000 €, depending on device currency's display settings

You can try some like this:

public class MainActivity extends AppCompatActivity {


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Utils.getCurrencySymbol(Currency.getInstance(Locale.US).getCurrencyCode());
        Utils.getCurrencySymbol(Currency.getInstance(Locale.JAPAN).getCurrencyCode());
        Utils.getCurrencySymbol(Currency.getInstance(Locale.UK).getCurrencyCode());

        //for your case that you want to get Euro symbol because France are with Euro symnol    
        Utils.getCurrencySymbol(Currency.getInstance(Locale.FRANCE).getCurrencyCode());
        //you can get symbol also if you write string of your desired currency
        Utils.getCurrencySymbol("INR");


    }


    static class Utils {
        public static SortedMap<Currency, Locale> currencyLocaleMap;

        static {
            currencyLocaleMap = new TreeMap<Currency, Locale>(new Comparator<Currency>() {
                public int compare(Currency c1, Currency c2) {
                    return c1.getCurrencyCode().compareTo(c2.getCurrencyCode());
                }
            });
            for (Locale locale : Locale.getAvailableLocales()) {
                try {
                    Currency currency = Currency.getInstance(locale);
                    currencyLocaleMap.put(currency, locale);
                } catch (Exception e) {
                }
            }
        }


        public static String getCurrencySymbol(String currencyCode) {
            Currency currency = Currency.getInstance(currencyCode);
            System.out.println(currencyCode + ":-" + currency.getSymbol(currencyLocaleMap.get(currency)));
            return currency.getSymbol(currencyLocaleMap.get(currency));
        }

    }
}

For sake of completeness suppose you want to display a price in phone's current locale (correct decimal mark and thousand separator) but with a currency of your choice.

NumberFormat format = NumberFormat.getCurrencyInstance(Locale.getDefault());
format.setCurrency(Currency.getInstance("CZK"));
String result = format.format(1234567.89);

result would then hold these values:

• CZK1,234,567.89 with US locale
• 1 234 567,89 Kč with Czech locale

If you'd like to omit the decimal part for prices (show $199 instead of $199.00) call this before using the formatter:

format.setMinimumFractionDigits(0);

All options are listed in NumberFormat docs.

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));

Firstly, I realised my language was set to "English (United Kingdom)" which was why the price was being displayed in pounds when using format.currency = Currency.getInstance(Locale.getDefault()). So changing my language to English (Singapore) fixed the issue.

However, I still wanted to display the currency based on the given currencyCode parameter in the function despite the default locale.

Thus, I managed to use the newer NumberFormatter api to achieve this:

fun getMonthlyPriceString(yearlyPriceMicros: Long, currencyCode: String): String {
    val monthlyPrice = yearlyPriceMicros.toFloat() / 1_000_000f / 12

    return NumberFormatter.with()
            .unit(Currency.getInstance(currencyCode)) // <-- Can pass the currency code from the function parameter here
            .precision(Precision.currency(Currency.CurrencyUsage.STANDARD)) // <-- This handles the decimal places for you
            .locale(Locale.getDefault()) // <-- Will still show the correct currency but in the user's locale
            .format(monthlyPrice)
            .toString()
}

Note that NumberFormatter is only available from SDK Level 30 (Android 11) and above.

The behaviour of the method is correct.

Not all countries expect the currency symbol before the amount.

If you always want the currency format to match an Americanised expectation, leave the locale as Locale.US. If you want the currency to display in a localised way, leave your implementation as is.

See this brief guide (from Microsoft, no less):

Currency Formatting

I'd guess what you may be trying to achieve is to display the currency in a format appropriate to its locale? If that's the case, just match the locale to the currency you're using, before calling the method.

Note that the format can even vary in the same country. In Canada, it's reasonably common to see English speakers use the format $50.00, whereas French-Canadians may use 50,00 $.

Also see this question on UX:

https://ux.stackexchange.com/questions/22574/where-to-place-currency-symbol-when-localizing-and-what-to-do-with-odd-symbols

    Locale locale = Locale.getDefault();
    Currency currency = Currency.getInstance(locale);
    String symbol = currency.getSymbol().replaceAll("\\w", "");

You can put symbols directly into your format pattern and surround them with apostrophes (just in case they are a pattern symbol) instead of using the currency symbol notation.

fun main() {
    val input = 5.47
    val symbol = '\u263a'
    val result = DecimalFormat("'$symbol'#.##").format(input)
    println(result)
}