Comment arrondir un entier en java

Utiliser la précision (Apache Commons Math 3.1.1)

Precision.round(double, scale); // return double Precision.round(float, scale); // return float 

Utiliser MathUtils (Apache Commons Math) – Anciennes versions

 MathUtils.round(double, scale); // return double MathUtils.round(float, scale); // return float 

scale – Le nombre de chiffres à droite du point décimal. (+/-)

Jeté parce que la méthode round (float, scale) peut être utilisée.

Math.round (MathUtils.round (1732, -1)); // près de dix heures, 1730
Math.round (MathUtils.round (1732, -2)); // la centaine la plus proche, 1700
Math.round (MathUtils.round (1732, -3)); // mille le plus proche, 2000

Meilleure solution

 int i = 1732; MathUtils.round((double) i, -1); // nearest ten, 1730.0 MathUtils.round((double) i, -2); // nearest hundred, 1700.0 MathUtils.round((double) i, -3); // nearest thousand, 2000.0 

Quel mécanisme d’arrondi voulez-vous utiliser? Voici une approche primitive, pour les nombres positifs:

 int roundedNumber = (number + 500) / 1000 * 1000; 

Cela apportera quelque chose comme 1499 à 1000 et 1500 à 2000.

Si vous pouviez avoir des nombres négatifs:

 int offset = (number >= 0) ? 500 : -500; int roundedNumber = (number + offset) / 1000 * 1000; 

 (int)(Math.round( 1732 / 10.0) * 10) 

Math.round(double) prend le double et arrondit ensuite à l’entier le plus proche. Donc, 1732 deviendra 173.2 (paramètre d’entrée) lors du traitement par Math.round(1732 / 10.0) . La méthode arrondit donc comme 173.0 . Ensuite, le multipliant par 10 (Math.round( 1732 / 10.0) * 10) donne la réponse arrondie, qui est 173.0 sera ensuite 173.0 en int .

Tu pourrais essayer:

 int y = 1732; int x = y - y % 10; 

Le résultat sera 1730.

Edit : Ceci ne répond pas à la question. Il supprime simplement une partie du numéro mais ne “arrondit pas au plus près”.

À dix heures près:

 int i = 1986; int result; result = i%10 > 5 ? ((i/10)*10)+10 : (i/10)*10; 

(Ajouter zéro à volonté pour cent mille).

pourquoi ne pas simplement vérifier le chiffre de l’unité … 1. s’il est inférieur ou égal à 5, ajoutez 0 à la position de l’unité et laissez le nombre tel quel. 2. s’il est supérieur à 5, incrémentez le chiffre des dizaines, ajoutez 0 à la position de l’unité.

ex: 1736 (depuis 6> = 5) le nombre arrondi sera 1740. maintenant pour 1432 (depuis 2 <5) le nombre arrondi sera 1430 ....

J’espère que cela fonctionnera … sinon, laissez-moi savoir à propos de ces cas …

Bonne programmation,

très simple. essaye ça

 int y = 173256457;int x = (y/10)*10; 

Maintenant, en cela, vous pouvez remplacer 10 par 100,1000 et ainsi de suite ….

C’est très facile..

int x = 1234; int y = x – x% 10; // ça donnera 1230

int y = x – x% 100; // Il donnera 1200

int y = x – x% 1000; // Il donnera 1000

La logique ci-dessus convertira simplement les derniers chiffres à 0. Si vous voulez un tour réel de // Par exemple. 1278 cela devrait être arrondi à 1280 car le dernier chiffre 8> 5 pour cela, j’ai écrit une fonction.

  private double returnAfterRoundDigitNum(double paramNumber, int noOfDigit) { double tempSubtractNum = paramNumber%(10*noOfDigit); double tempResultNum = (paramNumber - tempSubtractNum); if(tempSubtractNum >= (5*noOfDigit)) { tempResultNum = tempResultNum + (10*noOfDigit); } return tempResultNum; } 

Ici, passer 2 parameters l’un est le nombre et l’autre est la position jusqu’à laquelle vous devez arrondir.

Cordialement, Abhinav

  int val2 = 1732; val2 = (int)(Math.rint((double) i / 10) * 10); 

La sortie est: 1730

Avez-vous examiné la mise en oeuvre de Mathutils.round ()? Tout est basé sur BigDecimal et les conversions de chaînes. Difficile d’imaginer de nombreuses approches moins efficaces.

Sans utiliser d’outil de calcul, l’arrondi pourrait être obtenu avec une unité comme ci-dessous:

 double roundValue (double input, double toNearest){ //toNearest is any rounding base like 10, 100 or 1000. double modValue = input % toNearest; System.out.println(modValue); if(modValue == 0d){ roundedValue = input; } else { roundedValue = ((input - modValue) + toNearest); } System.out.println(roundedValue); return roundedValue; } 

Je le fais habituellement de cette façon:

 int num = 1732; int roundedNum = Math.round((num + 9)/10 * 10); 

Cela vous donnera 1740 comme résultat.

J’espère que cela aidera.

J’ai fait cette méthode simple et ça marche bien pour moi. Il arrondit à la dizaine, mais avec un petit ajustement, vous pouvez arrondir 100, 1000 et etc.

 public int round10(int num){ if (num%10 < 5){ while (num%10!=0){ num--; } } else { while (num%10!=0){ num++; } } return num; }