round - redondear cantidades java

Redondeo hasta los cien más cercanos

Question

Llegué a una parte de mi programa de Java donde necesito redondear a la centena más cercana y pensé que probablemente había alguna forma de hacerlo, pero supongo que no. Así que busqué en la red ejemplos o respuestas y aún no he encontrado ninguno, ya que todos los ejemplos parecen ser de la centena más cercana. Solo quiero hacer esto y redondear hacia arriba. Tal vez hay alguna solución simple que estoy pasando por alto. He probado Math.ceil y otras funciones, pero aún no he encontrado una respuesta. Si alguien pudiera ayudarme con este problema lo agradecería enormemente.

Si mi número es 203, quiero que el resultado redondeado sea 300. Obtiene el punto.

1. 801-> 900
2. 99-> 100
3. 14-> 100
4. 452-> 500

Answer 1

Aproveche la división de enteros, que trunca la parte decimal del cociente. Para que parezca que se está redondeando, agregue 99 primero.

int rounded = ((num + 99) / 100 ) * 100;

Ejemplos:

801: ((801 + 99) / 100) * 100 → 900 / 100 * 100 → 9 * 100 = 900
99 : ((99 + 99) / 100) * 100 → 198 / 100 * 100 → 1 * 100 = 100
14 : ((14 + 99) / 100) * 100 → 113 / 100 * 100 → 1 * 100 = 100
452: ((452 + 99) / 100) * 100 → 551 / 100 * 100 → 5 * 100 = 500
203: ((203 + 99) / 100) * 100 → 302 / 100 * 100 → 3 * 100 = 300
200: ((200 + 99) / 100) * 100 → 299 / 100 * 100 → 2 * 100 = 200

Cotización relevante de la especificación del lenguaje Java, Sección 15.17.2 :

La división de enteros se redondea hacia 0. Es decir, el cociente producido para los operandos n y d que son enteros después de la promoción numérica binaria (§5.6.2) es un valor entero q cuya magnitud es tan grande como sea posible mientras satisface | d · q | ≤ | n |.

Answer 2

Aquí hay un algoritmo que creo que funciona para cualquier caso "múltiple de". Déjame saber lo que piensas.

int round (int number,int multiple){

    int result = multiple;

    //If not already multiple of given number

    if (number % multiple != 0){

        int division = (number / multiple)+1;

        result = division * multiple;

    }

    return result;

}

Answer 3

El siguiente código me sirve para redondear un número entero a los siguientes 10 o 100 o 500 o 1000, etc.

public class MyClass {
    public static void main(String args[]) {
        int actualValue = 34199;
        int nextRoundedValue = 500 // change this based on your round requirment ex: 10,100,500,...
        int roundedUpValue = actualValue;

        //Rounding to next 500
        if(actualValue%nextRoundedValue != 0)
          roundedUpValue =
(((actualValue/nextRoundedValue)) * nextRoundedValue) + nextRoundedValue;
         System.out.println(roundedUpValue);
    }
}

Answer 4

Esto funcionó perfectamente para mí:

    var round100 = function(n) {
        if (n < 50) {
            var low = n - (n % 100);
            return Math.round(low);     
        }

        return Math.round(n/100) * 100;
    }

Puedes asignar tus var (variables) a cualquier cosa.

Answer 5

No tengo suficiente reputación para agregar un comentario a la respuesta de , pero creo que debería ser:

`
if (number % multiple != 0) {
    int division = (number / multiple) + 1;
    result = division * multiple;
} else {
    result = Math.max(multiple, number);
}
`

con la else para que, por ejemplo, round(9, 3) = 9 , de lo contrario sería round(9, 3) = 3

Answer 6

Otra forma es usar BigDecimal

private static double round(double number, int precision, RoundingMode roundingMode) {
    BigDecimal bd = null;
    try {
        bd = BigDecimal.valueOf(number);
    } catch (NumberFormatException e) {
        // input is probably a NaN or infinity
        return number;
    }
    bd = bd.setScale(precision, roundingMode);
    return bd.doubleValue();
}

round(102.23,0,RoundingMode.UP) = 103  
round(102.23,1,RoundingMode.UP) = 102.3  
round(102.23,2,RoundingMode.UP) = 102.24  
round(102.23,-1,RoundingMode.UP) = 110  
round(102.23,-2,RoundingMode.UP) = 200  
round(102.23,-3,RoundingMode.UP) = 1000

Answer 7

Prueba esto:

(int) (Math.ceil(number/100.0))*100

Answer 8

int roundUpNumberByUsingMultipleValue(double number, int multiple) {

        int result = multiple;

        if (number % multiple == 0) {
            return (int) number;
        }

        // If not already multiple of given number

        if (number % multiple != 0) {

            int division = (int) ((number / multiple) + 1);

            result = division * multiple;

        }
        return result;

    }

Example:
System.out.println("value 1 =" + round(100.125,100));   
System.out.println("value 2 =" + round(163,50));
System.out.println("value 3 =" + round(200,100));
System.out.println("value 4 =" + round(235.33333333,100));
System.out.println("value 5 =" + round(0,100));

OutPut: 
value 1 =200
value 2 =200
value 3 =200
value 4 =300
value 5 =0

Answer 9

long i = 2147483648L;
if(i % 100 != 0) {
   long roundedI = (100 - (i % 100)) + i;
}

Ejemplo:

649: (100 - (649 % 100)) + 649 -> (100 - 49) + 649) -> 51 + 649 = 700
985: (100 - (985 % 100)) + 985 -> (100 - 85) + 985) -> 15 + 985 = 1000

El tipo de datos largo se utiliza para asegurarse de que la limitación del rango de enteros no debe causar ningún problema para valores más grandes. Por ejemplo, esto podría ser muy importante en el caso de un valor de importe (dominio bancario).

Answer 10

A simple implementation of rgettman which gives:
roudUp(56007)=60000
roudUp(4511)=5000
roudUp(1000)=1000
roudUp(867)=900
roudUp(17)=20
roudUp(5)=10
roudUp(0)=0


import java.util.*;

public class Main {
    static int roundUp(int src){
        int len = String.valueOf(src).length()-1;
        if (len==0) len=1;
        int d = (int) Math.pow((double) 10, (double) len);
        return (src + (d-1))/d*d;
    }
    public static void main(String[] args)  {
        System.out.println("roudUp(56007)="+roundUp(56007));
        System.out.println("roudUp(4511)="+roundUp(4511));
        System.out.println("roudUp(1000)="+roundUp(1000));
        System.out.println("roudUp(867)="+roundUp(867));
        System.out.println("roudUp(17)="+roundUp(17));
        System.out.println("roudUp(5)="+roundUp(5));
        System.out.println("roudUp(0)="+roundUp(0));
    }
}