Comment puis-je obtenir entiers et de fractions de double en JSP/Java?

Comment puis-je obtenir entiers et de fractions de double en JSP/Java ? Si la valeur est de 3,25 alors je veux obtenir fractional =.25, whole = 3

Comment peut-on le faire en Java?

Vous semblez avoir une idée inexacte de ce que la mantisse et l'exposant sont. Ils ne sont pas simplement "partie entière" et "partie fractionnaire". Voir en.wikipedia.org/wiki/Floating_point
En fait j'ai lu autour de 5 messages avant d'aller "hé.. qui ne s'appelle pas un exposant'. Mon cerveau a jeté les mots et a commencé à résoudre le problème .. les mauvaises habitudes de lecture de la programmation des trucs a me donner 🙂
Aussi, merci de reformuler la question de l'OP.. pour la postérité, entre autres raisons.
Ressemble étrangement à un problème.
ohh je vois. j'ai déjà demandé comment il obtient donc des résultats étranges
Simplement, je ne veux pas savoir de cette école si c'est le cas.. trop petit pour l'exercice de toutes les cellules du cerveau. 🙂
Garder le titre original sinon, la plupart des réponses ne faites pas de sens.
Mes 5 lignes de code fonctionne pour tous les cas, prendre un coup d'oeil ici stackoverflow.com/a/56413634/8253662

InformationsquelleAutor Vinayak Bevinakatti | 2008-12-05

94

Google pourrait vous aider si vous avez utilisé les bons termes de recherche "obtenir les fractions et de toute la 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);
```
Sorties:
```
Integer part = 2
Fractional part = 0.2999999999999998
```
- En fait, cette page est la première à frapper sur une recherche google pour "obtenir des fractions et de toute la partie de double java" =)
- En fait, cette réponse est incorrecte, pour les valeurs plus grandes que long peut représenter ça va donner un grand nombre dans la partie fractionnaire. Dan Vinton réponse ci-dessous est tout aussi simple et retourne toujours le bon résultat.
- donc en fait, ce n'est pas correct, comme vous pouvez le voir dans la sortie. l'entrée est de la fraction de la 3 et la sortie est 29999999...à l'aide de BigDecimal au lieu de Double fera l'affaire si
- 0.2999999999999 est égale à 0,3
- Non, l'entrée est un nombre qui est très proche de 2.3, mais sûrement pas 2.3. Et il n'y a rien de mal à la sortie, sauf si vous voulez beaucoup plus que 10 valable chiffres. Tous vous avez besoin est un peu de l'arrondissement à chaque sortie (par exemple, le format %.9f), qui est généralement moins de douleur que BigDecimal. Le seul problème ici, c'est le trop-plein.
- La conversion double en int est presque toujours une mauvaise idée. Parce que par exemple pour (long)1.0e100 vous obtiendrez 0. Beaucoup de fois vous avez besoin du double de la valeur simplement "au sol" pour lequel il n'existe floor(). Si vous voulez à la fois intégré et d'une fraction des pièces, utilisez modf(). Vraiment, c'est une mauvaise réponse.
InformationsquelleAutor Gishu
142
```
double value = 3.25;
double fractionalPart = value % 1;
double integralPart = value - fractionalPart;
```
- Pourquoi est-ce downvoted? Fonctionne très bien, et avec mon montage va travailler avec des valeurs négatives ainsi.
- La partie entière pourrait être => long longPart = (long)3.25
- Ne pas travailler pour nég. des valeurs. I. e. -3.25 % 1 = 0.75 pas de 0,25. Donc integralPart sera -3.25 - 0.75 = -4.
- J'ai vérifié pour le négatif.. et de ses œuvres.. cependant pour les décimales qui sont en petit nombre, il y aura une légère erreur. Ex. pour -03.0025 il retourne -0.0024999999999999467 et -3.0
- La confusion ici, c'est parce que certaines langues, comme le Python, l'utilisation % à dire modulo (-3.25 % 1 == 0.75) et d'autres, tels que Java, Fortran, C et C++, l'utilisation % pour signifier reste (-3.25 % 1 == -0.25). WindRider peut-être tapé dans un Python REPL pour l'opportunisme, mais cette réponse est trompeuse, car cette question est au sujet de la JVM.
InformationsquelleAutor Dan Vinton
23

Depuis 1 ans, la question a été soulevée par quelqu'un qui a corrigé la question, et cette question est balisé avec jsp, et personne ici n'a été en mesure de donner une JSP réponse ciblée, voici ma JSP-contribution ciblée.

Utilisation JSTL (il suffit de déposer jstl-1.2.jar dans /WEB-INF/lib) fmt taglib. Il y a un <fmt:formatNumber> balise qui fait exactement ce que vous voulez et dans un très facile avec l'aide de maxFractionDigits et maxIntegerDigits attributs.

Voici un SSCCE, il suffit de copier n " coller'n'run il.
```
<%@ 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>
```
De sortie:

Ensemble: 3

Fraction: .25

Que c'est. Pas besoin de massage avec l'aide de matières premières de code Java.
- +1 pour la première seule phrase
InformationsquelleAutor BalusC
7

L'original de la question posée pour l'exposant et la mantisse, plutôt que de la fraction, et toute la partie.

Pour obtenir l'exposant et la mantisse d'un double, vous pouvez le convertir dans le La norme IEEE 754 représentation et d'en 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;
```
- N'est-ce pas le premier bit de la mantinssa implicitement la valeur 1, donc la mantisse doit être bits (& 0x000fffffffffffffL) | 0x0010000000000000L?
- Rasmus il n'était pas un ryt de sortie de Sortie: exposant 0 et mantisse 2814749767106560 et si u choisir urs agnul la mantisse est 0
- Désolé mantisse sera b 7318349394477056
- Rompu avec 4 votes:) Même si je vois ce que le code est en essayant de prendre part double de la valeur à ses articulations, le code ne semble pas à la sortie de la droite des valeurs.
- Je pense que "mantisse" se réfère généralement à la seule valeur des bits. Vous pourriez tout simplement de convertir ce pour le significande par (parfois) en ajoutant un bit à 1. Mais selon Wikipedia, le mot de la mantisse est maintenant dépréciée en faveur de la "fraction".
InformationsquelleAutor Rasmus Faber
5

