web-dev-qa-db-fra.com

Comment obtenir des parties entières et des fractions de double dans JSP/Java?

Comment obtenir des parties entières et des fractions de double dans JSP/Java? Si la valeur est 3.25 alors je veux obtenir fractional =.25, whole = 3

Comment pouvons-nous faire cela en Java?

javamathjsp
88
Vinayak Bevinakatti

Google vous aiderait si vous utilisiez les bons termes pour rechercher "obtenir une fraction et une partie de 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);

Les sorties:

Integer part = 2
Fractional part = 0.2999999999999998
93
Gishu
double value = 3.25;
double fractionalPart = value % 1;
double integralPart = value - fractionalPart;
140
Dan Vinton

Depuis que cette question d’un an a été lancée par une personne qui a corrigé le sujet de la question, cette question a été étiquetée avec jsp, et personne ici n’a été en mesure de donner une réponse ciblée JSP, voici ma contribution ciblée sur JSP.

Utilisez JSTL (déposez simplement jstl-1.2.jar dans /WEB-INF/lib) fmt taglib. Il y a une balise <fmt:formatNumber> qui fait exactement ce que vous voulez et de manière assez simple avec l'aide des attributs maxFractionDigits et maxIntegerDigits.

Voici un SSCCE , copiez-le et copiez-le simplement.

<%@ 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:

Ensemble: 3

Fraction: 0,25

C'est tout. Pas besoin de le masser avec l'aide de code Java brut.

23
BalusC

La question initiale visait l'exposant et la mantisse, plutôt que la fraction et la partie entière.

Pour obtenir l’exposant et la mantisse d’un double, vous pouvez le convertir en IEEE 754 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;
7
Rasmus Faber

La logique principale vous devez d’abord trouver combien de chiffres se trouvent après le point décimal.
Ce code fonctionne pour n'importe quel nombre jusqu'à 16 chiffres. Si vous utilisez BigDecimal, vous pouvez l'exécuter pour un maximum de 18 chiffres. mettez la valeur d'entrée (votre nombre) dans la variable "num", ici à titre d'exemple, je l'ai codée en 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);
5
OnePunchMan

La mantisse et l’exposant d’un nombre à double nombre à virgule flottante IEEE sont les valeurs telles que

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

si la mantisse est de la forme 0.101010101_base 2 (c'est-à-dire que son bit le plus significatif est décalé après le point binaire) et que l'exposant est ajusté pour le biais.

Depuis 1.6, Java.lang.Math fournit également une méthode directe pour obtenir l’exposant non biaisé (appelé getExponent (double)). 

Cependant, les nombres que vous demandez sont les parties intégrales et fractionnaires du nombre, qui peuvent être obtenues en utilisant

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

bien que vous souhaitiez traiter les nombres négatifs différemment (floor(-3.5) == -4.0), en fonction de la raison pour laquelle vous souhaitez les deux parties.

Je suggère fortement que vous n'appelez pas ces mantisse et exposant.

4
Pete Kirkham

Je ne sais pas si c'est plus rapide mais j'utilise

float fp = ip % 1.0f;
4
QED

[Edit: La question à l'origine demandait comment obtenir la mantisse et l'exposant.]

Où n est le nombre pour obtenir la vraie mantisse/exposant:

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

Ou, pour obtenir la réponse que vous cherchiez:

exponent = int(n)
mantissa = n - exponent

Ce ne sont pas Java exactement mais devrait être facile à convertir.

3
Stephen Darlington

La partie entière est obtenue à partir d'un casting simple et pour le fractionnement fractionné:

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
1
Zon

Et si votre numéro est 2.39999999999999. Je suppose que vous voulez obtenir la valeur décimale exacte. 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);
1
roybraym

Puisque la balise fmt:formatNumber ne donne pas toujours le résultat correct, voici une autre approche uniquement basée sur JSP: elle formate simplement le nombre en tant que chaîne et effectue le reste du calcul sur la chaîne, car cela est plus facile et n'implique pas davantage arithmétique ponctuelle.

<%@ 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>
0
Roland Illig

Beaucoup de ces réponses ont des erreurs d'arrondissement horribles parce qu'elles affichent des nombres d'un type à l'autre. Que diriez-vous:

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

Je voudrais utiliser BigDecimal pour la solution. Comme ça:

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

La réponse acceptée ne fonctionne pas bien pour les nombres négatifs compris entre -0 et -1.0 Indiquez également la fraction décimale négative.

Par exemple: Pour le nombre -0,35 

résultats

Partie entière = 0 Partie fractionnaire = -0,35

Si vous travaillez avec des coordonnées GPS, il est préférable d’obtenir un résultat avec le signe sur la partie entière, comme suit:

Partie entière = -0 Partie fractionnaire = 0,35 

Ces nombres sont utilisés par exemple pour les coordonnées GPS, où sont importants le signum de la position Lat ou Long

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
0
user1817835
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);
    }
}
0
Mohamed Sabirulla

Depuis Java 8, vous pouvez utiliser Math.floorDiv.

Elle renvoie la plus grande valeur int (la plus proche de l'infini positif) inférieure ou égale au quotient algébrique.

Quelques exemples:

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

Sinon, l'opérateur / peut être utilisé:

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

Références:

0
Stephan