determinare il numero di decimali Place utilizzando BigDecimal

Question

ero interessato ad avere la seguente funzione getNumberOfDecimalPlace:

System.out.println("0 = " + Utils.getNumberOfDecimalPlace(0));   // 0 
    System.out.println("1.0 = " + Utils.getNumberOfDecimalPlace(1.0));  // 0 
    System.out.println("1.01 = " + Utils.getNumberOfDecimalPlace(1.01)); // 2 
    System.out.println("1.012 = " + Utils.getNumberOfDecimalPlace(1.012)); // 3 
    System.out.println("0.01 = " + Utils.getNumberOfDecimalPlace(0.01)); // 2 
    System.out.println("0.012 = " + Utils.getNumberOfDecimalPlace(0.012)); // 3 

Posso sapere come posso implementare getNumberOfDecimalPlace, utilizzando BigDecimal?

Il seguente codice non funziona come previsto:

public static int getNumberOfDecimalPlace(double value) { 
    final BigDecimal bigDecimal = new BigDecimal("" + value); 
    final String s = bigDecimal.toPlainString(); 
    System.out.println(s); 
    final int index = s.indexOf('.'); 
    if (index < 0) { 
     return 0; 
    } 
    return s.length() - 1 - index; 
} 

Di seguito vengono stampati:

0.0 
0 = 1 
1.0 
1.0 = 1 
1.01 
1.01 = 2 
1.012 
1.012 = 3 
0.01 
0.01 = 2 
0.012 
0.012 = 3 

Tuttavia, per il caso del 0, 1.0, non funziona bene. Mi aspetto, "0" come risultato. Ma si sono rivelati "0.0" e "1.0". Ciò restituirà "1" come risultato.

Answer 1

Questo codice:

int getNumberOfDecimalPlaces(BigDecimal bigDecimal) { 
    String string = bigDecimal.stripTrailingZeros().toPlainString(); 
    int index = string.indexOf("."); 
    return index < 0 ? 0 : string.length() - index - 1; 
} 

... supera questi test:

assertThat(getNumberOfDecimalPlaces(new BigDecimal("0.001")), equalTo(3)); 
assertThat(getNumberOfDecimalPlaces(new BigDecimal("0.01")), equalTo(2)); 
assertThat(getNumberOfDecimalPlaces(new BigDecimal("0.1")), equalTo(1)); 
assertThat(getNumberOfDecimalPlaces(new BigDecimal("1.000")), equalTo(0)); 
assertThat(getNumberOfDecimalPlaces(new BigDecimal("1.00")), equalTo(0)); 
assertThat(getNumberOfDecimalPlaces(new BigDecimal("1.0")), equalTo(0)); 
assertThat(getNumberOfDecimalPlaces(new BigDecimal("1")), equalTo(0)); 
assertThat(getNumberOfDecimalPlaces(new BigDecimal("10")), equalTo(0)); 
assertThat(getNumberOfDecimalPlaces(new BigDecimal("10.1")), equalTo(1)); 
assertThat(getNumberOfDecimalPlaces(new BigDecimal("10.01")), equalTo(2)); 
assertThat(getNumberOfDecimalPlaces(new BigDecimal("10.001")), equalTo(3)); 

... se è davvero quello che vuoi. Le altre risposte sono corrette, devi utilizzare BigDecimal fino in fondo anziché doppio/float.

Answer 2

Che ne dici di dare un'occhiata al javadoc di BigDecimal. Non sono sicuro, ma darei una prova a getScale e getPercision.

Answer 3

Il modo migliore per ottenere un BigDecimal con un numero specificato di posizioni decimali consiste nell'utilizzare il metodo setscale su di esso. Personalmente mi piace utilizzare anche la versione arrotondamento del metodo (vedi link in basso): http://java.sun.com/j2se/1.5.0/docs/api/java/math/BigDecimal.html#setScale(int,%20int)

Se hai intenzione di ottenere il numero di posizioni decimali che un BigDecimal è attualmente fissato a chiamata scala associato () metodo.

Answer 4

Perché non basta modificare il codice per ottenere cifre decimali doppie?

public static int getNumberOfDecimalPlace(double value) { 
    //For whole numbers like 0 
    if (Math.round(value) == value) return 0; 
    final String s = Double.toString(value); 
    System.out.println(s); 
    final int index = s.indexOf('.'); 
    if (index < 0) { 
     return 0; 
    } 
    return s.length() - 1 - index; 
} 

Answer 5

