Converting String to BigDecimal in Java

1. Overview

In this tutorial, we’ll cover many ways of converting String to BigDecimal in Java.

2. BigDecimal

BigDecimal represents an immutable arbitrary-precision signed decimal number. It consists of two parts:

• Unscaled value – an arbitrary precision integer
• Scale – a 32-bit integer representing the number of digits to the right of the decimal point

For example, the BigDecimal 3.14 has an unscaled value of 314 and a scale of 2.

If zero or positive, the scale is the number of digits to the right of the decimal point.

If negative, the unscaled value of the number is multiplied by ten to the power of the negation of the scale. Therefore, the value of the number represented by the BigDecimal is (Unscaled value × 10^-Scale).

The BigDecimal class in Java provides operations for basic arithmetic, scale manipulation, comparison, format conversion, and hashing.

Furthermore, we use BigDecimal for high-precision arithmetic, calculations requiring control over the scale, and rounding off behavior. One such example is calculations involving financial transactions.

We can convert a String into BigDecimal in Java using one of the below methods:

• BigDecimal(String) constructor
• BigDecimal.valueOf() method
• DecimalFormat.parse() method

Let’s discuss each of them below.

3. BigDecimal(String)

The easiest way to convert String to BigDecimal in Java is to use BigDecimal(String) constructor:

BigDecimal bigDecimal = new BigDecimal("123");
assertEquals(new BigDecimal(123), bigDecimal);

4. BigDecimal.valueOf()

We can also convert String to BigDecimal by using the BigDecimal.valueOf(double) method.

This is a two-step process. The first step is to convert the String to Double. The second step is to convert Double to BigDecimal:

BigDecimal bigDecimal = BigDecimal.valueOf(Double.valueOf("123.42"));
assertEquals(new BigDecimal(123.42).setScale(2, BigDecimal.ROUND_HALF_UP), bigDecimal);

It must be noted that some floating-point numbers can’t be exactly represented using a Double value. This is because of the in-memory representation of floating-point numbers of type Double. Indeed, the number is represented in a rational form approaching the entered Double number as much as possible. As a result, some floating-point numbers become inaccurate.

5. DecimalFormat.parse()

When a String representing a value has a more complex format, we can use a DecimalFormat.

For example, we can convert a decimal-based long value without removing non-numeric symbols:

BigDecimal bigDecimal = new BigDecimal(10692467440017.111).setScale(3, BigDecimal.ROUND_HALF_UP);

DecimalFormatSymbols symbols = new DecimalFormatSymbols();
symbols.setGroupingSeparator(',');
symbols.setDecimalSeparator('.');
String pattern = "#,##0.0#";
DecimalFormat decimalFormat = new DecimalFormat(pattern, symbols);
decimalFormat.setParseBigDecimal(true);

// parse the string value
BigDecimal parsedStringValue = (BigDecimal) decimalFormat.parse("10,692,467,440,017.111");

assertEquals(bigDecimal, parsedStringValue);

The DecimalFormat.parse method returns a Number, which we convert to a BigDecimal number using the setParseBigDecimal(true).

Usually, the DecimalFormat is more advanced than we require. Thus, we should favor the new BigDecimal(String) or the BigDecimal.valueOf() instead.

6. Invalid Conversions

Java provides generic exceptions for handling invalid numeric Strings.

Notably, new BigDecimal(String), BigDecimal.valueOf(), and DecimalFormat.parse throw a NullPointerException when we pass null:

@Test(expected = NullPointerException.class)
public void givenNullString_WhenBigDecimalObjectWithStringParameter_ThenNullPointerExceptionIsThrown() {
    String bigDecimal = null;
    new BigDecimal(bigDecimal);
}

@Test(expected = NullPointerException.class)
public void givenNullString_WhenValueOfDoubleFromString_ThenNullPointerExceptionIsThrown() {
    BigDecimal.valueOf(Double.valueOf(null));
}

@Test(expected = NullPointerException.class)
public void givenNullString_WhenDecimalFormatOfString_ThenNullPointerExceptionIsThrown()
  throws ParseException {
    new DecimalFormat("#").parse(null);
}

