Formate a saída de números em Java

Olá a todos! Muitas vezes nossos métodos vêm com números que precisam ser exibidos em algum formato especial. Parece uma coisa pequena, mas como você implementaria essa tarefa? Convidamos você a pensar um pouco sobre isso hoje. Primeiro, para mergulhar na formatação de números em Java, vamos lembrar o método de formato da classe String : public static String format(String format, Object... args) - retorna uma string formatada a partir da string de formato usando os argumentos args restantes . E apenas um exemplo:

String str = String.format("Hi - %s! How are you %s?", "Sasha", "At work");
System.out.println(str);

Como resultado, obteremos a saída no console:

métodos printf e format

String.format() não é o único método para formatar uma string. Seus análogos são System.out.printf() e System.out.format(); . Portanto, podemos substituir o código anterior por:

System.out.printf("Hi - %s! How are you %s?", "Sasha", "At work");

ou

System.out.format("Hi - %s! How are you %s?", "Sasha", "At work");

A saída no console permanecerá a mesma. A única diferença é que esses métodos exibem imediatamente o valor no console, ao contrário de String.format() . Mas eu gosto mais de String.format() , já que nem sempre precisamos exibir o resultado no console, então usaremos esse método posteriormente. Voltemos ao nosso exemplo. O que vemos? E o fato é que nos locais onde havia caracteres - %s , são inseridas as falas - “Sasha” e “no trabalho” . Como isso pode nos ajudar no desenvolvimento? Imagine que você tem um modelo de texto grande, mas em alguns lugares é necessário inserir valores que podem ser diferentes e vir como argumentos de fora. É aqui que essa formatação é útil. Os especificadores de formato começam com um sinal de porcentagem, %, e terminam com um caractere que indica o tipo de argumento a ser formatado. E, como você provavelmente entende, %s é usado para inserir objetos - strings. Mas se tentarmos inserir, por exemplo, um double no local onde o objeto string está registrado:

String str = String.format("Hi - %s! How are you %s?", 55.6, "At work");

isso também funcionará. double será convertido em uma string e obteremos: Além de strings e números de ponto flutuante, existem outros tipos em Java, certo? Então, vamos dar uma olhada em todo o arsenal: Vamos usar um formato mais adequado para double :

String str = String.format("The distance from Kyiv to Odessa is %f. Not so short, is it?", 475.4d);
System.out.println(str);

Saída do console: Como você deve ter percebido, %f seria um especificador mais apropriado para números de ponto flutuante, que incluem tipos de dados como double e float em Java. Com este especificador podemos formatar um número de ponto flutuante:

String str = String.format("The distance from Kyiv to Odessa is %.2f. Not so short, is it?", 475.4d);

Inserir .2 neste especificador truncará o número de casas decimais para duas, fornecendo a saída: .2 não é o único ajuste nos especificadores. A combinação dessas subconfigurações é chamada de instrução . A forma geral das instruções é a seguinte: Agora vamos decifrar tudo em ordem:

• [argument_index] é um número inteiro que indica a posição na lista de argumentos. Por exemplo, o link para o primeiro argumento é $1, o link para o segundo argumento é $2, etc. Se a posição não foi especificada, os argumentos deverão estar na mesma ordem em que são referenciados na string de formato.
• [sinalizadores] são caracteres especiais para formatação. Por exemplo:
  • Sinalizador + indicando que se um valor numérico for positivo, ele deve incluir um sinal +
  • - significa alinhar o resultado à esquerda
  • , define o separador de milhar para números inteiros
• [largura] é um número inteiro decimal positivo que especifica o número mínimo de caracteres que serão gerados. Se este número for precedido por 0, os caracteres ausentes serão preenchidos com 0, se não houver 0, então com espaços.
• [.accuracy] é um número inteiro não negativo precedido por um ponto. Normalmente usado para limitar o número de caracteres. O comportamento específico depende do tipo específico de especificador.

Também gostaria de observar que todos os elementos das instruções acima são opcionais e tudo funcionará sem eles. Como exemplo de uso de subconfigurações, vamos imaginar que precisamos de uma saída específica do número Pi:

String str = String.format("%1$+09.5f", 3.1415926535897);
System.out.print(str);

E, consequentemente, a saída no console: Parece fácil, certo? Mas quando se trata de formatar um número, você não pode ignorar DecimalFormat . Vamos descobrir o que isso significa.

Formato Decimal

DecimalFormat é uma classe para formatar qualquer número em Java, seja um número inteiro ou um número de ponto flutuante. Quando um objeto DecimalFormat é criado , você pode especificar um modelo para formatar números recebidos diretamente no construtor. Este é o aspecto do nosso exemplo usando DecimalFormat :

DecimalFormat dF = new DecimalFormat( "#.###" );
double value = 72.224463;
System.out.print(dF.format(value));

Saída do console: A linha #.### é um padrão que indica que estamos formatando o valor passado com 3 casas decimais. Que outros símbolos estão disponíveis para padrões? Aqui estão alguns deles:

