Comment puis-je obtenir des parties entières et fractionnelles de double en JSP/Java?
Comment obtenir des parties entières et fractionnaires de double en JSP / Java ? Si la valeur est 3.25 alors je veux obtenir fractional =.25 , whole = 3
Comment Pouvons-nous faire cela en Java?
17 réponses
Google vous aiderait si vous utilisiez les bons termes pour rechercher "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);
sorties:
Integer part = 2
Fractional part = 0.2999999999999998
double value = 3.25;
double fractionalPart = value % 1;
double integralPart = value - fractionalPart;
puisque cette question vieille d'un an a été soulevée par quelqu'un qui a corrigé le sujet de la question, et que cette question a été étiquetée avec jsp , et que personne ici n'a été en mesure de donner une réponse ciblée JSP, voici ma contribution ciblée JSP.
Utiliser JSTL (il suffit de déposer jstl-1.2.jar dans /WEB-INF/lib ) fmt taglib. Il y a une étiquette <fmt:formatNumber> ce qui fait exactement ce que vous voulez et d'une manière assez facile avec l'aide des attributs maxFractionDigits et maxIntegerDigits .
voici un SSCCE , Copiez-le.
<%@ 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>
sortie:
entier: 3
Fraction: .25
C'est ça. Pas besoin de le masser à l'aide de code Java brut.
la question originale demandait l'exposant et la mantissa, plutôt que la partie fractionnaire et entière.
pour obtenir l'exposant et mantissa d'un double vous pouvez le convertir dans le IEEE 754 représentation et extraire les bits comme ceci:
long bits = Double.doubleToLongBits(3.25);
boolean isNegative = (bits & 0x8000000000000000L) != 0;
long exponent = (bits & 0x7ff0000000000000L) >> 52;
long mantissa = bits & 0x000fffffffffffffL;
Logique principale vous devez d'abord trouver combien de chiffres sont là après le point décimal.
Ce code fonctionne pour tout nombre jusqu'à 16 chiffres. Si vous utilisez BigDecimal vous pouvez l'exécuter juste pour jusqu'à 18 chiffres. mettez la valeur d'entrée (votre nombre) à la variable "num", ici comme un exemple je l'ai codé dur.
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);
le mantissa et l'exposant d'un nombre de point flottant double IEEE sont les valeurs telles que
value = sign * (1 + mantissa) * pow(2, exponent)
si le mantissa est de la forme 0.101010101_base 2 (c'est-à-dire que son bit le plus significatif est décalé pour être après le point binaire) et l'exposant est ajusté pour le biais.
depuis le 1.6, java.lang.Les mathématiques fournissent aussi une méthode directe pour obtenir l'exposant impartial (appelé getExponent (double))
cependant, les nombres vous demandez sont les parties intégrales et fractionnaires du nombre, qui peuvent être obtenus en utilisant
integral = Math.floor(x)
fractional = x - Math.floor(x)
bien que vous puissiez vouloir traiter les nombres négatifs différemment (floor(-3.5) == -4.0) , selon pourquoi vous voulez les deux parties.
je vous conseille fortement de ne pas appeler ces mantissa et exposant.
Je ne sais pas si c'est plus rapide mais j'utilise
float fp = ip % 1.0f;
[Edit: La question initialement posée de savoir comment obtenir la mantisse et l'exposant.]
où n est le nombre pour obtenir le vrai mantissa / exposant:
exponent = int(log(n))
mantissa = n / 10^exponent
Ou, pour obtenir la réponse que vous recherchez:
exponent = int(n)
mantissa = n - exponent
ceux-ci ne sont pas exactement Java mais devraient être faciles à convertir.
Que faire si votre numéro est 2.399999999999. Je suppose que vous voulez obtenir la valeur exacte décimale. Ensuite, utilisez 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);
partie entière obtenu de la fonte simple et pour fractional - chaîne de fente:
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
puisque la balise fmt:formatNumber ne donne pas toujours le bon résultat, voici une autre approche JSP-only: elle ne formate que le nombre sous forme de chaîne et fait le reste du calcul sur la chaîne, puisque c'est plus facile et n'implique pas d'arithmétique flottante.
<%@ 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>
beaucoup de ces réponses comportent d'horribles erreurs d'arrondissement parce qu'elles font passer les nombres d'un type à l'autre. Pourquoi pas:
double x=123.456;
double fractionalPart = x-Math.floor(x);
double wholePart = Math.floor(x);
la réponse acceptée ne fonctionne pas bien pour les nombres négatifs entre -0 et -1.0 Donnez aussi la fraction négative.
par exemple: Pour le nombre -0,35
retourne
partie entière = 0 Partie fractionnaire = -0,35
si vous travaillez avec des coordonnées GPS, il est préférable d'avoir un résultat avec le signe sur la partie entière comme:
partie entière = -0 Partie fractionnaire = 0.35
ces numéros sont utilisés par exemple pour les coordonnées GPS, où sont importants le signe pour la position Lat ou longue
code proposé:
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));
sortie:
Integer part = -0
Fractional part = 0,3500
depuis Java 8, Vous pouvez utiliser Math.floorDiv .
il renvoie la valeur la plus grande (la plus proche de l'infini positif) int qui est inférieure ou égale au quotient algébrique.
quelques exemples:
floorDiv(4, 3) == 1
floorDiv(-4, 3) == -2
alternativement, l'opérateur / peut être utilisé:
(4 / 3) == 1
(-4 / 3) == -1
, les Références:
J'utiliserais BigDecimal pour la solution. Comme ceci:
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);
}
}