¿Por qué (360/24)/60 = 0… en Java?

Question

Estoy intentando calcular (360/24)/60. Sigo obteniendo la respuesta 0,0 cuando debería obtener 0,25.

En palabras:quiero dividir 360 entre 24 y luego dividir el resultado entre 60

public class Divide {

    public static void main(String[] args){
      float div = ((360 / 24) / 60);
      System.out.println(div);

    }
}

Esto imprime:

0.0

¿Porqué es eso?¿Estoy haciendo algo realmente estúpido o hay una buena razón para ello?

Answer 1

Ninguno de los operandos en la aritmética es un flotador - así que todo está haciendo con aritmética de enteros y entonces convertidos a un flotador. Si cambia el tipo de un operando apropiada a un flotador, que va a trabajar bien:

float div = ((360 / 24f) / 60); // div is now 0.25

Tenga en cuenta que si ha cambiado a 60 para ser un flotador, que terminarías con el 360/24 se realiza como aritmética de enteros - que está muy bien en este caso en particular, pero no representa lo que sospecho que realmente pretendía . Básicamente, usted tiene que asegurarse de que la operación aritmética se realiza en la forma en que desea.

Answer 2

En realidad estás haciendo división entera ( JLS 15.17.2 ).

float div = ((360 / 24) / 60);
float div = (float) ((360 / 24) / 60);
float div = (float) (15 / 60);
float div = (float) (0);
float div = 0F;

Para hacer una división en coma flotante, al menos uno de los operandos tienen que ser un tipo numérico de coma flotante.

float div = ((360F / 24) / 60);
float div = 15F / 60;
float div = 0.25F;

---

Consejo: si la precisión es importante, que quiere hacer la mayor cantidad de cálculo con double, antes de convertirse al float. De hecho, a menos que su perfilado demuestra que es absolutamente necesario float, siempre se debe preferir double.

    float f;

    f = (1E-17F * 1E-17F);
    System.out.println(f); // prints "9.999999E-35"

    f = (float) (1E-17D * 1E-17D);
    System.out.println(f); // prints "1.0E-34"

Answer 3

En su método principal,

public static void main(String[] args){
      float div = ((360 / 24) / 60);
      System.out.println(div);
}

Tenga en cuenta que 360, 24 y 60 son todos valores enteros.Como tal obtendrás valores extraños.

360/24 -> 15 (perfectamente bien)
15/60 -> 0,4 ​​(coma flotante)

Desafortunadamente para usted, los números de coma flotante se truncan, por lo que obtiene:

-> 0 (integer value)

Luego, al asignar 0 a una variable de punto flotante, cambia 0 a un valor de punto flotante, 0,0.De ahí el resultado.

Si desea dividirlos, debe cambiarlos a valores de punto flotante.

El código correcto debería ser el siguiente:

public static void main(String[] args){
      float div = ((360.0 / 24.0) / 60.0);
      System.out.println(div);
}