Toujours Ronde, d'un Double

Comment pourrais-je toujours arrondir un double à un int, et jamais une tour vers le bas.
Je sais de Math.round(double), mais je le veux pour toujours round up.
Donc, si c'était 3.2, il devient arrondi à 4.

Math.ceil - si vous avez un problème de ce genre dans le futur, vous pouvez lire l'généré JavaDoc de la bibliothèque en question. Dans ce cas, Mathématiques
Même si vous n'avez pas envie de RTFM, Math.round(yourNum+0.5) œuvres.
Pas tout à fait comme 0.0 sera arrondi à 1 c'est le même que l'arrondi vers le bas et en ajoutant 1.

InformationsquelleAutor sparklyllama | 2013-10-27

java rounding

35

Vous pouvez utiliser Math.ceil() méthode.

Voir JavaDoc lien: https://docs.oracle.com/javase/10/docs/api/java/lang/Math.html#ceil(double)

De la documentation:

ceil
```
public static double ceil(double a)
```
Retourne le plus petit (le plus proche à l'infini négatif) le double de la valeur qui est supérieure ou égale à l'argument et est égale à une mathématique entier. Cas particuliers:
- Si la valeur de l'argument est déjà égale à une mathématique entier, le résultat est le même que l'argument.
- Si l'argument est NaN ou un infini positif ou nul ou négatif égal à zéro, alors le résultat est le même que l'argument.
- Si l'argument valeur est inférieure à zéro, mais le plus de -1.0, alors le résultat est négatif zéro.
Noter que la valeur de Mathématiques.ceil(x) est exactement la valeur de Math.étage(-x).

Paramètres:
- a - a de la valeur.
Retourne:

Le plus petit (le plus proche à l'infini négatif) valeur à virgule flottante qui est supérieur ou égal à l'argument et est égale à une mathématique entier.
- Si vous pouvez citer le lien, il aide les gens à trouver l'intégralité de la réponse sur un Débordement de Pile.
- fait
- ceil retourne un double, il a demandé int
- Je (et je suis sûr que l'OP trop) utilisé le mot "int" comme java de type de données, pas un terme mathématique. Donc, en fonte ou autre chose qui donne un int est absent de la réponse.
InformationsquelleAutor tabz100
8

Dans des mots simples,
- Math.ceil toujours round UP ou comme dit ci-dessus, dans excès.
- Math.round arrondir vers le haut ou vers le bas selon les décimales.
  - Si la décimale est égal ou supérieur à 5, alors il est arrondi.
    
    décimal => 5. (1,5 = 2)
  - Si la décimale est moins de 5, alors il est arrondi.
    
    décimal < 5. (1,45 = 1)
Exemples de Math.ceil et Math.round:

Le code ci-Dessous serait de retour:

Coût, sans Ceil 2.2 et avec Ceil 3 (int), 3.0 (double). Si nous autour d'elle: 2
```
    int m2 = 2200;
    double rate = 1000.0;

    int costceil = (int)Math.ceil(m2/rate);
    double costdouble = m2/rate;
    double costdoubleceil = Math.ceil(m2/rate);
    int costrounded = (int)Math.round(m2/rate);
    System.out.println("Cost, without Ceil "+costdouble+" and with Ceil "+
            costceil+"(int), "+costdoubleceil+"(double). If we round it: "+costrounded);
```
Si nous changeons la valeur de m2 par exemple 2499, le résultat serait:
Coût, sans Ceil 2.499 et avec Ceil 3 (int), 3.0 (double). Si nous autour d'elle: 2

Si nous changeons la valeur de m2 par exemple 2550, le résultat serait:

Coût, sans Plafond de 2,55 et avec Ceil 3 (int), 3.0 (double). Si nous autour d'elle: 3

Espère que cela aide. (Informations extraites à partir des réponses précédentes, je voulais juste le rendre plus clair).

InformationsquelleAutor maral04

private int roundUP(double d){
    double dAbs = Math.abs(d);
    int i = (int) dAbs;
    double result = dAbs - (double) i;
    if(result==0.0){ 
        return (int) d;
    }else{
        return (int) d<0 ? -(i+1) : i+1;          
    }
}

Bon travail ! 😉

InformationsquelleAutor Lostkiefer

Ma méthode est relativement simple, espérons que cela fonctionne pour vous.

Dans mon cas, j'ai une ligne d'objets qui ne peuvent contenir que 3 articles et je dois ajuster le nombre de lignes que j'ai pour accueillir les éléments.

Alors j'ai quelques Doubles nombredelignes, je puis utiliser nombredelignes.intValue() pour obtenir une valeur int pour nombredelignes.

si la valeur int-je obtenir est de moins de nombredelignes, j'ajoute 1 à nombredelignes afin de l'arrondir, d'autre de la valeur que je reçois de nombredelignes.intValue() est la réponse que je veux.

J'ai écrit cette simple boucle for pour le tester:

    for(int numberOfItems = 0; numberOfItems < 16; numberOfItems++) {
        Double numberOfRows = numberOfItems / 3.0;

        System.out.println("Number of rows are: " + numberOfRows);
        System.out.println("Number of items are: " + numberOfItems);
        if(numberOfRows.intValue() < numberOfRows) {
            System.out.println("int number of rows are: " + (numberOfRows.intValue() + 1));
        }
        else {
            System.out.println("int value of rows are: " + numberOfRows.intValue());
        }
        System.out.println();
        System.out.println();
    }

InformationsquelleAutor Tunji_D

0

Exemple court sans l'aide de Mathématiques.ceil().
```
public double roundUp(double d){
    return d > (int)d ? (int)d + 1 : d;
}
```
Exaplanation:
Comparer opérande d'arrondi opérande à l'aide de transtypage, si grand retour arrondi argument + 1 (moyen tour) reste inchangé opérande.

Exemple en Pseudo-code
```
double x = 3.01
int roundDown = (int)x   //roundDown = 3
if(x > roundDown)        //3.01 > 3
    return roundDown + 1 //return 3.0 + 1.0 = 4.0
else
    return x             //x equals roundDown
```
De toute façon, vous devez utiliser Math.ceil(). C'est uniquement destinée à être un exemple simple de la façon dont vous pourriez le faire par vous-même.

InformationsquelleAutor trinity420
0

tl;dr
```
BigDecimal( "3.2" ).setScale( 0 , RoundingMode.CEILING )
```
4

BigDecimal

Si vous voulez la précision plutôt que la performance, éviter virgule flottante de la technologie. Que signifie éviter float, Float, double, Double. Pour plus de précision, utilisez BigDecimal classe.

Sur un BigDecimal, définir l'échelle de l', le nombre de chiffres à droite de la virgule. Si vous ne voulez pas de fraction décimale, réglez l'échelle à zéro. Et de préciser un mode d'arrondi. Toujours autour d'une fraction vers le haut, utilisez RoundingMode.PLAFOND documentée:

Mode d'arrondi à tour vers l'infini positif. Si le résultat est positif, se comporte comme pour RoundingMode.JUSQU'; si le résultat est négatif, se comporte comme pour RoundingMode.Vers le BAS. Notez que ce mode d'arrondi diminue jamais la valeur calculée. Ainsi, par exemple, 1.1 est de 2, et votre 3.2 devient 4.
```
BigDecimal bd = new BigDecimal( "3.2" ) ;
BigDecimal bdRounded = bd.setScale( 0 , RoundingMode.CEILING ) ;
String output = bdRounded.toString() ; 
System.out.println( "bdRounded.toString(): " + bdRounded ) ;  //4
```
4

Voir ce code à exécuter en direct à IdeOne.com.

InformationsquelleAutor Basil Bourque
-2

Math.ceil() vous donnera le plus proche de la valeur la plus basse si vous voulez qu'il soit arrondi au plus proche des valeurs que vous devriez utiliser Math.floor()
- C'est l'arrière vers l'avant.
InformationsquelleAutor Muhammad Ahmed

Vous devez vous connecter pour publier un commentaire.

tl;dr

BigDecimal

`BigDecimal`