问题

How could I always round up a double to an int, and never round it down. I know of Math.round(double), but I want it to always round up. So if it was 3.2, it gets rounded to 4.

回答1:

You can use Math.ceil() method.

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

From the docs:

ceil

public static double ceil(double a)

Returns the smallest (closest to negative infinity) double value that is greater than or equal to the argument and is equal to a mathematical integer. Special cases:

If the argument value is already equal to a mathematical integer, then the result is the same as the argument.
If the argument is NaN or an infinity or positive zero or negative zero, then the result is the same as the argument.
If the argument value is less than zero but greater than -1.0, then the result is negative zero.

Note that the value of Math.ceil(x) is exactly the value of -Math.floor(-x).

Parameters:

a - a value.

Returns:

The smallest (closest to negative infinity) floating-point value that is greater than or equal to the argument and is equal to a mathematical integer.

回答2:

In simple words,

Math.ceil will always round UP or as said above, in excess.
Math.round will round up or down depending on the decimals.
- If the decimal is equal or higher than 5, then it's rounded up.
  - decimal => 5. (1,5 = 2)
- If the decimal is less than 5, then it's rounded down.
  - decimal < 5. (1,45 = 1)

Examples of Math.ceil and Math.round:

The code Below would return:
Cost, without Ceil 2.2 and with Ceil 3 (int), 3.0 (double). If we round it: 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);

If we change the value of m2 to for example 2499, the result would be: Cost, without Ceil 2.499 and with Ceil 3 (int), 3.0 (double). If we round it: 2
If we change the value of m2 to for example 2550, the result would be:
Cost, without Ceil 2.55 and with Ceil 3 (int), 3.0 (double). If we round it: 3

Hope it helps. (Information extracted from previous answers, i just wanted to make it clearer).

回答3:

tl;dr

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

4

`BigDecimal`

If you want accuracy rather than performance, avoid floating point technology. That means avoiding float, Float, double, Double. For accuracy, use BigDecimal class.

On a BigDecimal, set the scale, the number of digits to the right of the decimal place. If you want no decimal fraction, set scale to zero. And specify a rounding mode. To always round an fraction upwards, use RoundingMode.CEILING, documented as:

Rounding mode to round towards positive infinity. If the result is positive, behaves as for RoundingMode.UP; if negative, behaves as for RoundingMode.DOWN. Note that this rounding mode never decreases the calculated value. So for example, 1.1 becomes 2, and your 3.2 becomes 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

See this code run live at IdeOne.com.

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

Good job ! ;)

回答5:

My method is relatively simple, hope it works for you.

In my case I have a row of objects that can only hold 3 items and I must adjust the number of rows I have to accommodate the items.

So I have some Double numberOfRows, I then use numberOfRows.intValue() to get an int value for numberOfRows.

if the int value I get is less than numberOfRows, I add 1 to numberOfRows to round it up, else the value I get from numberOfRows.intValue() is the answer I want.

I wrote this simple for loop to test it out:

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

回答6:

Short example without using Math.ceil().

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

Exaplanation: Compare operand to rounded down operand using typecast, if greater return rounded down argument + 1 (means round up) else unchanged operand.

Example 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

Anyway you should use Math.ceil(). This is only meant to be a simple example of how you could do it by yourself.

回答7:

Math.ceil() will give you the closest lowest value if you want it to be rounded to largest closest values you should use Math.floor()

来源：https://stackoverflow.com/questions/19614695/always-round-up-a-double

标签

java

rounding

Always Round UP a Double

问题