Come ottengo la parte dopo il punto decimale in Java?

Ho una double variabile d = 1.15 .

Voglio il numero dopo il punto decimale, cioè “15”.

Qual è il modo migliore per ottenere questo in Java?

Ho provato in questo modo:

 Double d = 1.15; String str = d.toString(); int len = str.substring(str.indexOf(".")).length() - 1; int i= (int) (d * (long)Math.pow(10,len) % (long)Math.pow(10,len)); 

Ma non ho ottenuto la risposta corretta perché quando converto d.toString() la risposta è 14.999999999999986 .

prova questo,

 String numberD = String.valueOf(d); numberD = numberD.substring ( numberD.indexOf ( "." ) ); 

Ora questa variabile numberD avrà un valore di 24

Prova Math.floor ();

 double d = 4.24; System.out.println( d - Math.floor( d )); 

Per evitare errori di arrotondamento potresti convertirli in BigDecimal

  double d = 4.24; BigDecimal bd = new BigDecimal( d - Math.floor( d )); bd = bd.setScale(4,RoundingMode.HALF_DOWN); System.out.println( bd.toString() ); 

Stampa 0.2400

Si noti che il 4 in setScale è il numero di cifre dopo il separatore decimale (‘.’)

Per avere il resto come valore intero, puoi modificarlo

 BigDecimal bd = new BigDecimal(( d - Math.floor( d )) * 100 ); bd = bd.setScale(4,RoundingMode.HALF_DOWN); System.out.println( bd.intValue() ); 

Stampa 24

Il numero dopo il punto decimale non è un concetto ben definito. Ad esempio per “4.24”, potrebbe essere “0.24”, “0.239999999999” (o simile), “24” o “239999999999”.

Devi essere chiaro se stai parlando di un numero o di una stringa di cifre decimali … e se il valore di input è una rappresentazione di un numero in virgola mobile binario (nel qual caso “4.24” è molto probabilmente un’approssimazione) un decimale numero in virgola mobile.

A seconda della tua interpretazione, la risposta corretta sarà diversa.


Ma non ho ottenuto la risposta corretta perché quando ho convertito d.toString () la risposta è 14.999999999999986.

Si sta affrontando il problema che double e float sono formati in virgola mobile di base-2, e nella maggior parte dei casi non possono rappresentare precisamente i numeri decimali in virgola mobile. Non c’è una soluzione per questo … a parte l’utilizzo di qualcosa come BigDecimal per rappresentare i tuoi numeri. (E anche allora, una certa perdita di precisione è ansible ogni volta che si esegue un’operazione di divisione o modulo.)

Se vuoi le cifre decimali e vuoi arrotondare il risultato.

 double d = 4.24; System.out.printf("%0.2f%n", d - (long) d); 

stampe

 0.24 

Se si desidera un valore arrotondato, è necessario determinare la precisione desiderata.

 double d = 4.24; double fract = d - (long) d; fract = (long) (fract * 1e9 + 0.5) / 1e9; // round to the 9 decimal places. 

Se il tuo doppio è:

 d = 1.25; 

E se lo fai:

 String number = String.valueOf(d); number = number.substring(number.indexOf(".")).substring(1); 

allora il number sarà 25 .

Non so se questo è il modo migliore per farlo, ma funziona.

Prova RegEx, qui ^\d*\. , cercherà le cifre seguite dal punto e sostituirà con lo spazio vuoto.

 for(double d : new double[]{1.15,0.009,222.9,3.67434}){ System.out.println(String.valueOf(d).replaceAll("^\\d*\\.","")); } 

dà:

 15 009 9 67434 

Hai provato d = d%1.0 ? Questo dovrebbe restituire il resto della divisione d per 1, che dovrebbe essere solo la parte decimale.

Puoi anche farlo per ottenere il valore int: d = (int)((d%1.0)*100)

Invece di d.toString() , prova questo:

 String str = String.format("%.2f", d); 

Proprio come in qualsiasi altra lingua: moltiplicare per 10 e controllare la parte int del residuo quando si divide per 10. Allo stesso modo si estraggono cifre da un numero intero.

 short[] digits = new short[max_len]; double tmp = d - ((int) d); for (int i = 0; i < digits.length && tmp != 0; i++) { tmp *= 10; digit[i] = (short) tmp; tmp -= (int) tmp; } 

Ma sappi che per il doppio devi introdurre un limite di precisione, ovvero il numero massimo di cifre da estrarre (max_len dall'esempio di codice sopra riportato).

Leggero aggiornamento (arrotondamento aggiunto al limite della precisione):

 double d = 1.15; short[] digits = new short[10]; double tmp = d - ((int) d) + 0.5 * 1e-10; for (int i = 0; i < digits.length && tmp != 0; i++) { tmp *= 10; digits[i] = (short) tmp; tmp -= (int) tmp; } 

prova questo :

 double d = 1.1512; int i = (int) (d*100 - Math.floor(d)*100); 

ora questo ti darà: 15