Como formatar bem números flutuantes para String sem zero desnecessário decimal?

496

Um duplo de 64 bits pode representar inteiro +/- 2 53 exatamente

Dado esse fato, optei por usar um tipo duplo como um tipo único para todos os meus tipos, pois meu maior número inteiro é sem sinal de 32 bits.

Mas agora eu tenho que imprimir esses pseudo números inteiros, mas o problema é que eles também são misturados com dobras reais.

Então, como faço para imprimir essas dobras muito bem em Java?

Eu tentei String.format("%f", value), que está próximo, exceto que recebo muitos zeros à direita para valores pequenos.

Aqui está um exemplo de saída de %f

232.00000000
0.18000000000
1237875192.0
4.5800000000
0,00000000
1.23450000

O que eu quero é:

232
0,18
1237875192
4.58
0 0
1,2345

Claro que posso escrever uma função para cortar esses zeros, mas isso representa muita perda de desempenho devido à manipulação de String. Posso fazer melhor com outro código de formato?

EDITAR

As respostas de Tom E. e Jeremy S. são inaceitáveis, pois ambas arbitrariamente arredondam para duas casas decimais. Por favor, entenda o problema antes de responder.

EDIT 2

Observe que String.format(format, args...)depende da localidade (consulte as respostas abaixo).

Pyrolistical
fonte
Se tudo o que você deseja são números inteiros, por que não usar um longo? Você obtém mais economia em 2 ^ 63-1, sem formatação estranha e melhor desempenho.
basszero
14
Porque alguns valores são realmente dobra
Pyrolistical
2
Alguns casos em que esse problema ocorreu foram um bug corrigido no JDK 7: stackoverflow.com/questions/7564525/…
Pyrolistical
Sou apenas eu ou o JavaScript é 100% melhor na conversão de número para string do que Java?
Andy Andy
System.out.println("YOUR STRING" + YOUR_DOUBLE_VARIABLE);
Shayan Amani

Respostas:

399

Se a ideia é imprimir números inteiros armazenados como dobra como se fossem números inteiros, e imprimir os dobros com a precisão mínima necessária:

public static String fmt(double d)
{
    if(d == (long) d)
        return String.format("%d",(long)d);
    else
        return String.format("%s",d);
}

Produz:

232
0.18
1237875192
4.58
0
1.2345

E não depende da manipulação de strings.

JasonD
fonte
9
Concordou, esta é uma resposta ruim, não a use. Falha ao trabalhar com um valor doublemaior que o máximo int. Mesmo com longisso ainda falharia com grandes números. Além disso, retornará uma String em forma exponencial, por exemplo, "1.0E10", para valores grandes, o que provavelmente não é o que o solicitante deseja. Use em %fvez de %sna segunda sequência de formato para corrigir isso.
JLH
26
O OP declarou explicitamente que não queria que a saída fosse formatada usando %f. A resposta é específica para a situação descrita e a saída desejada. O OP sugeriu que seu valor máximo era um int sem sinal de 32 bits, o que eu entendi como intaceitável (não assinado não existe realmente em Java e nenhum exemplo era problemático), mas mudar intpara longé uma correção trivial se a situação for diferente.
JasonD
1
Onde, na pergunta, diz que não deveria fazer isso?
21414 JasonDas
6
String.format("%s",d)??? Fale sobre despesas desnecessárias. Use Double.toString(d). Mesmo para o outro: Long.toString((long)d).
Andreas
15
O problema é que %snão funciona com localidades. Em alemão, usamos um "," em vez de um "." em números decimais. Enquanto String.format(Locale.GERMAN, "%f", 1.5)retorna "1.500000", String.format(Locale.GERMAN, "%s", 1.5)retorna "1.5" - com um ".", Que é falso no idioma alemão. Também existe uma versão dependente de localidade de "% s"?
Felix Edelmann
414
new DecimalFormat("#.##").format(1.199); //"1.2"

Como apontado nos comentários, esta não é a resposta certa para a pergunta original.
Dito isto, é uma maneira muito útil de formatar números sem zeros à direita desnecessários.

