incrementi doppie in Java

Question

Eventuali duplicati:
How to iterate between 0.1f and 1.0f with 0.1f increments in Java?

Parte del mio programma deve utilizzare i valori all'interno di un ciclo while come:

0,1

0,2

0,3

...

0,9

quindi ho bisogno di fornire loro dentro quel ciclo. Ecco il codice:

double x = 0.0; 
while (x<=1) 
{ 
// increment x by 0.1 for each iteration 
x += 0.1; 
} 

Ho bisogno dell'uscita essere esattamente:

0,1

0,2

0,3

0,4

0,5

0,6

0,7

0,8

0,9

Ma in realtà mi dà qualcosa di simile:

0,1

0,2

0,300000000000000000000000004

0,4

0,5

0,6

0,79999999999999999999999999

0,89999999999999999999999999

0,99999999999999999999999999

Answer 1

Benvenuti nel mondo di virgola mobile, in cui 0,1 non è 0,1. Il problema è che molti numeri, incluso 0.1, non può essere rappresentato esattamente in un double. Quindi non stai aggiungendo esattamente da 0,1 a x ogni volta attraverso il ciclo.

Un approccio è quello di utilizzare l'aritmetica intera e dividere per 10:

int i = 0; 
while (i <= 10) { 
    double x = i/10.0; 
    . . . 
    i++; 
} 

Un altro approccio è quello di fare un xBigDecimal, in cui è possibile specificare che si desidera una particolare precisione. Fondamentalmente sta facendo quello che fa il ciclo precedente (un numero intero più una scala), ma confezionato in una bella classe con un sacco di campane e fischietti. Oh, e ha una precisione arbitraria.

Answer 2

Utilizzando BigDecimal

double x = 0.0; 
    int decimalPlaces = 2;   

    while (x<=1) 
    { 

    x += 0.1; 
    BigDecimal bd = new BigDecimal(x); 
    bd = bd.setScale(decimalPlaces, BigDecimal.ROUND_HALF_UP); 
    x = bd.doubleValue();   

    System.out.println(x); 
    } 

Answer 3

Questo perché è possibile utilizzare il virgola mobile binario per eseguire un'aritmetica decimale precisa perché FP non può rappresentare con precisione tutti i valori decimali.

È necessario utilizzare un valore intero che rappresenta un'unità decimale decimale come centesimi o millesimi o utilizzare qualcosa come BigDecimal.

Answer 4

doppia è memorizzato in binario

galleggiante e doppie memorizzare numeri da un certo numero di cifre significative e un punto radice (come tipo di notazione scientifica). La parte delle figure significative non è sempre perfetta, perché è memorizzata come un certo numero di cifre binarie, quindi non puoi aspettarti che funzioni nel modo in cui ti aspetti. (Per una spiegazione migliore vedere http://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html)

considerare l'utilizzo di una classe, come BigDecimal o di una classe che implementa numeri razionali, come quelli menzionati qui - Is there a commonly used rational numbers library in Java?

Si potrebbe anche solo girare i in un intero, e il cambiamento da 1 a 10 e compensare questo nel codice.

Answer 5

Per ottenere l'output desiderato, è possibile utilizzare DecimalFormat. Ecco alcuni esempi di codice.

import java.text.DecimalFormat; 

public class DF { 

    public static void main(String [] args) { 

    double x = 0.1; 
    DecimalFormat form = new DecimalFormat("#.#"); 
    while (x <= .9) { 
     System.out.println(Double.valueOf(form.format(x))); 
     x += 0.1; 
    } 

    } 

} 

Per quanto riguarda l'attuazione che hai ora, non v'è alcuna garanzia circa la precisione di ciò che viene stampato a causa della natura dei numeri in virgola mobile.

Answer 6

è necessario utilizzare il formattatore decimale per ottenere l'output previsto.

Di seguito si riporta il codice per la generazione l'uscita prevista:

import java.text.DecimalFormat; 


public class FloatIncrement { 

    public static void main (String args[]){ 

     double x= 0.0; 
     DecimalFormat form = new DecimalFormat("#.#");  
     while(x<0.9){ 
      x= x+0.1; 
      System.out.println("X : "+Double.valueOf(form.format(x)));   

     } 

    } 
}