Come arrotondare la divisione intera e avere risultato int in Java?

Question

Ho appena scritto un piccolo metodo per contare il numero di pagine per gli SMS del cellulare. Non ho avuto la possibilità di arrotondare utilizzando Math.ceil, e onestamente sembra essere molto brutto.

Ecco il mio codice:

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

non mi piace molto questo pezzo di codice e sto cercando un modo più elegante di fare questo. Con questo, mi aspetto 3 e non 3.0000000. Qualche idea?

Answer 1

per arrotondare una divisione intera è possibile utilizzare

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

o se entrambi i numeri sono positivi

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

Answer 2

(message.length() + 152)/153 

Questo darà un numero intero "arrotondato".

Answer 3

questo potrebbe essere utile ,, Sottrarre la parte restante alla legnth e ne fanno un numero divisibile e quindi dividerlo con 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 

Answer 4

Ex panding sulla soluzione di Peter, questo è quello che ho trovato per me funziona per sempre rotonda 'verso l'infinito positivo':

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

Answer 5

Usa Math.ceil() e gettato il risultato a int:

• Questo è ancora più veloce che evitare i doppi usando abs().
• Il risultato è corretto quando si lavora con negativi, perché -0,999 sarà arrotondata a 0

Esempio:

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

Answer 6

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

Answer 7

Un'altra-liner che non è troppo complicato:

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

È possibile utilizzare long invece di int; basta cambiare i tipi di parametri e restituire il tipo.

Answer 8

Se si desidera calcolare a diviso b arrotondato è possibile utilizzare (a + (-% B))/b

Answer 9

se si desidera importare nulla, vi consiglio questo:

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; 

Answer 10

biblioteca Guava di Google handles this in the IntMath class:

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

A differenza di molte risposte qui, gestisce i numeri negativi. Inoltre, genera un'eccezione appropriata quando si tenta di dividere per zero.