Tom Esterez
fonte
16
Uma observação importante aqui é que 1.1 seria formatado corretamente como "1.1" sem zeros à direita.
Steve Pomeroy
53
E se você desejar um número específico de zeros à direita (por exemplo, se estiver imprimindo quantias em dinheiro), poderá usar '0' em vez de '#' (ou seja, novo DecimalFormat ("0,00"). Format (amount);) this não é o que o OP queria, mas pode ser útil para referência.
TJ Ellis
22
Sim, como autor original da pergunta, esta é a resposta ERRADA. Engraçado quantos votos existem. O problema com esta solução é arredondar arbitrariamente para 2 casas decimais.
Pyrolistical
11
@ Mazyod porque você sempre pode passar em um ponto flutuante com mais casas decimais que o formato. Isso é escrever código que funcionará na maioria das vezes, mas não cobrirá todos os casos extremos.
Pyrolistical
15
@Pyrolistical - IMHO, existem muitos votos positivos, porque, embora esta seja a solução errada para você, é a solução certa para mais de 99% das pessoas que encontram essas perguntas e respostas: geralmente, os últimos dígitos de um duplo são "ruído", que bagunçam a saída, interferindo na legibilidade. Portanto, o programador determina quantos dígitos são benéficos para a pessoa que está lendo a saída e especifica quantos. Uma situação comum é que pequenos erros matemáticos foram acumulados; portanto, um valor pode ser 12.000000034, mas prefere arredondar para 12 e exibir compactamente como "12". E "12.340000056" => "12.34".
Home
226
String.format("%.2f", value) ;
Jeremy Slade
fonte
13
Isso está correto, mas sempre imprime zeros à direita, mesmo se não houver parte fracionária. String.format (. "% 2f, 1,0005) imprime 1,00 e não 1. Existe alguma especificador de formato para não imprimir parte fracionária se ele não existe?
Emre Yazici
87
Votado para baixo, já que a pergunta está solicitando a remoção de todos os zeros à direita e essa resposta sempre deixará dois pontos flutuantes, independentemente de ser zero.
Zulaxia
O DecimalFormat foi um bom truque - embora eu tenha acabado usando este para a minha situação (temporizador no nível do jogo), pois os zeros à direita pareciam melhores.
Timothy Lee Russell
2
Eu acho que você pode lidar com os zeros à direita corretamente usando g em vez de f.
precisa saber é o seguinte
3
Eu usei esta solução em um sistema de produção com "% .5f", e é realmente muito ruim, não usá-lo ... porque impresso isto: 5.12E-4 em vez de 0,000512
Hamish
87

Em resumo:

Se você quiser se livrar dos zeros à direita e dos problemas de localidade, use:

double myValue = 0.00000021d;

DecimalFormat df = new DecimalFormat("0", DecimalFormatSymbols.getInstance(Locale.ENGLISH));
df.setMaximumFractionDigits(340); //340 = DecimalFormat.DOUBLE_FRACTION_DIGITS

System.out.println(df.format(myValue)); //output: 0.00000021

Explicação:

Por que outras respostas não me agradaram:

  • Double.toString()ou System.out.printlnou FloatingDecimal.toJavaFormatStringusa notações científicas se o dobro for menor que 10 ^ -3 ou maior que ou igual a 10 ^ 7

    double myValue = 0.00000021d;
    String.format("%s", myvalue); //output: 2.1E-7
  • usando %f, a precisão decimal padrão é 6; caso contrário, você pode codificá-la, mas isso resultará em zeros extras adicionados se você tiver menos casas decimais. Exemplo:

    double myValue = 0.00000021d;
    String.format("%.12f", myvalue); //output: 0.000000210000
  • usando setMaximumFractionDigits(0);ou %.0fremovendo qualquer precisão decimal, o que é bom para números inteiros / longos, mas não para o dobro

    double myValue = 0.00000021d;
    System.out.println(String.format("%.0f", myvalue)); //output: 0
    DecimalFormat df = new DecimalFormat("0");
    System.out.println(df.format(myValue)); //output: 0
  • usando DecimalFormat, você depende localmente. Na localidade francesa, o separador decimal é uma vírgula, não um ponto:

    double myValue = 0.00000021d;
    DecimalFormat df = new DecimalFormat("0");
    df.setMaximumFractionDigits(340);
    System.out.println(df.format(myvalue));//output: 0,00000021

    O uso da localidade ENGLISH garante que você obtenha um ponto para o separador decimal, onde quer que o seu programa seja executado

Por que usar 340 então para setMaximumFractionDigits?

Duas razões :

  • setMaximumFractionDigitsaceita um número inteiro, mas sua implementação tem um número máximo permitido dos DecimalFormat.DOUBLE_FRACTION_DIGITSquais é igual a 340
  • Double.MIN_VALUE = 4.9E-324 portanto, com 340 dígitos, você não deve arredondar sua precisão dupla e solta
JBE
fonte
Isso não funciona para números inteiros, por exemplo, "2" se torna "2".
kap
Obrigado, eu corrigi a resposta usando o padrão em 0vez de#.
JBE
Você não está usando a constante, DecimalFormat.DOUBLE_FRACTION_DIGITSmas o valor 340, que fornece um comentário para mostrar que é igual DecimalFormat.DOUBLE_FRACTION_DIGITS. Por que não usar apenas a constante ???
Maarten Bodewes
1
Porque este atributo não é público ... é "empacotar friendly"
JBE
4
Obrigado! De fato, essa resposta é a única que realmente corresponde a todos os requisitos mencionados na pergunta - ela não mostra zeros desnecessários, não arredonda os números e depende da localidade. Ótimo!
Felix Edelmann
26

Por que não:

if (d % 1.0 != 0)
    return String.format("%s", d);
else
    return String.format("%.0f",d);

Isso deve funcionar com os valores extremos suportados pelo Double. Rendimentos:

0.12
12
12.144252
0
Valeriu Paloş
fonte
2
Prefiro esta resposta pela qual não precisamos fazer a conversão de tipos.
Jeff T.
Breve explicação: "%s"basicamente chama, d.toString()mas não funciona com intou se d==null!
Neph 24/10/19
24

Na minha máquina, a seguinte função é aproximadamente 7 vezes mais rápida que a função fornecida pela resposta de JasonD , pois evita String.format:

public static String prettyPrint(double d) {
  int i = (int) d;
  return d == i ? String.valueOf(i) : String.valueOf(d);
}
Rok Strniša
fonte
1
Hmm, isso não leva em consideração os locais, mas o JasonD também não.
TWiStErRob
22

Meus 2 centavos:

if(n % 1 == 0) {
    return String.format(Locale.US, "%.0f", n));
} else {
    return String.format(Locale.US, "%.1f", n));
}
Fernando Gallego
fonte
2
Ou apenas return String.format(Locale.US, (n % 1 == 0 ? "%.0f" : "%.1f"), n);.
MC Emperor
falha quando 23.00123 ==> 23.00
aswzen
11

