Converting Exponential Value in Java to a Number Format

Java parse a number in exponential notation

Use Double.valueOf() and cast the result to long:


Convert exponential values in a String into a decimal representation without exponential notation

Something like this should do the job:

public static void main(String[] args) {
String patternStr = "[0-9.-]*e[0-9.-]*";
String word = "m -263.61653,-131.25745 c -7.5e-4,-1.04175 0.71025,-1.90875 1.67025,-2.16526";
Pattern pattern = Pattern.compile(patternStr);
Matcher matcher = pattern.matcher(word);
if (matcher.find()) {
Double d = Double.valueOf(;
System.out.println(word.replaceAll(patternStr, BigDecimal.valueOf(d).toPlainString()));


Output will be:

m -263.61653,-131.25745 c -0.00075,-1.04175 0.71025,-1.90875 1.67025,-2.16526

Of course if there are multiple exponentials on the String you will have to tweak it a bit.

How do I print a double value without scientific notation using Java?

You could use printf() with %f:

double dexp = 12345678;
System.out.printf("dexp: %f\n", dexp);

This will print dexp: 12345678.000000. If you don't want the fractional part, use

System.out.printf("dexp: %.0f\n", dexp);

0 in %.0f means 0 places in fractional part i.e no fractional part. If you want to print fractional part with desired number of decimal places then instead of 0 just provide the number like this %.8f. By default fractional part is printed up to 6 decimal places.

This uses the format specifier language explained in the documentation.

The default toString() format used in your original code is spelled out here.

Converting exponential into number in java

Try a NumberFormat:

System.out.println(new DecimalFormat("#").format(yourLongNumber));

(You should not create a new format for each output, so reuse it when possible.)

Conversion of double to string gives exponent values

If I understood your problem correctly then you do not need String.valueOf() but String.format().

Here is the code snippet:

public static void main (String[] args) throws Exception
String input = "32,646,513.32";
double value = Double.parseDouble(input.replace(",",""));
String output = String.format("%f",value);
System.out.println("Value: " + output);


Value: 32646513.320000

Replace the following line in your code appropriately:

/* Note the change from `valueOf()` to `format()` */ 

Converting big decimal to double without exponential format

You seem to be confusing a double, a 64 bit value where different bits have a different meaning, with its string representation.

Let's take a value of 0.015625. Internally, the double is represented as 64 bits (I don't know right now which combination of bits, but that is irrelevant anyway).

But the string representation depends on the format settings of the library you are using. Note that the representations 0.015625 and 1.5625E-2 represent the exact same double value. The double is not stored as a string, it does not contain a . or an E, just a number of bits. The combination of these bits form its real value, and it is the same, no matter how you represent it as a string. If you have a different format setting, the result can just as well be 1.56E-2. This just means that the code that converts the internal bit combination of the double to a string does some rounding.

So, to obtain a double from a BigDecimal, simply use bd.doubleValue(). There is no need to use an intermediate string representation, and it can even be detrimental to do so, because if the string representation performs some rounding, you don't get the best approximation of the value in the BigDecimal.

So again, bd.doubleValue() is the only correct way to do this. This does not return a specific format, it simply returns the double that is closest to the value in the BigDecimal.

And again, do not confuse the double type with how it is represented as a string. These are different things. A double is a double is a double, and that is not stored as a string, exponential or plain or rounded or whatever.

Actually, BigDecimal.toString() and BigDecimal.toPlainString() also return different string representations of the same BigDecimal. AFAIK, there is even a third string conversion function, toEngineeringString(), which gives you yet another string representation of the same BigDecimal. This is similar for double: different output routines with different arguments return different strings for the exact same value.

Related Topics

Leave a reply