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?
double value = 3.25;
double fractionalPart = value % 1;
double integralPart = value - fractionalPart;
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
2.3, but surely not 2.3. And there's nothing wrong with the output, unless you want much more than 10 valid digits. All you need is some rounding in each output (e.g., format %.9f) which is usually less pain than BigDecimal. The only problem here is the overflow.
(long)1.0e100 you will get 0. A lot of the times you need the double value simply "floored" for which there is floor(). If you want both integral and fraction parts use modf(). Really, this is a bad answer.
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;
Don't know if this is faster but I'm using
float fp = ip % 1.0f;
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.
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>
fmt:formatNumber rounds its argument, which is not wanted in this case.
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);
Math.abs?
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:
Java 8 : Math.floorDiv(int,int)
Java 8 : Math.floorDiv(long,long)
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);
}
}
OK this is maybe late, but i think the best and more accurate approach is using BigDecimal
double d = 11.38;
BigDecimal bigD = BigDecimal.valueOf(d);
int intPart = bigD.intValue();
double fractionalPart = bigD.subtract(BigDecimal.valueOf(intPart)).doubleValue();
System.out.println(intPart); // 11
System.out.println(fractionalPart ); //0.38
input (5.03) output int = 5 , fractional = 0.0299999 , we are talking about inputs and outputs, u put value and get back your value without losing 0.001% of it! and this accurate, not misleading!
// target float point number
double d = 3.025;
// transfer the number to string
DecimalFormat df = new DecimalFormat();
df.setDecimalSeparatorAlwaysShown(false);
String format = df.format(d);
// split the number into two fragments
int dotIndex = format.indexOf(".");
int iPart = Integer.parseInt(format.substring(0, dotIndex)); // output: 3
double fPart = Double.parseDouble(format.substring(dotIndex)); // output: 0.025
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);
}
}
Follow WeChat
Success story sharing
Want to stay one step ahead of the latest teleworks?
Subscribe Now相似问题
- How do I call one constructor from another in Java?
- How do I read / convert an InputStream into a String in Java?
- What's the simplest way to print a Java array?
- How to get an enum value from a string value in Java
- Does Java support default parameter values?
- How can I get the current stack trace in Java?
- How can I avoid Java code in JSP files, using JSP 2?
- How to get the current working directory in Java?
- Why is subtracting these two times (in 1927) giving a strange result?
- Why is processing a sorted array faster than processing an unsorted array?
%to mean modulo (-3.25 % 1 == 0.75) and others, such as Java, Fortran, C, and C++, use%to mean remainder (-3.25 % 1 == -0.25). WindRider may have typed it into a Python REPL for expediency, but that answer is misleading because this question is about the JVM.