Как округлить целочисленное деление и получить int в Java?

Я написал небольшой метод подсчета количества страниц для сотового телефона SMS. У меня не было возможности округлить, используя Math.ceil, и, честно говоря, это кажется очень уродливым.

Вот мой код:

public class Main {

/**
 * @param args the command line arguments
 */
public static void main(String[] args) {
   String message = "today we stumbled upon a huge performance leak while optimizing a raycasting algorithm. Much to our surprise, the Math.floor() method took almost half of the calculation time: 3 floor operations took the same amount of time as one trilinear interpolation. Since we could not belive that the floor-method could produce such a enourmous overhead, we wrote a small test program that reproduce";

   System.out.printf("COunt is %d ",(int)messagePageCount(message));



}

public static double messagePageCount(String message){
    if(message.trim().isEmpty() || message.trim().length() == 0){
        return 0;
    } else{
        if(message.length() <= 160){
            return 1;
        } else {
            return Math.ceil((double)message.length()/153);
        }
    }
}

Мне не нравится этот кусок кода, и я ищу более элегантный способ сделать это. При этом я ожидаю 3, а не 3.0000000. Любые идеи?

Ответ 1

Чтобы округлить целочисленное деление, вы можете использовать

import static java.lang.Math.abs;

public static long roundUp(long num, long divisor) {
    int sign = (num > 0 ? 1 : -1) * (divisor > 0 ? 1 : -1);
    return sign * (abs(num) + abs(divisor) - 1) / abs(divisor);
}

или если оба числа положительны

public static long roundUp(long num, long divisor) {
    return (num + divisor - 1) / divisor;
}

Ответ 2

Используйте Math.ceil() и передайте результат в int:

Это все еще быстрее, чем избегать удвоений с помощью abs().
Результат корректен при работе с негативами, поскольку -0.999 будет округлено до 0

Пример:

(int) Math.ceil((double)divident / divisor);

Ответ 3

Другой однострочный слой, который не слишком сложный:

private int countNumberOfPages(int numberOfObjects, int pageSize) {
    return numberOfObjects / pageSize + (numberOfObjects % pageSize == 0 ? 0 : 1);
}

Может использовать long вместо int; просто измените типы параметров и тип возвращаемого значения.

Ответ 4

(message.length() + 152) / 153

Это даст "округленное" целое число.

Ответ 5

long numberOfPages = new BigDecimal(resultsSize).divide(new BigDecimal(pageSize), RoundingMode.UP).longValue();

Ответ 6

Библиотека Google Guava обрабатывает это в классе IntMath:

IntMath.divide(numerator, divisor, RoundingMode.CEILING);

В отличие от многих ответов здесь он обрабатывает отрицательные числа. Он также создает соответствующее исключение при попытке деления на ноль.

Ответ 7

Развернувшись на решении Питера, это то, что я нашел, работает для меня всегда вокруг "к положительной бесконечности":

public static long divideAndRoundUp(long num, long divisor) {
    if (num == 0 || divisor == 0) { return 0; }

    int sign = (num > 0 ? 1 : -1) * (divisor > 0 ? 1 : -1);

    if (sign > 0) {
        return (num + divisor - 1) / divisor;
    }
    else {
        return (num / divisor);
    }
}

Ответ 8

Если вы хотите вычислить деленное на b округленное, вы можете использовать (a + (- a% b))/b

Ответ 9

Это может быть полезно, Вычтите остаток в legnth и сделайте его делимым числом, а затем разделите его на 153

int r=message.length()%153;       //Calculate the remainder by %153
return (message.length()-r)/153;  // find the pages by adding the remainder and 
                                  //then divide by 153

Ответ 10

если вы хотите ничего не импортировать, я предлагаю следующее:

int var = message.length() / 153; //you can put any integer instead of 153 depend on your case
if(message.length() % 153 != 0)
     var = var + 1;