How do I get whole and fractional parts from double in JSP/Java ? If the value is 3.25 then I want to get `fractional =.25`

, `whole = 3`

How can we do this in Java?

Google would help you if you used the right terms to search “get fractional and whole part out from double java”

http://www.java2s.com/Code/Java/Data-Type/Obtainingtheintegerandfractionalparts.htm

```
double num;
long iPart;
double fPart;
// Get user input
num = 2.3d;
iPart = (long) num;
fPart = num - iPart;
System.out.println("Integer part = " + iPart);
System.out.println("Fractional part = " + fPart);
```

Outputs:

```
Integer part = 2
Fractional part = 0.2999999999999998
```

```
double value = 3.25;
double fractionalPart = value % 1;
double integralPart = value - fractionalPart;
```

Since this 1-year old question was kicked up by someone who corrected the question subject, and this question is been tagged with `jsp`, and nobody here was able to give a JSP targeted answer, here is my JSP-targeted contribution.

Use JSTL (just drop jstl-1.2.jar in `/WEB-INF/lib`

) fmt taglib. There’s a `<fmt:formatNumber>`

tag which does exactly what you want and in a quite easy manner with help of `maxFractionDigits`

and `maxIntegerDigits`

attributes.

Here’s an SSCCE, just copy’n’paste’n’run it.

```
<%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt" %>
<%
// Just for quick prototyping. Don't do this in real! Use servlet/javabean.
double d = 3.25;
request.setAttribute("d", d);
%>
<!doctype html>
<html lang="en">
<head>
<title>SO question 343584</title>
</head>
<body>
<p>Whole: <fmt:formatNumber value="${d}" maxFractionDigits="0" />
<p>Fraction: <fmt:formatNumber value="${d}" maxIntegerDigits="0" />
</body>
</html>
```

Output:

Whole: 3

Fraction: .25

That’s it. No need to massage it with help of raw Java code.

The original question asked for the exponent and mantissa, rather than the fractional and whole part.

To get the exponent and mantissa from a double you can convert it into the IEEE 754 representation and extract the bits like this:

```
long bits = Double.doubleToLongBits(3.25);
boolean isNegative = (bits & 0x8000000000000000L) != 0;
long exponent = (bits & 0x7ff0000000000000L) >> 52;
long mantissa = bits & 0x000fffffffffffffL;
```

Main logic you have to first find how many digits are there after the decimal point.

This code works for any number upto 16 digits. If you use BigDecimal you can run it just for upto 18 digits. put the input value (your number) to the variable “num”, here as an example i have hard coded it.

```
double num, temp=0;
double frac,j=1;
num=1034.235;
// FOR THE FRACTION PART
do{
j=j*10;
temp= num*j;
}while((temp%10)!=0);
j=j/10;
temp=(int)num;
frac=(num*j)-(temp*j);
System.out.println("Double number= "+num);
System.out.println("Whole part= "+(int)num+" fraction part= "+(int)frac);
```

The mantissa and exponent of an IEEE double floating point number are the values such that

```
value = sign * (1 + mantissa) * pow(2, exponent)
```

if the mantissa is of the form 0.101010101_base 2 (ie its most sigificant bit is shifted to be after the binary point) and the exponent is adjusted for bias.

Since 1.6, java.lang.Math also provides a direct method to get the unbiased exponent (called getExponent(double))

However, the numbers you’re asking for are the integral and fractional parts of the number, which can be obtained using

```
integral = Math.floor(x)
fractional = x - Math.floor(x)
```

though you may you want to treat negative numbers differently `(floor(-3.5) == -4.0)`

, depending why you want the two parts.

I’d strongly suggest that you don’t call these mantissa and exponent.

*[Edit: The question originally asked how to get the mantissa and exponent.]*

Where *n* is the number to get the real mantissa/exponent:

```
exponent = int(log(n))
mantissa = n / 10^exponent
```

Or, to get the answer you were looking for:

```
exponent = int(n)
mantissa = n - exponent
```