Não, não importa.

A perda de desempenho devido à manipulação de String é zero.

E aqui está o código para aparar o final depois %f

private static String trimTrailingZeros(String number) {
    if(!number.contains(".")) {
        return number;
    }

    return number.replaceAll("\\.?0*$", "");
}
Pyrolistical
fonte
7
Fiz uma votação baixa porque sua solução não é o melhor caminho a percorrer. Dê uma olhada no String.format. Você precisa usar o tipo de formato correto, flutuar nesta instância. Olhe para a minha resposta acima.
Jjnguy 01/04/09
6
Votei na votação porque estou tendo o mesmo problema, e ninguém aqui parece entender o problema.
Obay
1
Reduzido como o DecimalFormat mencionado no post de Tom é exatamente o que você estava procurando. Tira zeros com bastante eficiência.
27611 Steve Pomeroy
4
Para o exposto, talvez ele queira aparar os zeros SEM arredondamentos? PS @ Pirolistical, certamente você pode usar number.replaceAll (".? 0 * $", ""); (depois contém (".") é claro)
Rehno Lindeque
1
Ok, então como você seria capaz de alcançar meu objetivo com o DecimalFormat?
Pyrolistical 18/01/12
8

Use um DecimalFormatesetMinimumFractionDigits(0)

vlazzle
fonte
Eu acrescentaria setMaximumFractionDigits(2)e setGroupingUsed(false)(os OP não mencionam, mas a partir do exemplo, parece que é necessário). Além disso, um pequeno caso de teste não dói, pois é trivial nesse caso. Ainda assim, desde que eu acho que a sua a solução mais simples, uma upvote é um upvote :)
acrespo
6
if (d == Math.floor(d)) {
    return String.format("%.0f", d);
} else {
    return Double.toString(d);
}
fop6316
fonte
1
Eu acho que vou segui-lo desta forma: D
aeracode
5

Observe que String.format(format, args...)depende da localidade porque formata usando a localidade padrão do usuário, ou seja, provavelmente com vírgulas e até espaços dentro, como 123 456,789 ou 123,456.789 , o que pode não ser exatamente o que você espera.

Você pode preferir usar String.format((Locale)null, format, args...) .