Logique principale, vous devez d'abord trouver du nombre de chiffres après le point décimal.

Ce code fonctionne pour un certain nombre jusqu'à 16 chiffres. Si vous utilisez BigDecimal vous pouvez l'exécuter juste pour jusqu'à 18 chiffres. mettre la valeur d'entrée (votre numéro) à la variable "num", ici, à titre d'exemple, j'ai codé en dur elle.
```
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);
```
- Mec, ce qui est extrêmement compliqué de répondre à un problème simple. Avez-vous jeter un oeil à la accepté de répondre?
- Maintenant, la personne qui a le droit de voter (pas moi btw), devrait avoir expliqué pourquoi il y a un vote. Ce n'est pas bon. Mais nous avions tous un score de 1 à un moment ou un autre.
- la question était de séparer 3.25, '3' et '25', et l'on a accepté la réponse ne sera jamais jamais donner de l' '25', il sera toujours donner des "2599999999'
- Je sais qui downvote, c'était un gars du nom de Eji(ancien utilisateur) moqueur sur chaque et chaque de mon commentaire, répondre à des questions et que je poste dans ce blog. Enfin je me plains de l'animateur.
- Bien n'obtenez pas sur la défensive. Écrire de simples bonnes réponses, avec de bonnes descriptions et vous permettra de faire mec. Le meilleur de la chance.
- Cette réponse est très utile si vous voulez que la partie décimale d'un nombre entier
InformationsquelleAutor OnePunchMan
4

Ne sais pas si c'est plus rapide mais je suis en utilisant
```
float fp = ip % 1.0f;
```
InformationsquelleAutor QED
4