Non è il tuo codice che è sbagliato, ma le tue aspettative. double si basa su una rappresentazione in virgola mobile e completamente non adatta per rappresentare con precisione le frazioni decimali. Decimale 0,1 ad es. ha un numero infinito di cifre quando rappresentato in binario, quindi viene troncato e quando viene convertito in decimale, si ottengono degli errori nelle cifre meno significative.

Se si utilizza BigDecimal esclusivamente, il codice funzionerà come previsto.

Answer 6

Se davvero ottieni il doppio, ti consiglio di formularli prima come stringhe prima di creare lo BigDecimal. Almeno che ha funzionato per me: How to check if a double has at most n decimal places?

seconda del numero di cifre che ci si aspetta è possibile utilizzare la formattazione standard come

String.valueOf(doubleValue); 

o si potrebbe utilizzare la formattazione specializzato per evitare formato esponenziale

DecimalFormat decimalFormat = new DecimalFormat(); 
decimalFormat.setMaximumIntegerDigits(Integer.MAX_VALUE); 
// don't use grouping for numeric-type cells 
decimalFormat.setGroupingUsed(false); 
decimalFormat.setDecimalFormatSymbols(new DecimalFormatSymbols(Locale.US)); 
value = decimalFormat.format(numericValue); 

Se hai un BigDecimal puoi semplicemente chiamare scale() per ottenere il numero di posizioni decimali.

Answer 7

La risposta di Michael Borgwardt è corretta. Non appena si usa un doppio o un float, i valori sono già corrotti.

Per fornire un esempio di codice:

System.out.println("0 = " + BigDecimalUtil.getNumberOfDecimalPlace("0")); // 0 
System.out.println("1.0 = " + BigDecimalUtil.getNumberOfDecimalPlace("1.0")); // 0 
System.out.println("1.01 = " + BigDecimalUtil.getNumberOfDecimalPlace(new BigDecimal("1.01"))); // 2 
System.out.println("1.012 = " + BigDecimalUtil.getNumberOfDecimalPlace(new BigDecimal("1.012"))); // 3 
System.out.println("0.01 = " + BigDecimalUtil.getNumberOfDecimalPlace("0.01")); // 2 
System.out.println("0.012 = " + BigDecimalUtil.getNumberOfDecimalPlace("0.012")); // 3 
System.out.println("0.00000000000000000012 = " + BigDecimalUtil.getNumberOfDecimalPlace("0.00000000000000000012")); // 20 

E una versione di overload di getNumberOfDecimalPlace così si potrebbe usare con BigDecimal o stringa:

public static int getNumberOfDecimalPlace(String value) { 
    final int index = value.indexOf('.'); 
    if (index < 0) { 
     return 0; 
    } 
    return value.length() - 1 - index; 
} 

public static int getNumberOfDecimalPlace(BigDecimal value) { 
    return getNumberOfDecimalPlace(value.toPlainString()); 
} 

Answer 8

Prova questo:

Math.floor(Math.log(x)/Math.log(10)) 
0.001 = -3 
0.01 = -2 
0.1 = -1 
1  = 0 
10 = 1 
100 = 2 

Answer 9

che dovrebbe farlo

int getNumberOfDecimalPlace(BigDecimal number) { 
    int scale = number.stripTrailingZeros().scale(); 
    return scale > 0 ? scale : 0; 
} 

Answer 10

Combinando Turismo, Robert e user1777653's risposte, abbiamo:

int getNumberOfDecimalPlaces(BigDecimal bigDecimal) { 
    return Math.max(0, bigDecimal.stripTrailingZeros().scale()); 
} 

• stripTrailingZeros() assicura che il trailing gli zeri non vengono contati (ad es. 1.0 ha 0 posizioni decimali).
• scale() è più efficiente di String.indexOf().
• Un valore negativo scale() rappresenta zero cifre decimali.

Ecco, il meglio di entrambi i mondi.

Answer 11

opzione migliore che ho trovato finora (non avendo bisogno toString + indice):

public static int digitsStripTrailingZero(BigDecimal value) 
{ 
    return digits(value.stripTrailingZeros()); 
} 

public static int digits(BigDecimal value) 
{ 
    return Math.max(0, value.scale()); 
} 

Answer 12

senza dover convertire in stringa, dovrebbe essere più efficiente di utilizzare la bilancia direttamente:

private int getNumberOfDecimalPlaces(BigDecimal bigDecimal) 
    { 
    int scale = bigDecimal.stripTrailingZeros().scale(); 
    return scale>0?scale:0; 
    }