Comment arrondir la division entière et avoir pour résultat int en Java?

Je viens d’écrire une toute petite méthode pour compter le nombre de pages pour les SMS de téléphone portable. Je n’ai pas eu la possibilité d’arrondir Math.ceil , et honnêtement, cela semble très moche.

Voici mon code:

 public class Main { /** * @param args the command line arguments */ public static void main(Ssortingng[] args) { Ssortingng 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 sortinglinear 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(Ssortingng message){ if(message.sortingm().isEmpty() || message.sortingm().length() == 0){ return 0; } else{ if(message.length() <= 160){ return 1; } else { return Math.ceil((double)message.length()/153); } } } 

Je n’aime pas vraiment ce code et je cherche une façon plus élégante de le faire. Avec cela, j’attends 3 et pas 3.0000000. Des idées?

Pour arrondir une division entière, vous pouvez utiliser

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

ou si les deux nombres sont positifs

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

Utilisez Math.ceil() et Math.ceil() le résultat en int:

  • C’est encore plus rapide que d’éviter les doubles en utilisant abs ().
  • Le résultat est correct lorsque vous travaillez avec des négatifs, car -0,999 sera arrondi à 0

Exemple:

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

Un autre one-liner qui n’est pas trop compliqué:

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

Peut utiliser long au lieu de int; modifiez simplement les types de parameters et le type de retour.

La bibliothèque Guava de Google gère cela dans la classe IntMath :

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

Contrairement à beaucoup de réponses ici, il gère les nombres négatifs. Il jette également une exception appropriée lors de la tentative de division par zéro.

 (message.length() + 152) / 153 

Cela donnera un entier “arrondi”.

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

En développant la solution de Peter, c’est ce que j’ai trouvé qui fonctionne pour que je fasse toujours le tour «vers l’infini positif»:

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

Si vous voulez calculer un divisé par b arrondi, vous pouvez utiliser (a + (- a% b)) / b

cela pourrait être utile, soustraire le rest à la jambe et en faire un nombre divisible, puis le diviser avec 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