These are not Java exactly but should be easy to convert.

Don’t know if this is faster but I’m using

```
float fp = ip % 1.0f;
```

What if your number is 2.39999999999999. I suppose you want to get the exact decimal value. Then use BigDecimal:

```
Integer x,y,intPart;
BigDecimal bd,bdInt,bdDec;
bd = new BigDecimal("2.39999999999999");
intPart = bd.intValue();
bdInt = new BigDecimal(intPart);
bdDec = bd.subtract(bdInt);
System.out.println("Number : " + bd);
System.out.println("Whole number part : " + bdInt);
System.out.println("Decimal number part : " + bdDec);
```

Since the `fmt:formatNumber`

tag doesn’t always yield the correct result, here is another JSP-only approach: It just formats the number as string and does the rest of the computation on the string, since that is easier and doesn’t involve further floating point arithmetics.

```
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>
<%
double[] numbers = { 0.0, 3.25, 3.75, 3.5, 2.5, -1.5, -2.5 };
pageContext.setAttribute("numbers", numbers);
%>
<html>
<body>
<ul>
<c:forEach var="n" items="${numbers}">
<li>${n} = ${fn:substringBefore(n, ".")} + ${n - fn:substringBefore(n, ".")}</li>
</c:forEach>
</ul>
</body>
</html>
```

A lot of these answers have horrid rounding errors because they’re casting numbers from one type to another. How about:

```
double x=123.456;
double fractionalPart = x-Math.floor(x);
double wholePart = Math.floor(x);
```

The accepted answer don’t work well for negative numbers between -0 and -1.0

Also give the fractional part negative.

For example:

For number -0,35

returns

Integer part = 0

Fractional part = -0.35

If wou are working with GPS coordinates it is better to have a result with the signum on the integer part as:

Integer part = -0

Fractional part = 0.35

Theses numbers are used for example for GPS coordinates, where are important the signum for Lat or Long position

Propose code:

```
double num;
double iPart;
double fPart;
// Get user input
num = -0.35d;
iPart = (long) num;
//Correct numbers between -0.0 and -1.0
iPart = (num<=-0.0000001 && num>-1.0)? -iPart : iPart ;
fPart = Math.abs(num - iPart);
System.out.println(String.format("Integer part = %01.0f",iPart));
System.out.println(String.format("Fractional part = %01.04f",fPart));
```

Output:

```
Integer part = -0
Fractional part = 0,3500
```

Since Java 8, you can use `Math.floorDiv`

.

It returns the largest (closest to positive infinity) `int`

value that is less than or equal to the algebraic quotient.

Some examples:

```
floorDiv(4, 3) == 1
floorDiv(-4, 3) == -2
```

Alternatively, the `/`

operator can be used:

```
(4 / 3) == 1
(-4 / 3) == -1
```

References:

I would use BigDecimal for the solution. Like this:

```
double value = 3.25;
BigDecimal wholeValue = BigDecimal.valueOf(value).setScale(0, BigDecimal.ROUND_DOWN);
double fractionalValue = value - wholeValue.doubleValue();
```

```
String value = "3.06";
if(!value.isEmpty()){
if(value.contains(".")){
String block = value.substring(0,value.indexOf("."));
System.out.println(block);
}else{
System.out.println(value);
}
}
```

Integer part gets from simple casting and for fractional – string splitting:

```
double value = 123.004567890
int integerPart;
int fractionPart;
/**
* To control zeroes omitted from start after parsing.
*/
int decimals;
integerPart = (int) value; // 123
fractionPart =
Integer.valueOf(
String.valueOf(value)
.split(".")
[1]); // 004567890
decimals =
String.valueOf(value)
.split(".")
[1]
.length(); // 9
```

```
public class MyMain2 {
public static void main(String[] args) {
double myDub;
myDub=1234.5678;
long myLong;
myLong=(int)myDub;
myDub=(myDub%1)*10000;
int myInt=(int)myDub;
System.out.println(myLong + "\n" + myInt);
}
}
```