Formater la sortie des nombres en Java

Salut tout le monde! Souvent, nos méthodes sont accompagnées de nombres qui doivent être affichés dans un format spécial. Cela semble être une petite chose, mais comment mettriez-vous en œuvre cette tâche ? Nous vous invitons à y réfléchir un peu aujourd’hui. Tout d'abord, pour plonger dans le formatage des nombres en Java, rappelons-nous la méthode format de la classe String : public static String format(String format, Object... args) - renvoie une chaîne formatée à partir de la chaîne de format en utilisant les arguments args restants . Et juste un exemple :

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

En conséquence, nous obtiendrons le résultat dans la console :

méthodes printf et format

String.format() n'est pas la seule méthode pour formater une chaîne. Ses analogues sont System.out.printf() et System.out.format(); . On peut donc remplacer le code précédent par :

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");

La sortie dans la console restera la même. La seule différence est que ces méthodes affichent immédiatement la valeur dans la console, contrairement à String.format() . Mais j'aime mieux String.format() , car nous n'avons pas toujours besoin d'afficher le résultat dans la console, nous utiliserons donc cette méthode plus loin. Revenons à notre exemple. Que voit-on ? Et le fait est qu'aux endroits où il y avait des caractères - %s , les lignes - "Sasha" et "au travail" sont insérées . Comment cela peut-il nous aider dans le développement ? Imaginez que vous disposez d'un grand texte de modèle, mais à certains endroits, vous devez insérer des valeurs qui peuvent être différentes et provenir de l'extérieur sous forme d'arguments. C'est là que ce formatage est utile. Les spécificateurs de format commencent par un signe de pourcentage, %, et se terminent par un caractère indiquant le type d'argument à formater. Et, comme vous l'avez probablement compris, %s est utilisé pour insérer des objets - des chaînes. Mais si nous essayons d'insérer, par exemple, un double à l'endroit où l'objet chaîne est enregistré :

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

cela fonctionnera également. double sera converti en chaîne et nous obtiendrons : Outre les chaînes et les nombres à virgule flottante, il existe d’autres types en Java, n’est-ce pas ? Jetons donc un coup d'œil à l'ensemble de l'arsenal : Utilisons un format plus approprié pour double :

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

Sortie de la console : Comme vous l'avez peut-être réalisé, %f serait un spécificateur plus approprié pour les nombres à virgule flottante, qui incluent des types de données comme double et float en Java. Avec ce spécificateur, nous pouvons formater un nombre à virgule flottante :

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

L'insertion de .2 dans ce spécificateur tronquera le nombre de décimales à deux, nous donnant le résultat : .2 n’est pas la seule modification apportée aux spécificateurs. La combinaison de ces sous-ensembles s'appelle une instruction . La forme générale des instructions est la suivante : Maintenant, décryptons tout dans l'ordre :

• [argument_index] est un entier indiquant la position dans la liste d'arguments. Par exemple, le lien vers le premier argument est $1, le lien vers le deuxième argument est $2, etc. Si la position n'a pas été spécifiée, les arguments doivent être dans le même ordre que celui dans lequel ils sont référencés dans la chaîne de format.
• [drapeaux] sont des caractères spéciaux pour le formatage. Par exemple:
  • Drapeau + indiquant que si une valeur numérique est positive, elle doit inclure un signe +
  • - signifie aligner le résultat à gauche
  • , définit le séparateur de milliers pour les entiers
• [width] est un entier décimal positif qui spécifie le nombre minimum de caractères qui seront affichés. Si ce numéro est précédé de 0, alors les caractères manquants seront complétés par des 0, s'il n'y a pas de 0, alors par des espaces.
• [.accuracy] est un entier non négatif précédé d'un point. Généralement utilisé pour limiter le nombre de caractères. Le comportement spécifique dépend du type spécifique de spécificateur.

Je voudrais également noter que tous les éléments ci-dessus des instructions sont facultatifs et que tout fonctionnera sans eux. À titre d'exemple d'utilisation de sous-ensembles, imaginons que nous ayons besoin d'une sortie spécifique du nombre Pi :

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

Et en conséquence, la sortie dans la console : Cela semble facile, non ? Mais lorsqu’il s’agit de formater un nombre, vous ne pouvez pas ignorer DecimalFormat . Voyons ce que cela signifie.

Format décimal

DecimalFormat est une classe permettant de formater n'importe quel nombre en Java, qu'il s'agisse d'un nombre entier ou d'un nombre à virgule flottante. Lorsqu'un objet DecimalFormat est créé , vous pouvez spécifier un modèle pour formater les nombres entrants directement dans le constructeur. Voici à quoi ressemblerait notre exemple en utilisant DecimalFormat :

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