Similary, new BigDecimal(String) and BigDecimal.valueOf() throw a NumberFormatException when we pass an invalid String that can’t be parsed to a BigDecimal (such as &):

@Test(expected = NumberFormatException.class)
public void givenInalidString_WhenBigDecimalObjectWithStringParameter_ThenNumberFormatExceptionIsThrown() {
    new BigDecimal("&");
}

@Test(expected = NumberFormatException.class)
public void givenInalidString_WhenValueOfDoubleFromString_ThenNumberFormatExceptionIsThrown() {
    BigDecimal.valueOf(Double.valueOf("&"));
}

Lastly, DecimalFormat.parse throws a ParseException when we pass an invalid String:

@Test(expected = ParseException.class)
public void givenInalidString_WhenDecimalFormatOfString_ThenNumberFormatExceptionIsThrown()
  throws ParseException {
    new DecimalFormat("#").parse("&");
}

7. Convert a String Number Value with a Dollar Sign to BigDecimal

Sometimes, numeric values are represented as strings that include a dollar sign, such as “$348.45”. The BigDecimal constructor accepts only valid numeric strings, so we need to remove the currency symbol or use a parsing utility before conversion.

7.1. Removing the Dollar Sign

The simplest approach is to remove the dollar symbol and any non-numeric characters before creating a BigDecimal:

@Test
public void givenStringWithDollarSign_whenRemovedAndConvertedToBigDecimal_thenReturnExpectedValue() {
    String salePrice = "$348.45";
    String price = salePrice.replace("$", "");
    BigDecimal amount = new BigDecimal(price);

    assertEquals(new BigDecimal("348.45"), amount);
}

This method works well when the format is predictable and uses a single currency, such as USD.

7.2. Using NumberFormat with Locale

For locale-aware parsing or international currency formats, we can use the NumberFormat class. It automatically interprets the correct currency symbol and formatting rules for a given locale, which makes it ideal for converting localized currency strings into BigDecimal values.

To illustrate this, let’s start with a U.S. currency example:

@Test
public void givenStringWithDollarSign_whenParsedWithNumberFormat_thenReturnExpectedValue() throws ParseException {
    String salePrice = "$348.45";
    Locale locale = Locale.US;

    Number number = NumberFormat.getCurrencyInstance(locale).parse(salePrice);
    BigDecimal amount = new BigDecimal(number.toString());

    assertEquals(new BigDecimal("348.45"), amount);
}

In this test, NumberFormat.getCurrencyInstance(Locale.US) parses a currency string formatted according to U.S. conventions. It recognizes the dollar sign ($) and the dot (.) as the decimal separator and converts the string to a BigDecimal value of “348.45”. This approach works well for predictable, single-locale inputs such as those using U.S. currency formatting.

To demonstrate how NumberFormat adapts to other regional conventions, let’s consider a second example that uses the euro symbol (€) and a European locale:

@Test
public void givenEuroCurrencyString_whenParsedWithNumberFormat_thenReturnExpectedValue() throws ParseException {
    String salePrice = "348,45\u00A0€";
    Locale locale = Locale.FRANCE;

    Number number = NumberFormat.getCurrencyInstance(locale).parse(salePrice);
    BigDecimal amount = new BigDecimal(number.toString());

    assertEquals(new BigDecimal("348.45"), amount);
}

In many European locales, such as France, the comma (,) is used as the decimal separator, and the euro symbol (€) appears after the number, separated by a non-breaking space (\u00A0). Using NumberFormat.getCurrencyInstance(Locale.FRANCE) applies these formatting rules automatically, allowing the parser to interpret “348,45 €” correctly and produce the expected BigDecimal value of 348.45.

By relying on locale-specific NumberFormat instances, we can accurately handle currency strings from different regions, ensuring reliable numeric conversion in internationalized applications.

8. Conclusion

In this article, we learned that Java provides us with multiple methods to convert String to BigDecimal values. In general, we recommend using the new BigDecimal(String) method for this purpose.