Hoe kan ik een Doublealtijd naar boven afronden naar een inten nooit naar beneden afronden.
Ik ken Math.round(double), maar ik wil dat het altijd naar boven wordt afgerond.
Dus als het 3.2was, wordt het afgerond op 4.

Antwoord 1, autoriteit 100%

U kunt de methode Math.ceil()gebruiken.

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

Uit de documenten:

plafond

public static double ceil(double a)

Retourneert de kleinste (dichtst bij negatieve oneindigheid) dubbele waarde die groter is dan of gelijk is aan het argument en gelijk is aan een wiskundig geheel getal. Speciale gevallen:

• Als de argumentwaarde al gelijk is aan een wiskundig geheel getal, dan is het resultaat hetzelfde als het argument.
• Als het argument NaN of een oneindigheid of een positieve nul of een negatieve nul is, dan is het resultaat hetzelfde als het argument.
• Als de argumentwaarde kleiner is dan nul maar groter dan -1,0, dan is het resultaat negatief nul.

Merk op dat de waarde van Math.ceil(x) exact de waarde is van -Math.floor(-x).

Parameters:

• a – een waarde.

Retouren:

De kleinste (dichtst bij negatieve oneindigheid) drijvende-kommawaarde die groter is dan of gelijk is aan het argument en gelijk is aan een wiskundig geheel getal.

Antwoord 2, autoriteit 36%

In eenvoudige bewoordingen,

• Math.ceilzal altijd naar boven afrondenof zoals hierboven vermeld, in overschot.
• Math.roundzal naar boven of naar beneden afronden, afhankelijk van de decimalen.
  • Als het decimaalteken gelijk aan of hoger is dan 5, wordt het naar boven afgerond.
    • decimaal => 5. (1,5 = 2)
  • Als het decimaalteken minder dan 5is, wordt het naar beneden afgerond.
    • decimaal < 5. (1,45 = 1)

Voorbeelden van Math.ceilen Math.round:

De onderstaande code zou terugkeren:
Kosten, zonder Ceil 2.2 en met Ceil 3 (int), 3.0 (dubbel). Als we het afronden: 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);

Als we de waarde van m2 veranderen in bijvoorbeeld 2499, zou het resultaat zijn:
Kosten, zonder Ceil 2.499 en met Ceil 3 (int), 3.0 (dubbel). Als we het afronden: 2
Als we de waarde van m2 veranderen in bijvoorbeeld 2550, zou het resultaat zijn:
Kosten, zonder Ceil 2.55 en met Ceil 3 (int), 3.0 (dubbel). Als we het afronden: 3

Ik hoop dat het helpt. (Informatie verkregen uit eerdere antwoorden, ik wilde het alleen duidelijker maken).

Antwoord 3, autoriteit 10%

tl;dr

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

4

BigDecimal

Als je nauwkeurigheid wilt in plaats van prestaties, vermijd dan drijvende komma-technologie. Dat betekent het vermijden van Float, Float, Double, Double. Gebruik voor nauwkeurigheid BigDecimalklas.

Op een BigDecimal, stel de schaal in, het aantal cijfers rechts van de komma. Als u geen decimale breuk wilt, stelt u de schaal in op nul. En specificeer een afrondingsmodus. Gebruik RoundingMode.CEILING, gedocumenteerd als:

Afrondingsmodus om af te ronden naar positieve oneindigheid. Als het resultaat positief is, gedraagt het zich als bij RoundingMode.UP; indien negatief, gedraagt zich als voor RoundingMode.DOWN. Merk op dat deze afrondingsmodus nooit de berekende waarde verlaagt. Dus 1.1 wordt bijvoorbeeld 2 en uw 3.2 wordt 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

Zie deze code run live op ideone.com .

Antwoord 4

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

goed werk! 😉

Antwoord 5

Mijn methode is relatief eenvoudig, hoop dat het voor u werkt.

In mijn geval heb ik een rij objecten die slechts 3 items kunnen bevatten en ik moet het aantal rijen aanpassen dat ik nodig heb om de items te huisvesten.

Dus ik heb een aantal dubbele numberofrows, gebruik ik dan Numberofrows.intvalue () om een ​​int-waarde voor nummeraanbiedingen te krijgen.

Als de INT-waarde die ik krijg minder is dan nummerofrows, voeg ik 1 toe aan nummerofrows om het op te ronden, anders de waarde die ik krijg van nummerofrows.intvalue () is het antwoord dat ik wil.

Ik schreef dit eenvoudig voor lus om het uit te testen:

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

Antwoord 6

Korte voorbeeld zonder MATH.CEIL () te gebruiken.

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

Uitleg:
Vergelijk de operand met de naar beneden afgeronde operand met behulp van typecast, als een groter rendement naar beneden wordt afgerond + 1 (betekent naar boven afronden) anders ongewijzigde operand.

Voorbeeld in pseudocode

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

Hoe dan ook, je moet Math.ceil()gebruiken. Dit is alleen bedoeld als een eenvoudig voorbeeld van hoe u het zelf zou kunnen doen.

Antwoord 7

Math.ceil()geeft u de dichtstbijzijnde laagste waarde als u wilt dat deze wordt afgerond op de grootste dichtstbijzijnde waarden, u moet Math.floor()