Por exemplo,

    double f = 123456.789d;
    System.out.println(String.format(Locale.FRANCE,"%f",f));
    System.out.println(String.format(Locale.GERMANY,"%f",f));
    System.out.println(String.format(Locale.US,"%f",f));

impressões

123456,789000
123456,789000
123456.789000

e é isso que vai String.format(format, args...) em diferentes países.

EDIT Ok, já que houve uma discussão sobre formalidades:

    res += stripFpZeroes(String.format((Locale) null, (nDigits!=0 ? "%."+nDigits+"f" : "%f"), value));
    ...

protected static String stripFpZeroes(String fpnumber) {
    int n = fpnumber.indexOf('.');
    if (n == -1) {
        return fpnumber;
    }
    if (n < 2) {
        n = 2;
    }
    String s = fpnumber;
    while (s.length() > n && s.endsWith("0")) {
        s = s.substring(0, s.length()-1);
    }
    return s;
}
18446744073709551615
fonte
1
você deve adicionar este como um comentário à resposta aceita
Pyrolistical
Os comentários não permitem a duração ou o formato deste adendo. Como ele adiciona informações possivelmente úteis, acho que deve ser permitido como está, e não excluído.
Terry Jan Reedy
5

Eu fiz um DoubleFormatterpara converter eficientemente um grande número de valores duplos em uma String agradável / apresentável:

double horribleNumber = 3598945.141658554548844; 
DoubleFormatter df = new DoubleFormatter(4,6); //4 = MaxInteger, 6 = MaxDecimal
String beautyDisplay = df.format(horribleNumber);
  • Se a parte inteira de V tiver mais de MaxInteger => exibir V no formato cientista (1.2345e + 30), caso contrário, exibir no formato normal 124.45678.
  • o MaxDecimal decide números de dígitos decimais (apara com o arredondamento do banqueiro)

Aqui o código:

import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.text.NumberFormat;
import java.util.Locale;

import com.google.common.base.Preconditions;
import com.google.common.base.Strings;

/**
 * Convert a double to a beautiful String (US-local):
 * 
 * double horribleNumber = 3598945.141658554548844; 
 * DoubleFormatter df = new DoubleFormatter(4,6);
 * String beautyDisplay = df.format(horribleNumber);
 * String beautyLabel = df.formatHtml(horribleNumber);
 * 
 * Manipulate 3 instances of NumberFormat to efficiently format a great number of double values.
 * (avoid to create an object NumberFormat each call of format()).
 * 
 * 3 instances of NumberFormat will be reused to format a value v:
 * 
 * if v < EXP_DOWN, uses nfBelow
 * if EXP_DOWN <= v <= EXP_UP, uses nfNormal
 * if EXP_UP < v, uses nfAbove
 * 
 * nfBelow, nfNormal and nfAbove will be generated base on the precision_ parameter.
 * 
 * @author: DUONG Phu-Hiep
 */
public class DoubleFormatter
{
    private static final double EXP_DOWN = 1.e-3;
    private double EXP_UP; // always = 10^maxInteger
    private int maxInteger_;
    private int maxFraction_;
    private NumberFormat nfBelow_; 
    private NumberFormat nfNormal_;
    private NumberFormat nfAbove_;

    private enum NumberFormatKind {Below, Normal, Above}

    public DoubleFormatter(int maxInteger, int maxFraction){
        setPrecision(maxInteger, maxFraction);
    }

    public void setPrecision(int maxInteger, int maxFraction){
        Preconditions.checkArgument(maxFraction>=0);
        Preconditions.checkArgument(maxInteger>0 && maxInteger<17);

        if (maxFraction == maxFraction_ && maxInteger_ == maxInteger) {
            return;
        }

        maxFraction_ = maxFraction;
        maxInteger_ = maxInteger;
        EXP_UP =  Math.pow(10, maxInteger);
        nfBelow_ = createNumberFormat(NumberFormatKind.Below);
        nfNormal_ = createNumberFormat(NumberFormatKind.Normal);
        nfAbove_ = createNumberFormat(NumberFormatKind.Above);
    }

    private NumberFormat createNumberFormat(NumberFormatKind kind) {
        final String sharpByPrecision = Strings.repeat("#", maxFraction_); //if you do not use Guava library, replace with createSharp(precision);
        NumberFormat f = NumberFormat.getInstance(Locale.US);

        //Apply banker's rounding:  this is the rounding mode that statistically minimizes cumulative error when applied repeatedly over a sequence of calculations
        f.setRoundingMode(RoundingMode.HALF_EVEN);

        if (f instanceof DecimalFormat) {
            DecimalFormat df = (DecimalFormat) f;
            DecimalFormatSymbols dfs = df.getDecimalFormatSymbols();

            //set group separator to space instead of comma

            //dfs.setGroupingSeparator(' ');

            //set Exponent symbol to minus 'e' instead of 'E'
            if (kind == NumberFormatKind.Above) {
                dfs.setExponentSeparator("e+"); //force to display the positive sign in the exponent part
            } else {
                dfs.setExponentSeparator("e");
            }

            df.setDecimalFormatSymbols(dfs);

            //use exponent format if v is out side of [EXP_DOWN,EXP_UP]

            if (kind == NumberFormatKind.Normal) {
                if (maxFraction_ == 0) {
                    df.applyPattern("#,##0");
                } else {
                    df.applyPattern("#,##0."+sharpByPrecision);
                }
            } else {
                if (maxFraction_ == 0) {
                    df.applyPattern("0E0");
                } else {
                    df.applyPattern("0."+sharpByPrecision+"E0");
                }
            }
        }
        return f;
    } 

    public String format(double v) {
        if (Double.isNaN(v)) {
            return "-";
        }
        if (v==0) {
            return "0"; 
        }
        final double absv = Math.abs(v);

        if (absv<EXP_DOWN) {
            return nfBelow_.format(v);
        }

        if (absv>EXP_UP) {
            return nfAbove_.format(v);
        }

        return nfNormal_.format(v);
    }

    /**
     * format and higlight the important part (integer part & exponent part) 
     */
    public String formatHtml(double v) {
        if (Double.isNaN(v)) {
            return "-";
        }
        return htmlize(format(v));
    }

    /**
     * This is the base alogrithm: create a instance of NumberFormat for the value, then format it. It should
     * not be used to format a great numbers of value 
     * 
     * We will never use this methode, it is here only to understanding the Algo principal:
     * 
     * format v to string. precision_ is numbers of digits after decimal. 
     * if EXP_DOWN <= abs(v) <= EXP_UP, display the normal format: 124.45678
     * otherwise display scientist format with: 1.2345e+30 
     * 
     * pre-condition: precision >= 1
     */
    @Deprecated
    public String formatInefficient(double v) {

        final String sharpByPrecision = Strings.repeat("#", maxFraction_); //if you do not use Guava library, replace with createSharp(precision);

        final double absv = Math.abs(v);

        NumberFormat f = NumberFormat.getInstance(Locale.US);

        //Apply banker's rounding:  this is the rounding mode that statistically minimizes cumulative error when applied repeatedly over a sequence of calculations
        f.setRoundingMode(RoundingMode.HALF_EVEN);

        if (f instanceof DecimalFormat) {
            DecimalFormat df = (DecimalFormat) f;
            DecimalFormatSymbols dfs = df.getDecimalFormatSymbols();

            //set group separator to space instead of comma

            dfs.setGroupingSeparator(' ');

            //set Exponent symbol to minus 'e' instead of 'E'

            if (absv>EXP_UP) {
                dfs.setExponentSeparator("e+"); //force to display the positive sign in the exponent part
            } else {
                dfs.setExponentSeparator("e");
            }
            df.setDecimalFormatSymbols(dfs);

            //use exponent format if v is out side of [EXP_DOWN,EXP_UP]

            if (absv<EXP_DOWN || absv>EXP_UP) {
                df.applyPattern("0."+sharpByPrecision+"E0");
            } else {
                df.applyPattern("#,##0."+sharpByPrecision);
            }
        }
        return f.format(v);
    }

    /**
     * Convert "3.1416e+12" to "<b>3</b>.1416e<b>+12</b>"
     * It is a html format of a number which highlight the integer and exponent part
     */
    private static String htmlize(String s) {
        StringBuilder resu = new StringBuilder("<b>");
        int p1 = s.indexOf('.');

        if (p1>0) {
            resu.append(s.substring(0, p1));
            resu.append("</b>");
        } else {
            p1 = 0;
        }

        int p2 = s.lastIndexOf('e');
        if (p2>0) {
            resu.append(s.substring(p1, p2));
            resu.append("<b>");
            resu.append(s.substring(p2, s.length()));
            resu.append("</b>");
        } else {
            resu.append(s.substring(p1, s.length()));
            if (p1==0){
                resu.append("</b>");
            }
        }
        return resu.toString();
    }
}

Nota: usei 2 funções da biblioteca GUAVA. Se você não usa o GUAVA, codifique você mesmo:

/**
 * Equivalent to Strings.repeat("#", n) of the Guava library: 
 */
private static String createSharp(int n) {
    StringBuilder sb = new StringBuilder(); 
    for (int i=0;i<n;i++) {
        sb.append('#');
    }
    return sb.toString();
}
Hiep
fonte
1
Se você conhece a precisão, use um BigDecimal. Veja docs.oracle.com/javase/1.5.0/docs/api/java/math/…
Pyrolistical
5

Este fará o trabalho bem, sei que o tópico é antigo, mas estava lutando com o mesmo problema até chegar a esse ponto. Espero que alguém ache útil.

    public static String removeZero(double number) {
        DecimalFormat format = new DecimalFormat("#.###########");
        return format.format(number);
    }
Bialy
fonte
5
new DecimalFormat("00.#").format(20.236)
//out =20.2

new DecimalFormat("00.#").format(2.236)
//out =02.2
  1. 0 para o número mínimo de dígitos
  2. Renderiza # dígitos
Hossein Hajizadeh
fonte
enquanto isso pode fornecer uma solução para a questão, é uma boa prática para adicionar uma breve explicação para a comunidade benefício (e aprender) a partir da resposta
blurfus
4
String s = String.valueof("your int variable");
while (g.endsWith("0") && g.contains(".")) {
    g = g.substring(0, g.length() - 1);
    if (g.endsWith("."))
    {
        g = g.substring(0, g.length() - 1);
    }
}
Kamal
fonte
você deve procurar o primeiro dígito que não seja zero à direita e usar a subString (e também verificar se a string contém ".", é claro). Dessa forma, você não criará tantas seqüências temporárias no caminho.
desenvolvedor android
3

Resposta tardia, mas ...

Você disse que escolhe armazenar seus números com o tipo duplo . Eu acho que isso pode ser a raiz do problema, porque obriga a armazenar números inteiros em duplas (e, portanto, perdendo as informações iniciais sobre a natureza do valor). Que tal armazenar seus números nas instâncias do Number classe (superclasse de Duplo e Inteiro) e confiar no polimorfismo para determinar o formato correto de cada número?

Eu sei que pode não ser aceitável refatorar uma parte inteira do seu código devido a isso, mas pode produzir a saída desejada sem código / conversão / análise extra.

Exemplo:

import java.util.ArrayList;
import java.util.List;

public class UseMixedNumbers {

    public static void main(String[] args) {
        List<Number> listNumbers = new ArrayList<Number>();

        listNumbers.add(232);
        listNumbers.add(0.18);
        listNumbers.add(1237875192);
        listNumbers.add(4.58);
        listNumbers.add(0);
        listNumbers.add(1.2345);

        for (Number number : listNumbers) {
            System.out.println(number);
        }
    }

}

Produzirá a seguinte saída:

232
0.18
1237875192
4.58
0
1.2345
Visto
fonte
javascript fez a mesma escolha pela maneira :)
Pyrolistical
@Pyrolistical Você pode explicar um pouco mais a sua declaração? Não está muito claro para mim ... :)
Visto
2

Isto é o que eu vim com:

  private static String format(final double dbl) {
    return dbl % 1 != 0 ? String.valueOf(dbl) : String.valueOf((int) dbl);
  }

Um liner simples, só lança para int se realmente precisar

keisar
fonte
1
Repetindo o que Felix Edelmann disse em outro lugar: isso criará uma sequência independente de localidade, que nem sempre pode ser apropriada para o usuário.
JJ Brown
ponto justo, para o meu caso de uso este não era um problema, eu não sou inteiramente certo agora, mas eu acho que um poderia usar String.format (com a queria Locale) em vez de valueOf
keisar
2

Formate o preço com agrupamento, arredondamento, sem zeros desnecessários (em dobro).

Regras:

  1. Não há zeros no final (2.0000 = 2; 1.0100000 = 1.01 )
  2. Dois dígitos no máximo após um ponto (2.010 = 2.01; 0.20 = 0.2 )
  3. Arredondamento após o segundo dígito após um ponto (1.994 = 1.99; 1.995 = 2; 1.006 = 1.01; 0.0006 -> 0 )
  4. Devoluções 0(null/-0 = 0 )
  5. Adiciona $(= $56/-$56 )
  6. Agrupamento ( 101101.02 = $101,101.02)

Mais exemplos:

-99.985 = -$99.99

10 = $10

10.00 = $10

20.01000089 = $20.01

Escrito em Kotlin como uma divertida extensão do Double (causa usada no Android), mas pode ser convertido para Java facilmente, pois classes java foram usadas.

/**
 * 23.0 -> $23
 *
 * 23.1 -> $23.1
 *
 * 23.01 -> $23.01
 *
 * 23.99 -> $23.99
 *
 * 23.999 -> $24
 *
 * -0.0 -> $0
 *
 * -5.00 -> -$5
 *
 * -5.019 -> -$5.02
 */
fun Double?.formatUserAsSum(): String {
    return when {
        this == null || this == 0.0 -> "$0"
        this % 1 == 0.0 -> DecimalFormat("$#,##0;-$#,##0").format(this)
        else -> DecimalFormat("$#,##0.##;-$#,##0.##").format(this)
    }
}

Como usar:

var yourDouble: Double? = -20.00
println(yourDouble.formatUserAsSum()) // will print -$20

yourDouble = null
println(yourDouble.formatUserAsSum()) // will print $0

Sobre o DecimalFormat : https://docs.oracle.com/javase/6/docs/api/java/text/DecimalFormat.html

oxi
fonte
1
public static String fmt(double d) {
    String val = Double.toString(d);
    String[] valArray = val.split("\\.");
    long valLong = 0;
    if(valArray.length == 2){
        valLong = Long.parseLong(valArray[1]);
    }
    if (valLong == 0)
        return String.format("%d", (long) d);
    else
        return String.format("%s", d);
}

Eu tive que usar essa causa d == (long)destava me dando violação no relatório do sonar

ShAkKiR
fonte
1
float price = 4.30;
DecimalFormat format = new DecimalFormat("0.##"); // Choose the number of decimal places to work with in case they are different than zero and zero value will be removed
format.setRoundingMode(RoundingMode.DOWN); // choose your Rounding Mode
System.out.println(format.format(price));

este é o resultado de alguns testes:

4.30     => 4.3
4.39     => 4.39  // Choose format.setRoundingMode(RoundingMode.UP) to get 4.4
4.000000 => 4
4        => 4
Ahmed Mihoub
fonte
E quanto a 1,23450000?
Alex78191 20/02
1.23450000 => 1.23
Ahmed Mihoub
0

Aqui estão duas maneiras de conseguir isso. Primeiro, a maneira mais curta (e provavelmente melhor):

public static String formatFloatToString(final float f)
  {
  final int i=(int)f;
  if(f==i)
    return Integer.toString(i);
  return Float.toString(f);
  }

E aqui está a maneira mais longa e provavelmente pior:

public static String formatFloatToString(final float f)
  {
  final String s=Float.toString(f);
  int dotPos=-1;
  for(int i=0;i<s.length();++i)
    if(s.charAt(i)=='.')
      {
      dotPos=i;
      break;
      }
  if(dotPos==-1)
    return s;
  int end=dotPos;
  for(int i=dotPos+1;i<s.length();++i)
    {
    final char c=s.charAt(i);
    if(c!='0')
      end=i+1;
    }
  final String result=s.substring(0,end);
  return result;
  }
desenvolvedor android
fonte
1
às vezes, quando você faz as coisas mais simples, o por trás do código é mais complexa e menos otimizado ... mas sim, você pode usar muita construído em funções de API ...
desenvolvedor android
1
Você deve começar com simples e, depois de determinar que tem um problema de desempenho, só então você deve otimizar. Código é para o ser humano ler repetidas vezes. Fazer correr rápido é secundário. Ao não usar a API padrão sempre que possível, é mais provável que você introduza erros e apenas torna mais difícil a alteração no futuro.
Pyrolistical
3
Eu diria que o código que você escreve assim NÃO será mais rápido. A JVM é muito inteligente e você realmente não sabe o quão rápido ou lento é algo até que o perfil seja. Problemas de desempenho podem ser detectados e corrigidos quando se tornar um problema. Você não deve otimizar prematuramente isso. Escreva um código para as pessoas lerem, não para como você imagina que a máquina irá executá-lo. Quando se tornar um problema de desempenho, reescreva o código com um criador de perfil.
Pyrolistical
2
Outra pessoa editou a resposta para melhorar a formatação do código. Eu estava revisando várias dezenas de edições para aprovação e aprovaria a edição deles aqui, mas as edições eram inconsistentes, então eu as corrigi. Também melhorei a gramática dos trechos de texto.
Steve Vinoski
1
Eu não entendo Se você disse que a formatação não importava, por que gastou tempo para alterá-la novamente?
OrhanC1
0

Para o Kotlin, você pode usar extensões como:

fun Double.toPrettyString() =
    if(this - this.toLong() == 0.0)
        String.format("%d", this.toLong())
    else
        String.format("%s",this)
Levor
fonte
0

Aqui está outra resposta que tem uma opção para acrescentar decimal SOMENTE SE decimal não for zero.

   /**
     * Example: (isDecimalRequired = true)
     * d = 12345
     * returns 12,345.00
     *
     * d = 12345.12345
     * returns 12,345.12
     *
     * ==================================================
     * Example: (isDecimalRequired = false)
     * d = 12345
     * returns 12,345 (notice that there's no decimal since it's zero)
     *
     * d = 12345.12345
     * returns 12,345.12
     *
     * @param d float to format
     * @param zeroCount number decimal places
     * @param isDecimalRequired true if it will put decimal even zero,
     * false will remove the last decimal(s) if zero.
     */
    fun formatDecimal(d: Float? = 0f, zeroCount: Int, isDecimalRequired: Boolean = true): String {
        val zeros = StringBuilder()

        for (i in 0 until zeroCount) {
            zeros.append("0")
        }

        var pattern = "#,##0"

        if (zeros.isNotEmpty()) {
            pattern += ".$zeros"
        }

        val numberFormat = DecimalFormat(pattern)

        var formattedNumber = if (d != null) numberFormat.format(d) else "0"

        if (!isDecimalRequired) {
            for (i in formattedNumber.length downTo formattedNumber.length - zeroCount) {
                val number = formattedNumber[i - 1]

                if (number == '0' || number == '.') {
                    formattedNumber = formattedNumber.substring(0, formattedNumber.length - 1)
                } else {
                    break
                }
            }
        }

        return formattedNumber
    }
Tenten Ponce
fonte
-1

Aqui está uma resposta que realmente funciona (combinação de respostas diferentes aqui)

public static String removeTrailingZeros(double f)
{
    if(f == (int)f) {
        return String.format("%d", (int)f);
    }
    return String.format("%f", f).replaceAll("0*$", "");
}
Martin Klosi
fonte
1
você não substituiu o PONTO, por exemplo, "100.0" será convertido para "100".
VinceStyling
se (f == (int) f) cuida disso.
Martin Klosi
2
Falha em f = 9999999999.00
Dawood ibn Kareem
-4

Eu sei que esse é um tópico muito antigo. Mas acho que a melhor maneira de fazer isso é como abaixo:

public class Test {

    public static void main(String args[]){
        System.out.println(String.format("%s something",new Double(3.456)));
        System.out.println(String.format("%s something",new Double(3.456234523452)));
        System.out.println(String.format("%s something",new Double(3.45)));
        System.out.println(String.format("%s something",new Double(3)));
    }
}

Resultado:

3.456 something
3.456234523452 something
3.45 something
3.0 something

O único problema é o último em que .0 não é removido. Mas se você é capaz de conviver com isso, isso funciona melhor. % .2f arredondará para os últimos 2 dígitos decimais. DecimalFormat também. Se você precisar de todas as casas decimais, mas não os zeros à direita, isso funcionará melhor.

sethu
fonte
2
DecimalFormat com o formato "#. ##" não manterá 0 extra se não forem necessários: System.out.println(new java.text.DecimalFormat("#.##").format(1.0005));será impresso1
Aleks G
Esse é meu argumento. E se você quiser que o 0,0005 seja exibido, se houver algum. Você arredondará 2 dígitos decimais.
Set9
O OP está pedindo como imprimir valores inteiros armazenados em duplas :)
Aleks G
-8
String s = "1.210000";
while (s.endsWith("0")){
    s = (s.substring(0, s.length() - 1));
}

Isso fará com que a string solte os 0-s restantes.

Kadi
fonte
1
Esta é uma boa solução para a pergunta: se eles estavam apenas interessados ​​em eliminar zeros à direita, como você alteraria seu código para também aparar um ponto decimal à direita? ie "1."
bakoyaro
29
Cuidado, sua solução converterá 1000 em 1, o que está errado.
Aleks G