JSP / Java의 double에서 전체 및 부분 부분을 어떻게 얻습니까?
JSP / Java의 double에서 전체 및 부분 부분을 어떻게 얻습니까? 값이 3.25이면을 얻고 싶습니다 fractional =.25.whole = 3
Java에서 어떻게 할 수 있습니까?
"더블 자바에서 부분 및 전체 부분 가져 오기"를 검색하는 데 올바른 용어를 사용했다면 Google이 도움을 드릴 것입니다.
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);
출력 :
Integer part = 2
Fractional part = 0.2999999999999998
double value = 3.25;
double fractionalPart = value % 1;
double integralPart = value - fractionalPart;
이 1 년 된 질문은 질문 주제를 수정 한 사람에 의해 시작되었고이 질문에으로 태그가 지정 jsp되었고 여기에 아무도 JSP 대상 답변을 제공 할 수 없었기 때문에 여기에 JSP 대상 기여가 있습니다.
JSTL을 사용하십시오 ( jstl-1.2.jar 를 /WEB-INF/lib) fmt taglib. <fmt:formatNumber>당신이 원하는 것을 정확히 maxFractionDigits하고 maxIntegerDigits속성의 도움으로 아주 쉬운 방식으로 하는 태그 가 있습니다 .
여기에 SSCCE가 있습니다. copy'n'paste'n'run 입니다.
<%@ 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>
산출:
전체 : 3
분수 : .25
그게 다야. 원시 Java 코드를 사용하여 마사지 할 필요가 없습니다.
원래 질문은 분수와 전체 부분이 아닌 지수와 가수를 요구했습니다.
double에서 지수와 가수를 얻으려면 IEEE 754 표현 으로 변환하고 다음 과 같이 비트를 추출 할 수 있습니다 .
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);
Don't know if this is faster but I'm using
float fp = ip % 1.0f;
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.
Integer part gets from simple casting and for fractional - string splitting:
double value = 123.004567890
int integerPart = (int) value; // 123
int fractionPart =
Integer.valueOf(String.valueOf(value)
.split(".")[1]); // 004567890
/**
* To control zeroes omitted from start after parsing.
*/
int decimals =
String.valueOf(value)
.split(".")[1].length(); // 9
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);
}
}
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);
}
}
'code' 카테고리의 다른 글
| UIView 레이어의 내부 그림자 효과? (0) | 2020.09.02 |
|---|---|
| 숫자를 백분율로 (0) | 2020.09.02 |
| 파이썬에서 한 줄 ftp 서버 (0) | 2020.09.02 |
| 유형을 이동 만 가능하고 복사 불가능하게 만들 수 있습니까? (0) | 2020.09.01 |
| PHP에서 "=>"는 무엇을 의미합니까? (0) | 2020.09.01 |