La mantisse et l'exposant de l'IEEE double nombre à virgule flottante 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 sa plus sigificant peu décalée après le binaire point) et l'exposant est ajusté de biais.

Depuis la 1.6, java.lang.Les mathématiques fournit une méthode pour obtenir la neutralité de l'exposant (appelé getExponent(double))

Cependant, les chiffres que vous proposez sont de l'intégrale et de la fraction d'un nombre, qui peut être obtenu à l'aide de
```
integral = Math.floor(x)
fractional = x - Math.floor(x)
```
si vous vous voulez traiter les nombres négatifs différemment (floor(-3.5) == -4.0), selon lesquelles vous voulez les deux parties.

J'avais suggèrent fortement que vous n'appelez pas de ces mantisse et l'exposant.

InformationsquelleAutor Pete Kirkham
3

[Edit: La question initialement posée de savoir 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 recherchez:
```
exponent = int(n)
mantissa = n - exponent
```
Ce ne sont pas Java exactement, mais doit être facile à convertir.

InformationsquelleAutor Stephen Darlington

Partie entière obtient à partir de la fonderie simple et pour les fractions de chaîne de fendage:

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

InformationsquelleAutor Zon

Que faire si votre numéro est 2.39999999999999. Je suppose que vous voulez pour obtenir la valeur 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);

InformationsquelleAutor roybraym

Depuis le fmt:formatNumber balise n'est pas toujours le rendement le résultat correct, voici une autre JSP seule approche: Il vient de formats le numéro de la chaîne et le reste du calcul sur la chaîne, depuis que c'est plus facile et ne nécessite pas plus de l'arithmétique à virgule 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>

Quand n'est-il pas produire les résultats corrects, alors?
Juste essayer tous les numéros de mon exemple. fmt:formatNumber des tours de son argument, qui n'est pas souhaitable dans ce cas.

InformationsquelleAutor Roland Illig

0

Beaucoup de ces réponses ont d'horribles erreurs d'arrondi parce qu'ils sont les numéros de coulée à partir d'un type à l'autre. Que diriez-vous:
```
double x=123.456;
double fractionalPart = x-Math.floor(x);
double wholePart = Math.floor(x);
```
- l'habitude de travailler pour les négatifs, comme les Mathématiques.étage(-3.25) est de -4
- Que penser de l'utilisation Math.abs?
InformationsquelleAutor benofben
0

Accepté la réponse ne fonctionnent pas bien pour les nombres négatifs entre -0 et de -1.0
Donner également de la partie fractionnaire négatif.

Par exemple:
Pour nombre -0,35

retourne

Partie entière = 0
Partie fractionnaire = -0.35

Si wou travaillent avec des coordonnées GPS, il est préférable d'avoir un résultat avec le signum sur la partie entière comme:

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 pour Lat ou position Longue

Proposer 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));
```
De sortie:
```
Integer part = -0
Fractional part = 0,3500
```
InformationsquelleAutor user1817835
0

Depuis Java 8, vous pouvez utiliser Math.floorDiv.

Il renvoie la plus grande (la plus proche de l'infini positif) int valeur qui est inférieure ou égale à la algébrique quotient.

Quelques exemples:
```
floorDiv(4, 3) == 1
floorDiv(-4, 3) == -2
```
Sinon, le / opérateur peut être utilisé:
```
(4 / 3) == 1
(-4 / 3) == -1
```
Références:
- Java 8 : Les Maths.floorDiv(int,int)
- Java 8 : Les Maths.floorDiv(long,long)
InformationsquelleAutor Stephan

Je voudrais utiliser 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();

InformationsquelleAutor Endery

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);
    }
}

Cette réponse a été identifiée comme étant de faible qualité. Si elle répond à la question, envisager d'ajouter un peu de texte pour expliquer comment cela fonctionne.

InformationsquelleAutor Mohamed Sabirulla

-2

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);
    }
}

Cela ne fonctionne que si le nombre a exactement 4 chiffres après la virgule. Non pas le contraire.

InformationsquelleAutor

Vous devez vous connecter pour publier un commentaire.