En mots simples,

• {[1] } sera toujours arrondir ou comme dit ci-dessus, en excès.
• {[2] } arrondira vers le haut ou vers le bas en fonction des 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

Exemples de Math.ceil et Math.round:

Le code ci-dessous retournerait:
Coût, sans ceil 2.2 et avec Ceil 3 (int), 3.0 (double). Si nous l'arrondissons: 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 l'arrondissons: 2
Si nous changeons la valeur de m2 par exemple 2550, le résultat serait:
Coût, sans Plafond 2.55 et avec Ceil 3 (int), 3.0 (double). Si nous l'arrondissons: 3

J'espère que ça aide. (Informations extraites des réponses précédentes, je voulais juste le rendre plus clair).

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

Ma méthode est relativement simple, j'espère que cela fonctionne pour vous.

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

J'ai donc un double numberOfRows, j'utilise ensuite numberOfRows.intValue() pour obtenir une valeur int pour nombredelignes.

Si la valeur int que je reçois est inférieure à numberOfRows, j'ajoute 1 à numberOfRows pour l'arrondir, sinon la valeur que je reçois de numberOfRows.intValue () est la réponse I vouloir.

J'ai écrit ce simple for loop 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();
    }

Exemple court sans utiliser Math.ceil () .

public double roundUp(double d){
    return d > (int)d ? (int)d + 1 : d;
}

Exaplanation: Comparez l'opérande à l'opérande arrondi en utilisant typecast, si un plus grand retour arrondi vers le bas argument + 1 (signifie arrondir) sinon opérande inchangé.

Exemple de 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

Quoi qu'il en soit, vous devriez utiliser Math.ceil(). Ceci est seulement destiné à être un exemple simple de la façon dont vous pourriez le faire par vous-même.

Tl; dr

BigDecimal( "3.2" ).setScale( 0 , RoundingMode.CEILING )

4

BigDecimal

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

Sur une 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 scale sur zéro. Et spécifiez un mode d'arrondi . Pour toujours arrondir un fraction vers le haut, l'utilisation RoundingMode.CEILING, documenté comme:

Mode D'arrondi pour arrondir vers l'infini positif. Si le résultat est positif, se comporte comme pour L'Arrondissementmode.UP; si négatif, se comporte comme pour RoundingMode.Vers le BAS. Notez que ce mode d'arrondi ne diminue jamais la valeur calculée. Ainsi, par exemple, 1.1 devient 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écuté en direct à IdeOne.com .

Math.ceil() vous donnera la valeur la plus basse la plus proche si vous voulez qu'elle soit arrondie aux valeurs les plus proches, vous devez utiliser Math.floor()

Mathématiques.ceil

Public statique double ceil (double a)

Renvoie la plus petite (la plus proche de l'infini négatif) valeur double qui est supérieure ou égale à l'argument et est égale à un entier mathématique. Cas particuliers: