Segno negativo in caso di zero in java

Question

Esiste un modo per troncare il segno negativo quando il risultato restituisce zero; mentre si utilizza il formato decimale?

DecimalFormat df = new DecimalFormat("#,##0.0"); 
df.setRoundingMode(RoundingMode.HALF_UP); 
formattedValue = df.format("-0.023"); 

Il codice precedente restituisce -0,0. C'è un modo in cui restituirà solo 0,0? Tuttavia, voglio mantenere il segno negativo quando il risultato è un numero negativo.

Answer 1

Non credo ci sia un modo di farlo solo con DecimalFormat, ma questo one-liner si prende cura del problema:

formattedValue = formattedValue.replaceAll("^-(?=0(.0*)?$)", ""); 

Rimuove (sostituisce con "") il segno meno se è seguito da 0-n caratteri di "0.00000...", quindi questo funzionerà per qualsiasi risultato simile come ad esempio "-0", "-0." o "-0.000000000"

Ecco alcuni codice di prova:

public static void main(String[] args) { 
    System.out.println(format(-0.023)); 
    System.out.println(format(12.123)); 
    System.out.println(format(-12.345)); 
    System.out.println(format(-0.123)); 
    System.out.println(format(-1.777)); 
} 

public static String format(double number) { 
    DecimalFormat df = new DecimalFormat("#,##0.0"); 
    df.setRoundingMode(RoundingMode.HALF_UP); 
    String formattedValue = df.format(number); 
    formattedValue = formattedValue.replaceAll("^-(?=0(.0*)?$)", ""); 
    return formattedValue; 
} 

uscita (come previsto):

0.0 
12.1 
-12.3 
-0.1 
-1.8 

Answer 2

Prova questo: DecimalFormat df = new DecimalFormat("#,##0.0#;(#,##0.0#)");

Secondo il Javadoc for DecimalFormat:

A DecimalFormat pattern contains a positive and negative subpattern, for example, "#,##0.00;(#,##0.00)". Each subpattern has a prefix, numeric part, and suffix. The negative subpattern is optional; if absent, then the positive subpattern prefixed with the localized minus sign ('-' in most locales) is used as the negative subpattern. That is, "0.00" alone is equivalent to "0.00;-0.00". If there is an explicit negative subpattern, it serves only to specify the negative prefix and suffix; the number of digits, minimal digits, and other characteristics are all the same as the positive pattern. That means that "#,##0.0#;(#)" produces precisely the same behavior as "#,##0.0#;(#,##0.0#)".

Answer 3

Che per controllo se il valore calcolato = "-0.0" renderlo uguale "0.0"

e si può capsula il codice sush come

public String getFormattedValue(String input) { 
     DecimalFormat df = new DecimalFormat("#,##0.0"); 
     df.setRoundingMode(RoundingMode.HALF_UP); 
     String formattedValue = df.format(input); 

     if (formattedValue.equalsIgnoreCase("-0.0")) { 
      formattedValue = "0.0"; 
     } 

     System.out.println(formattedValue); 
     return formattedValue; 
    } 

Answer 4

Penso che sarebbe una soluzione alternativa per evitare -0.0. Usa il codice seguente:

DecimalFormat df = new DecimalFormat("#,##0.0"); 
df.setRoundingMode(RoundingMode.HALF_UP);  
df.setNegativePrefix(""); // set negative prefix BLANK 
String formattedValue = df.format(-0.023); 
df.setNegativePrefix("-"); // set back to - again 
System.out.println(formattedValue); 

uscita:

0.0 

Answer 5

Trovo il -0 molto utile perché ti informa che il valore arrotondato era in effetti negativo (che può avere molto significato per alcune funzioni). L'unico problema per me è che -1 * 0 è in realtà veramente 0 e deve essere formattato come 0 anche se non è con i programmi di formattazione Java.

Il seguente formattatore si occupa di questo, senza il costo costoso di manipolazione stringa (specialmente espressioni regolari):

public static String formatWithoutMinusZeroIssue(double d, DecimalFormat yourFormatter) { 
    if (d == 0) { 
     return yourFormatter.format(0); 
    } else { 
     return yourFormatter.format(d); 
    } 
} 

Questo utilizza il fatto che, sebbene -1 * 0 e 0 sono formattati in modo diverso, sono uguali.