Come sapere se un BigDecimal può esattamente convertire in float o doppio?

La classe BigDecimalha alcuni metodi utili per garantire la conversione senza perdita di dati:

• byteValueExact()
• shortValueExact()
• intValueExact()
• longValueExact()

Tuttavia, i metodi floatValueExact()e doubleValueExact()non esistono.

Ho letto il codice sorgente OpenJDK per i metodi floatValue()e doubleValue(). Entrambi sembrano ripiegare su Float.parseFloat()e Double.parseDouble(), rispettivamente, che possono restituire l'infinito positivo o negativo. Ad esempio, l'analisi di una stringa di 10.000 9s restituirà l'infinito positivo. A quanto ho capito, BigDecimalnon ha un concetto interno di infinito. Inoltre, analizzando una stringa di 100 9s come doubledà 1.0E100, che non è infinito, ma perde precisione.

Che cos'è un'implementazione ragionevole floatValueExact()e doubleValueExact()?

Ho pensato a una doublesoluzione combinando BigDecimal.doubleValue(), BigDecial.toString(), Double.parseDouble(String)e Double.toString(double), ma sembra disordinato. Voglio chiedere qui perché potrebbe (deve!) Esserci una soluzione più semplice.

Per essere chiari, non ho bisogno di una soluzione ad alte prestazioni.

Dalla lettura dei documenti , tutto ciò che fa con le numTypeValueExactvarianti è verificare l'esistenza di una parte di frazione o se il valore è troppo grande per il tipo numerico e generare eccezioni.

Per quanto riguarda floatValue()e doubleValue(), viene eseguito un controllo di overflow simile, ma invece di generare un'eccezione, restituisce invece Double.POSITIVE_INFINITYo Double.NEGATIVE_INFINITYper i doppi e Float.POSITIVE_INFINITYo Float.NEGATIVE_INFINITYper i float.

Pertanto l'implementazione più ragionevole (e più semplice) dei exactmetodi per float e double, dovrebbe semplicemente verificare se la conversione ritorna POSITIVE_INFINITYo NEGATIVE_INFINITY.

Inoltre , ricorda che è BigDecimalstato progettato per gestire la mancanza di precisione derivante dall'uso floato doubleper grandi irrazionali, quindi come ha commentato @JB Nizet , un altro controllo che puoi aggiungere a quello sopra sarebbe convertire doubleo floattornare indietro BigDecimalper vedere se hai ancora lo stesso valore. Ciò dovrebbe dimostrare che la conversione era corretta.

Ecco come sarebbe un metodo simile floatValueExact():

public static float floatValueExact(BigDecimal decimal) {
    float result = decimal.floatValue();
    if (!Float.isInfinite(result)) {
        if (new BigDecimal(String.valueOf(result)).compareTo(decimal) == 0) {
            return result;
        }
    }
    throw new ArithmeticException(String.format("%s: Cannot be represented as float", decimal));
}

L'uso di al compareToposto di equalssopra è intenzionale in modo da non diventare troppo rigoroso con i controlli. equalsvaluterà vero solo quando i due BigDecimaloggetti hanno lo stesso valore e scala (dimensione della parte della frazione del decimale), mentre compareTotrascurerà questa differenza quando non ha importanza. Per esempio 2.0vs 2.00.