Matching Currency Symbols in Java

1. Overview

In this tutorial, we’ll explore how to match and validate currency symbols in Java. This is a common requirement when processing user input for financial applications.

We can match currency symbols using regex for strict validation or NumberFormat for locale-aware parsing. We’ll explore both regular expressions and NumberFormat in this tutorial.

2. Using Regular Expressions

Regular expressions give us full control over the exact format we want to accept. Let’s create a pattern that matches US dollar amounts:

private static final String DOLLAR_PATTERN = "^\\$\\d+(\\.\\d{1,2})?$";

boolean matchesDollarAmount(String input) {
    return Pattern.matches(DOLLAR_PATTERN, input);
}

Let’s break down the pattern:

• ^ and $ are anchors that ensure the entire string matches, not just a substring
• \\$ matches the literal dollar sign (we escape it because $ has special meaning in regex)
• \\d+ matches one or more digits
• (\\.\\d{1,2})? optionally matches a decimal point followed by one or two digits

Anchors ensure the entire string matches, rejecting invalid inputs like “$$$34.00“. Without them, a pattern like \\$\\d+ would match “$34” within “$$$34.00” using Matcher.find().

Let’s verify our pattern works correctly:

@Test
void whenValidDollarAmount_thenMatches() {
    assertTrue(matchesDollarAmount("$100"));
    assertTrue(matchesDollarAmount("$100.00"));
    assertTrue(matchesDollarAmount("$10.5"));
    assertTrue(matchesDollarAmount("$0"));
    assertTrue(matchesDollarAmount("$0.99"));
}

@Test
void whenInvalidDollarAmount_thenDoesNotMatch() {
    assertFalse(matchesDollarAmount("$$$34.00"));
    assertFalse(matchesDollarAmount("$10."));
    assertFalse(matchesDollarAmount("$10.123"));
    assertFalse(matchesDollarAmount("100.00"));
    assertFalse(matchesDollarAmount("$1,000.00"));
}

For amounts with thousands separators, we can extend the pattern:

private static final String DOLLAR_WITH_COMMAS_PATTERN
    = "^\\$\\d{1,3}(,\\d{3})*(\\.\\d{1,2})?$";

boolean matchesDollarAmountWithCommas(String input) {
    return Pattern.matches(DOLLAR_WITH_COMMAS_PATTERN, input);
}

This pattern now accepts amounts like “$1,000.00” and “$1,234,567.89“:

@Test
void whenDollarAmountWithCommas_thenMatches() {
    assertTrue(matchesDollarAmountWithCommas("$1,000.00"));
    assertTrue(matchesDollarAmountWithCommas("$1,234,567.89"));
    assertTrue(matchesDollarAmountWithCommas("$100"));
    assertTrue(matchesDollarAmountWithCommas("$10.5"));
}

Regex gives us precise control, but requires careful pattern design for each format variation.

3. Using NumberFormat

Java’s NumberFormat class provides a simpler alternative for parsing currency values:

Number parseCurrency(String input) {
    try {
        return NumberFormat.getCurrencyInstance(Locale.US).parse(input);
    } catch (ParseException e) {
        return null;
    }
}

This approach automatically handles the US dollar format, including the currency symbol and thousands separators. Let’s test it:

@Test
void whenValidCurrencyFormat_thenParses() {
    assertNotNull(parseCurrency("$789.11"));
    assertNotNull(parseCurrency("$1,234.56"));
    assertNotNull(parseCurrency("$0.99"));
}

However, NumberFormat is lenient and accepts partially valid input like “$12asdf”. It parses as much as it can from the beginning of the string and ignores trailing characters:

@Test
void whenPartiallyValidInput_thenStillParses() {
    assertNotNull(parseCurrency("$12asdf"));
    assertNotNull(parseCurrency("$100abc"));
}

This behavior may or may not be acceptable depending on our validation requirements.

4. Comparison

Each approach has its strengths:

Regex is best for strict validation with full control, while NumberFormat is better for locale-aware parsing with simpler code.

5. Conclusion

In this article, we explored two approaches for matching currency symbols in Java. Regular expressions offer strict validation with full control over the accepted format, while NumberFormat provides simpler, locale-aware parsing at the cost of lenient matching.