• # — dígito, zeros à esquerda são omitidos;
• 0 — o dígito é sempre exibido, mesmo que o número tenha menos dígitos (neste caso, 0 é exibido);
• . — sinal separador decimal;
• , — sinal de agrupamento de separadores (por exemplo, separador de milhares);
• ; — separa formatos;
• - — marca o prefixo de um número negativo;
• % - multiplica por 100 e mostra o número em porcentagem;
• ? — multiplica por 1000 e mostra o número em ppm;
• E – Separa mantissa e expoente para notação científica.

Vejamos alguns exemplos:

System.out.println(new DecimalFormat( "###,###.##" ).format(74554542.224463));

Saída do console:

System.out.println(new DecimalFormat( "%###.##" ).format(0.723456));

Saída do console:

System.out.println(new DecimalFormat( "000.###" ).format(42.224463));

Saída do console: Não é necessário criar um novo objeto DecimalFormat toda vez para definir um novo modelo. Será suficiente usar seus métodos applyPattern e applyLocalizedPattern :

DecimalFormat dF = new DecimalFormat("###.###");
dF.applyPattern("000000.000");
dF.applyLocalizedPattern("#,#00.0#");

Quando falamos em formatar um número de ponto flutuante, estamos bastante interessados ​​em arredondamento, não é mesmo? Portanto, ao cortar um número com casas decimais além do padrão especificado, DecimalFormat arredonda o número para cima se o último número aparado for maior que 5. E se o último número aparado for 5? Na verdade, neste caso, este número está exatamente no meio entre os números inteiros mais próximos. Neste caso, o número anterior é levado em consideração. Se o número anterior for par, o arredondamento é feito:

DecimalFormat dF = new DecimalFormat("##.###");
String result = dF.format(56.4595);
System.out.println((result));

Saída do console: Se for ímpar, não é executado:

DecimalFormat dF = new DecimalFormat("##.###");
String str = dF.format(56.4595);
System.out.println((str));

Saída do console: A diferença entre formatar números de ponto flutuante usando String.format() e DecimalFormat.format() é que no primeiro caso haverá zeros à direita, mesmo que não haja parte fracionária. Por exemplo:

String firstStr = String.format("%.4f", 9.00001273);
System.out.println((firstStr));

Saída do console:

DecimalFormat decimalFormat = new DecimalFormat("#.####");
String secondStr = decimalFormat.format(9.00001273);
System.out.println((secondStr));

Saída do console: Como você pode ver, ao formatar o número 9.00001273 com precisão de quatro casas decimais, o método format() da classe String produzirá o valor 9.0000 , enquanto o método format() semelhante de DecimalFormat produzirá 9 .

BigDecimal e BigInteger

Já que tocamos no tópico de arredondamento de números em Java, vamos falar sobre como usar a classe BigDecimal para tais operações . Esta classe está focada em trabalhar com números realmente GRANDES: para ela, os valores máximos de double e float são muito pequenos. Esta classe possui muitas configurações diferentes para arredondamento de ponto flutuante, bem como muitos métodos para operações aritméticas. Possui uma classe semelhante, mas focada em trabalhar com números inteiros LARGE - BigInteger . Você pode ler mais sobre BigDecimal e BigInteger neste artigo .

Formatando data e hora

Foi mencionado apenas acima que usando format() da classe String você também pode formatar hora e data. Bem, vamos dar uma olhada em como isso é feito. Primeiramente, gostaríamos de lembrar que o especificador de formato %t é usado para datas . Segundo, ao formatar um modelo, são necessários sinalizadores de formatação adicionais para cada especificador de formato de datas. Aqui estão os possíveis sinalizadores de formatação para datas: Esta é uma lista resumida de possíveis sinalizadores de formatação de data - há muitos deles, para todos os gostos. Uma lista completa deles e possíveis especificadores pode ser encontrada neste link . Vejamos como usar isso. Desta vez não usamos String.format() , mas imediatamente System.out.printf() .

Exemplo 1

Além disso, definiremos o idioma do resultado passando-o como primeiro argumento do método:

Date date = new Date();
System.out.printf(Locale.ENGLISH,"%tB %te, %tY",date,date,date);

Saída do console: Sem especificar um idioma, será usado o idioma padrão (por exemplo, tenho russo).

Exemplo 2

Vamos exibir uma data mais completa:

Date date = new Date();
System.out.printf("%td %tB %tY of %n%tH:%tM:%tS",date,date,date,date,date,date,date);

E a saída no console: Passar o mesmo objeto Date como argumento tantas vezes... Não parece muito bom, não é? Vamos usar o subconjunto $ internal para especificar o argumento que queremos usar:

System.out.printf("%1$td %1$tB %1$tY of year %n%1$tH:%1$tM:%1$tS",date);

A saída em nosso console não mudará. Existem outras formas igualmente interessantes de formatar datas. Você pode ler sobre eles e um pouco mais sobre hora e data em Java neste material . Por hoje é tudo, obrigado pela atenção!