Perché (360/24)/60 = 0 ... in Java

Question

Sto cercando di calcolare (360/24)/60 Continuo a ricevere la risposta 0.0 quando dovrei ottenere 0,25

In parole: io vogliono dividere 360 ​​per 24 e poi dividere il risultato per 60

public class Divide { 

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

    } 
} 

Questo stampa:

0,0

Perché è così? Sto facendo qualcosa di veramente stupido, o c'è una buona ragione per questo

Answer 1

Nessuno degli operandi in aritmetica è un galleggiante - quindi è tutto stato fatto con l'aritmetica intero e poi convertito in un float. Se si cambia il tipo di un operando appropriato per un galleggiante, che funzionerà bene:

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

Si noti che se si è modificato solo 60 per essere un galleggiante, che ci si finisce con l'360/24 in corso di esecuzione come aritmetica intera - che va bene in questo caso particolare, ma non rappresenta ciò che sospetto che tu intendessi veramente. Fondamentalmente è necessario assicurarsi che l'operazione aritmetica venga eseguita nel modo desiderato.

Answer 2

In realtà si sta eseguendo la divisione di interi (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; 

Per eseguire la divisione in virgola mobile, almeno uno degli operandi deve essere un tipo numerico a virgola mobile.

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

---

Suggerimento: se la precisione è importante, si vuole fare come gran parte del calcolo con double, prima della conversione in float. Infatti, a meno che il tuo profilo non dimostri che hai assolutamente bisogno di float, devi sempre preferire 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

Nel metodo principale,

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

noti che 360, 24 e 60 sono tutti i valori interi. Come tale otterrete valori strani.

360/24 -> 15 (perfettamente bene)
15/60 -> 0.4 (floating point)

Purtroppo per voi galleggiare i numeri in virgola vengono troncati in tal modo si ottiene:

-> 0 (integer value) 

Quindi, assegnando 0 a una variabile in virgola mobile, si cambia 0 in un valore in virgola mobile, 0.0. Quindi il risultato.

Se si desidera dividerli è necessario modificarli in valori in virgola mobile.

Il codice corretto dovrebbe essere come tale:

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