(360/24)/60 = 0 ... en Java

Question

Estoy tratando de calcular (360/24)/60 me siguen dando la respuesta 0.0 cuando debería obtener 0,25

En palabras: querer dividir 360 por 24 y luego dividir el resultado por 60

public class Divide { 

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

    } 
} 

Esto muestra:

0,0

¿Por qué es eso? Estoy haciendo algo realmente estúpido, o hay una buena razón para esto

Answer 1

Ninguno de los operandos en la aritmética es un flotador - así que todo se hace con la aritmética de enteros y luego convierte en 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 que se realiza como aritmética de enteros, lo cual está bien en este caso particular, pero no representa lo que sospecho que realmente pretendías. Básicamente, debe asegurarse de que la operación aritmética se realice de la manera que desee.

Answer 2

En realidad estás haciendo una división de enteros (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 realizar la división en coma flotante, al menos uno de los operandos debe ser de 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, usted quiere hacer la mayor cantidad de cálculo con double, antes de convertirse al float. De hecho, a menos que su perfil demuestre que absolutamente necesita float, siempre 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 principal método,

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 los valores enteros. Como tal, obtendrás valores extraños.

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

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

-> 0 (integer value) 

Luego, al asignar 0 a una variable de coma flotante, cambia 0 a un valor de coma flotante, 0.0. Por lo tanto, el resultado.

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

el código correcto debe ser como tal:

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