Sortie de la console : La ligne #.### est un modèle qui indique que nous formatons la valeur transmise à 3 décimales. Quels autres symboles sont disponibles pour les motifs ? En voici quelques uns:

• # — chiffre, les zéros non significatifs sont omis ;
• 0 — le chiffre est toujours affiché, même si le numéro comporte moins de chiffres (dans ce cas, 0 est affiché) ;
• . — signe séparateur décimal ;
• , — signe de regroupement des séparateurs (par exemple, séparateur de milliers) ;
• ; — sépare les formats ;
• - — marque le préfixe d'un nombre négatif ;
• % - multiplie par 100 et affiche le nombre sous forme de pourcentage ;
• ? — multiplie par 1000 et affiche le nombre en ppm ;
• E - Sépare la mantisse et l'exposant pour la notation scientifique.

Jetons un coup d'œil à quelques exemples :

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

Sortie de la console :

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

Sortie de la console :

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

Sortie de la console : Il n'est pas nécessaire de créer un nouvel objet DecimalFormat à chaque fois pour définir un nouveau modèle. Il suffira d'utiliser ses méthodes applyPattern et applyLocalizedPattern :

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

Lorsque nous parlons de formater un nombre à virgule flottante, nous sommes très intéressés par l'arrondi, n'est-ce pas ? Ainsi, lors du découpage d'un nombre avec des décimales au-delà du motif spécifié, DecimalFormat arrondit le nombre si le dernier nombre coupé est supérieur à 5. Que se passe-t-il si le dernier nombre coupé est 5 ? En effet, dans ce cas, ce nombre est exactement au milieu entre les entiers les plus proches. Dans ce cas, le numéro précédent est pris en compte. Si le nombre précédent est pair, on arrondit :

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

Sortie de la console : Si impair, il n'est pas effectué :

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

Sortie de la console : La différence entre le formatage des nombres à virgule flottante à l'aide de String.format() et DecimalFormat.format() est que dans le premier cas, il y aura des zéros à droite, même s'il n'y a pas de partie fractionnaire. Par exemple:

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

Sortie de la console :

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

Sortie de la console : Comme vous pouvez le voir, lors du formatage du nombre 9.00001273 avec une précision de quatre décimales, la méthode format() de la classe String affichera la valeur 9.0000 , tandis que la méthode format() similaire de DecimalFormat affichera 9 .

BigDecimal et BigInteger

Puisque nous avons abordé le sujet de l'arrondi des nombres en Java, parlons de la façon d'utiliser la classe BigDecimal pour de telles opérations . Cette classe se concentre sur le travail avec de très GRANDS nombres : pour cela, les valeurs maximales double et float sont trop petites. Cette classe possède de nombreux paramètres différents pour l'arrondi en virgule flottante, ainsi que de nombreuses méthodes pour les opérations arithmétiques. Il a une classe similaire, mais axée sur le travail avec de GRANDS entiers - BigInteger . Vous pouvez en savoir plus sur BigDecimal et BigInteger dans cet article .

Formatage de la date et de l'heure

Il a seulement été mentionné ci-dessus qu'en utilisant format() de la classe String , vous pouvez également formater l'heure et la date. Eh bien, regardons comment cela se fait. Tout d’abord, nous souhaitons vous rappeler que le spécificateur de format %t est utilisé pour les dates . Deuxièmement, lors du formatage d'un modèle, des indicateurs de formatage supplémentaires sont requis pour chaque spécificateur de format pour les dates. Voici les indicateurs de formatage possibles pour les dates : Il s'agit d'une liste raccourcie d'indicateurs de formatage de date possibles - il y en a beaucoup, pour tous les goûts. Une liste complète d'entre eux et les spécificateurs possibles peuvent être trouvés sur ce lien . Voyons comment l'utiliser. Cette fois, nous n'utilisons pas String.format() , mais immédiatement System.out.printf() .

Exemple 1

De plus, nous définirons la langue du résultat en la passant comme premier argument à la méthode :

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

Sortie de la console : Sans préciser de langue, la langue par défaut sera utilisée (par exemple, j'ai le russe).

Exemple 2

Affichons une date plus complète :

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

Et le résultat dans la console : Passer le même objet Date comme argument tant de fois... Cela n'a pas l'air très bien, n'est-ce pas ? Utilisons le sous-ensemble $ internal pour spécifier l'argument que nous voulons utiliser :

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

La sortie dans notre console ne changera pas. Il existe d’autres manières tout aussi intéressantes de formater les dates. Vous pouvez en savoir plus sur eux et un peu plus sur l'heure et la date en Java dans ce document . C'est tout pour aujourd'hui, merci de votre attention !