## How do I parse negative number in parentheses?

In financial application negative numbers are often represented in parentheses. In this post we will learn how we can parse or convert the negative number in parentheses to produce the represented number value. To parse text / string to a number we can use the `java.text.DecimalFormat` class.

Beside number in parentheses, in this example we also parse negative number that use the minus sign with the currency symbol like `\$`. Let’s jump to the code snippet below:

``````package org.kodejava.text;

import java.text.DecimalFormat;

public class NegativeNumberParse {
// Pattern for parsing negative number.
public static final String PATTERN1 = "#,##0.00;(#,##0.00)";
public static final String PATTERN2 = "\$#,##0.00;-\$#,##0.00";

public static void main(String[] args) throws Exception {
DecimalFormat df = new DecimalFormat(PATTERN1);

String number1 = "(1000)";
String number2 = "(1,500.99)";

System.out.println("number1 = " + df.parse(number1));
System.out.println("number2 = " + df.parse(number2));

df = (DecimalFormat) DecimalFormat.getInstance();
df.applyPattern(PATTERN2);

String number3 = "-\$1000";
String number4 = "-\$1,500.99";

System.out.println("number3 = " + df.parse(number3));
System.out.println("number4 = " + df.parse(number4));
}
}
``````

And here are the results of our code snippet above:

``````number1 = -1000
number2 = -1500.99
number3 = -1000
number4 = -1500.99
``````

If you need to display or format negative numbers in parentheses you can take a look at the following example How do I display negative number in parentheses?.

## How do I display negative number in parentheses?

The code snippet below show us how to display or format negative number in parentheses. We start by defining the number format, the pattern has two parts separated by a semicolon. In the snippet we use the `#,##0.00;(#,##0.00)` pattern. The pattern after the semicolon will be used to format negative number.

Next we create an instance of `DecimalFormat` by calling `getInstance()` method. We apply the format pattern for the formatter object by calling the `applyPattern()` method of the `DecimalFormat` instance. To format the number we simply call the `format()` method and pass the number we are going to format for display or print out.

``````package org.kodejava.text;

import java.text.DecimalFormat;

public class NegativeNumberFormat {
// Pattern for formatting negative number.
public static final String PATTERN1 = "#,##0.00;(#,##0.00)";
public static final String PATTERN2 = "\$#,##0.00;-\$#,##0.00";

public static void main(String[] args) {
DecimalFormat df = (DecimalFormat) DecimalFormat.getInstance();
df.applyPattern(PATTERN1);

// Format using parentheses
System.out.println("Positive: " + df.format(125));
System.out.println("Negative: " + df.format(-125));

// Format using currency symbol and minus sign
df.applyPattern(PATTERN2);
System.out.println("Positive: " + df.format(1000));
System.out.println("Negative: " + df.format(-1000));
}
}
``````

The result of the code snippet above is:

``````Positive: 125.00
Negative: (125.00)
Positive: \$1,000.00
Negative: -\$1,000.00
``````

If you need to parse negative numbers in parentheses to produce the represented number you can see the following example How do I parse negative number in parentheses?.

## How do I change the currency symbol?

This example show you how to change the currency symbol for the defined locale using the `DecimalFormatSymbols.setCurrencySymbol()` method. After changing the currency symbol, the `DecimalFormatSymbols` instance is passed to the `DecimalFormat` object which does the formatting.

``````package org.kodejava.text;

import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.text.NumberFormat;
import java.util.Locale;

public class CurrencyFormatSymbols {
public static void main(String[] args) {
double number = 123456.789;

Locale[] locales = {
};

String[] symbols = {"CAD", "EUR", "GBP", "ITL", "USD"};

for (int i = 0; i < locales.length; i++) {
// Gets currency's formatted value for each locale
// without change the currency symbol
DecimalFormat formatter =
(DecimalFormat) NumberFormat.getCurrencyInstance(locales[i]);
String before = formatter.format(number);

// Create a DecimalFormatSymbols for each locale and sets
// its new currency symbol.
DecimalFormatSymbols symbol = new DecimalFormatSymbols(locales[i]);
symbol.setCurrencySymbol(symbols[i]);

// Set the new DecimalFormatSymbols into formatter object.
formatter.setDecimalFormatSymbols(symbol);

// Gets the formatted value
String after = formatter.format(number);
System.out.println(locales[i].getDisplayCountry() +
" | before: " + before + " | after: " + after);
}
}
}
``````

Here is are the result of our program:

``````Canada | before: \$123,456.79 | after: CAD123,456.79
Germany | before: 123.456,79 € | after: 123.456,79 EUR
United Kingdom | before: £123,456.79 | after: GBP123,456.79
Italy | before: € 123.456,79 | after: ITL 123.456,79
United States | before: \$123,456.79 | after: USD123,456.79
``````

