round - redondear decimales en java netbeans

¿Hay alguna función Java o clase util que redondee de esta manera: func(3/2)=2?

Question

¿Hay alguna función Java o class util que redondee de esta manera: func(3/2) = 2

Math.ceil() no ayuda, lo que por su nombre debería haberlo hecho. Soy consciente de BigDecimal , pero no lo necesito.

Answer 1

¿Has probado Math.floor() ?

Answer 2

¿No es este el caso habitual de división entera? Pruebe Math.Ceil después de convertir cualquier número a un tipo de punto flotante.

Answer 3

Aquí hay un método que creé para manejar la división int sin usar Math Round y casting para flotar. Esto funciona para números positivos y negativos. Funciona agregando la mitad del denominador para compensar el redondeo hacia abajo

public static int div_Int(int num, int den){
    if(num > 0 && den > 0 || num < 0 && den < 0 ){
        return ((2*num)+ den)/(2*den);  
    }else{
        return ((2*num)- den)/(2*den);
    }

}

Answer 4

En Java, 3/2 = 1 porque usa división entera. No hay ninguna función que pueda "arreglar" esto después. Lo que tienes que hacer es forzar una división de flotador y redondear el resultado:

int result = (int)Math.ceil( ((float)3) / ((float)2) );

Answer 5

Math.ceil te ayudará, siempre y cuando utilices números de punto flotante. El problema es que 3/2, en la división entera, es 1. En el momento en que el valor llega a cualquier función, ya sea Math.ceil o alguna otra cosa, el valor es simplemente 1. Cualquier parte decimal final se ha ido.

Answer 6

Me gusta la respuesta de Randy Proctor la mejor. Aquí con más detalle:

Si desea realizar un redondeo real (es decir, 3/2 -> 2, pero 17/7 -> 2) con enteros> 0: use (dividend + (divisor / 2)) / divisor lugar de dividend / divisor .

Si el dividendo puede ser cualquier entero (es decir, negativo permitido): (dividend >= 0) ? ((dividend + divisor / 2) / divisor) : ((dividend - divisor / 2) / divisor) (dividend >= 0) ? ((dividend + divisor / 2) / divisor) : ((dividend - divisor / 2) / divisor) .

Si dividendo es cualquier entero y divisor, cualquier entero menos 0: (dividend >= 0) ? ((dividend + Math.abs(divisor) / 2) / divisor) : ((dividend - Math.abs(divisor) / 2) / divisor) (dividend >= 0) ? ((dividend + Math.abs(divisor) / 2) / divisor) : ((dividend - Math.abs(divisor) / 2) / divisor) .

(Tenga en cuenta que la suma y la resta pueden causar un envolvente que de lo contrario no se produciría, lo que hace que el resultado sea incorrecto).

Answer 7

Muchos idiomas "piensan" así. Si está dividiendo un int en un int, entonces debería obtener un int (para que se trunquen y obtenga 1 como resultado).

Todos sabemos que esto no es cierto, pero así es como funcionan. Puede "engañarlos" y hacer algo como lanzar uno de ellos al doble, o usar una representación doble: Math.ceil (3.0 / 2) o Math.ceil((double)3/2) , como se mencionó.

Answer 8

Para convertir la división de piso en división de techo:

(numerator + denominator-1) / denominator

Para convertir la división de piso en división de redondeo:

(numerator + (denominator)/2) / denominator

Answer 9

Si realmente desea evitar el uso de ceil y casting, aquí hay un pequeño método que logra lo mismo.

public int findCeil(int X, int Y) {
        if (X % Y == 0){
            return X / Y;
        } else {
            return X / Y + 1;
        }
    }

Answer 10

Si solo quieres dividir por 2, puedes hacer:

n - n / 2

Y en general:

(n - 1) / d + 1 == (n + d - 1) / d

Esto es válido para los enteros no negativos. Cómo extenderlo a enteros negativos depende de lo que quiere decir con "redondear de esta manera". La división entera se redondea hacia cero, mientras que Math.ceil() redondea hacia arriba y Math.floor() redondea hacia abajo. Por ejemplo n / 2 != (int) Math.floor(n / 2.0) para n == -5 .

Si siempre quieres redondear, puedes usar Math.ceil() como en esta respuesta .

Answer 11

Siempre puedes lanzar primero

Math.ceil((double)3/2)

Answer 12

Un poco de magia negra, y puedes hacerlo todo con enteros:

// Divide x by n rounding up
int res = (x+n-1)/n

Answer 13

el fragmento de abajo también funciona con enteros negativos:

public static int divRoundUp(int x, int n) {
    if (n<=0) throw new RuntimeException("conceived wt. pos. dividers (was:"+n+")");
    int ret = (x+(n-1)*(x>0?1:0))/n;
    return ret;
}

Answer 14

Math.ceil() siempre se redondeará, sin embargo, estás haciendo una división entera con 3/2 . Por lo tanto, dado que en la división de enteros 3/2 = 1 (no 1.5 ) el techo de 1 es 1 .

Lo que debe hacer para lograr los resultados que desea es Math.ceil(3/2.0);

Al hacer la división por una cantidad doble ( 2.0 ), terminas haciendo una división de punto flotante en lugar de una división de enteros. Así, 3/2.0 = 1.5 , y el ceil() de 1.5 es siempre 2 .

Answer 15

if (a % b == 0)
{
  return (a / b);
}
else
{
  return (a / b) + 1;
}

Explota la división entera para hacer lo que quieras. No conozco una función matemática que haga esto, pero ¿por qué no rodar la tuya?