Quiero redondear el número 1732 a los diez, cientos y miles más cercanos. Intenté con las funciones de ronda de matemáticas, pero estaba escrito solo para flotante y doble. ¿Cómo hacer esto para Integer? ¿Hay alguna función en Java?Cómo redondear entero en java
Uso Precision (Apache Commons Math 3.1.1)
Precision.round(double, scale); // return double
Precision.round(float, scale); // return float
Use MathUtils (Apache Commons Matemáticas) - Las versiones más antiguas
MathUtils.round(double, scale); // return double
MathUtils.round(float, scale); // return float
escala - El número de dígitos a la derecha del punto decimal. (+/-)
descartado porque el método ronda (float, escala) ser utilizados.
Math.round (MathUtils.round (1732, -1)); // diez más cercanos, 1730
Math.round (MathUtils.round (1732, -2)); // 100 más cercanos, 1700
Math.round (MathUtils.round (1732, -3)); // millar más próximo, 2000
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
¿Cómo puedo hacer eso para los 12 más cercanos? –
Usted podría intentar:
int y = 1732;
int x = y - y % 10;
El resultado será 1730.
Editar: Este no da respuesta a la pregunta. Simplemente elimina parte del número pero no "redondea al más cercano".
¿Qué mecanismo de redondeo desea utilizar? He aquí un método primitivo, para los números positivos:
int roundedNumber = (number + 500)/1000 * 1000;
Esto traerá algo así como 1499 a 1000 y 1500 a 2000.
Si usted podría tener números negativos:
int offset = (number >= 0) ? 500 : -500;
int roundedNumber = (number + offset)/1000 * 1000;
Bajista anónimo, gracias. ¿Cualquier razón? – EboMike
este es el enfoque correcto: int r = ((int) ((n + 500)/1000)) * 1000 ya que solo la conversión a int corta los dígitos –
@nils: eso no tiene NINGÚN sentido. Los números ya están en entradas (según OP), por lo que fundir un int a int no hace nada. – EboMike
por qué no sólo verifique el dígito de la unidad ... 1. si es menor o igual a 5, agregue 0 en la posición de la unidad y deje el número tal como está. 2. si es más de 5, incremente el dígito de las decenas, agregue 0 en la posición de la unidad.
ex: 1736 (desde el 6 de> = 5) el número redondeado será 1740. ahora para 1432 (desde 2 < 5) el número redondeado será 1430 ....
espero que esto funcionará ... si no es que quisiera saber sobre esos casos ...
Programación feliz,
(int)(Math.round(1732/10.0) * 10)
Math.round(double) toma la double y luego repasa como un entero más cercano. Por lo tanto, 1732 se convertirá en 173.2 (parámetro de entrada) en el procesamiento por Math.round(1732/10.0). Entonces el método lo redondea como 173.0. Luego multiplicándolo con (Math.round(1732/10.0) * 10) da la respuesta redondeada, que es 173.0 y luego se convertirá en int.
Creo que 10D es lo que quiere decir en lugar de 10L. ¿No es así? +1 –
bien, funciona pero es mejor que explique cómo funciona su respuesta –
@MuhammedRefaat, 'Math.round (double)' toma el doble y luego se redondea como un entero. Por lo tanto, '1732' se convertirá en' 173.2' al procesar 'Math.round()'. Entonces el método lo redondea como '173.0'. Luego multiplicarlo por 10 da la respuesta redondeada. – Sibidharan
muy simple. probar este
int y = 173256457;int x = (y/10)*10;
Ahora, en esta se puede reemplazar el 10 por 100,1000 y así sucesivamente ....
Como se menciona en otras respuestas, esto llevaría 1739 a 1730 en lugar de 1740. – EboMike
Es muy fácil ..
int x = 1,234; int y = x - x% 10; // Proporcionará 1230
int y = x - x% 100; // Proporcionará 1200
int y = x - x% 1000; // Proporcionará 1000
La lógica anterior simplemente convertirá los últimos dígitos a 0. Si desea una ronda real de // Por ej.1278 esto debería redondear a 1280 porque el último dígito 8> 5 para esto escribí una función échale un vistazo.
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;
}
Aquí pasan 2 parámetros, uno es el número y el otro es la posición hasta la que debe redondear.
Regards, Abhinav
En decena:
int i = 1986;
int result;
result = i%10 > 5 ? ((i/10)*10)+10 : (i/10)*10;
(Agregar de cero a voluntad por ciento mil).
Esto redondea el siguiente número (al redondear al 100 más cercano) que debe redondearse hacia abajo: 170718 se redondea hacia ARRIBA a 170800. ¿Seguramente debería redondear ABAJO a 170700? – Adam893
¿Has mirado la implementación de Mathutils.round()? Todo se basa en BigDecimal y conversiones de cadenas. Es difícil imaginar muchos enfoques que son menos eficientes.
sin utilizar ningún utils matemáticas, el redondeo se podría lograr a cualquier unidad de la siguiente manera:
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;
}
He hecho este método simple y funciona bien para mí. Se redondea a decena, pero con poco ajustment puede redondear 100, 1000 y etc.
public int round10(int num){
if (num%10 < 5){
while (num%10!=0){
num--;
}
}
else {
while (num%10!=0){
num++;
}
}
return num;
}
que suele hacer de esta manera:
int num = 1732;
int roundedNum = Math.round((num + 9)/10 * 10);
esto le dará 1740 como el resultado.
Espero que esto ayude.
La respuesta que elijas está editada. – lschin