## How do I change number format symbols?

You can use the `DecimalFormatSymbols` class to change the symbols that appear in the formatted numbers. These symbols include the decimal separator which can be changed using the `setDecimalSeparator()`, the grouping separator which can be change using the `setGroupingSeparator()` method. You can also alter the minus sign, and the percent sign, among others.

``````package org.kodejava.text;

import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.util.Locale;

public class NumberFormatSymbol {
public static void main(String[] args) {
DecimalFormat formatter;
String pattern = "###,###.##";
double number = 123456.789;

// Create a DecimalFormatSymbols object for the United States
// locale.
DecimalFormatSymbols dfs = new DecimalFormatSymbols(Locale.US);

// Create a format object with the given pattern without
// change the locale dfs then format the given value.
formatter = new DecimalFormat(pattern);
String before = formatter.format(number);

// Change the decimal separator and grouping separator symbol.
dfs.setDecimalSeparator(',');
dfs.setGroupingSeparator('.');
dfs.setMinusSign('-');
dfs.setPercent('%');

// Create a format object with the given pattern and symbol
// then format the given value.
formatter = new DecimalFormat(pattern, dfs);
String after = formatter.format(number);

System.out.println("before: " + before + " | after: " + after);
}
}
``````

## How do I change DecimalFormat pattern?

To change the pattern use by the `DecimalFormat` when formatting a number we can use the `DecimalFormat.applyPattern()` method call. In this example we use three different patterns to format the given input number. The pattern determines what the formatted number looks like.

``````package org.kodejava.text;

import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.util.Locale;

public class FormatterPattern {
public static void main(String[] args) {
String[] patterns = {"###,###,###.##", "000000000.00", "\$###,###.##"};

double before = 1234567.899;

// To obtain a NumberFormat for a specific locale,
// including the default locale, call one of NumberFormat's
// factory methods, such as getNumberInstance(). Then cast
// it into a DecimalFormat.
DecimalFormat format =
(DecimalFormat) NumberFormat.getNumberInstance(Locale.UK);
for (String pattern : patterns) {
// Apply the given pattern to this Format object
format.applyPattern(pattern);

// Gets the formatted value
String after = format.format(before);

System.out.printf("Input: %s, Pattern: %s, Output: %s%n",
before, pattern, after);
}
}
}
``````

The output of the program shown below:

``````Input: 1234567.899, Pattern: ###,###,###.##, Output: 1,234,567.9
Input: 1234567.899, Pattern: 000000000.00, Output: 001234567.90
Input: 1234567.899, Pattern: \$###,###.##, Output: \$1,234,567.9
``````

## How do I format a number with leading zeros?

This example give you an example using `java.text.DecimalFormat` class to add leading zeros to a number. For another method you can read the see the earlier example on How do I add leading zeros to a number?.

``````package org.kodejava.text;

import java.text.DecimalFormat;
import java.text.NumberFormat;

public static void main(String[] args) {
NumberFormat formatter = new DecimalFormat("0000000");
String number = formatter.format(2500);

System.out.println("Number with leading zeros: " + number);
}
}
``````

The result of code snippet above:

``````Number with leading zeros: 0002500
``````

## How do I format a number?

If you want to display some numbers that is formatted to a certain pattern, either in a Java Swing application or in a JSP file, you can utilize `NumberFormat` and `DecimalFormat` class to give you the format that you want. Here is a small example that will show you how to do it.

In the code snippet below we start by creating a `double` variable that contains some value. By default, the `toString()` method of the `double` data type will print the money value using a scientific number format as it is greater than `10^7` (10,000,000.00). To be able to display the number without scientific number format we can use `java.text.DecimalFormat` which is a sub class of `java.text.NumberFormat`.

We create a formatter using `DecimalFormat` class with a pattern of `#0.00`. The `#` symbol means any number but leading zero will not be displayed. The `0` symbol will display the remaining digit and will display as zero if no digit is available.

``````package org.kodejava.text;

import java.text.DecimalFormat;
import java.text.NumberFormat;

public class DecimalFormatExample {
public static void main(String[] args) {
// We have some millions money here that we'll format its look.
double money = 100550000.75;

// Creates a formatter
NumberFormat formatter = new DecimalFormat("#0.00");

// Print the number using scientific number format and using our
// defined decimal format pattern above.
System.out.println(money);
System.out.println(formatter.format(money));
}
}
``````

Here is the different result of the code above.

``````1.0055000075E8
100550000.75
``````