Classe principale utilisée: java.text.decimalformat
1 et 1 Pour instancier un objet, vous pouvez utiliser les deux méthodes suivantes:
La copie de code est la suivante:
DECIMALFORMAT DF = (DECIMALFORMAT) NUBERFormat.getInstance ();
Decimalformat df1 = (decimalformat) decimalformat.getInstance ();
Parce que Decimalformat hérite de NumberFormat.
2 Définir le nombre de décimales
Le système par défaut des décimales est de 3, tels que:
La copie de code est la suivante:
DECIMALFORMAT DF = (DECIMALFORMAT) NUBERFormat.getInstance ();
System.out.println (df.format (12.3456789));
Sortie: 12.346
Vous pouvez maintenant définir la décimale sur deux chiffres par la méthode suivante:
La copie de code est la suivante:
df.setMaxiMumFractionDigits (2);
System.out.println (df.format (12.3456789));
Alors la sortie est: 12,35
3 et 3 Il existe deux façons de convertir les nombres en pourcentage de sortie:
(1)
La copie de code est la suivante:
df.ApplyPattern ("##. ##%");
System.out.println (df.format (12.3456789));
System.out.println (df.format (1));
System.out.println (df.format (0,015));
Les sorties sont: 1234,57% 100% 1,5%
(2)
La copie de code est la suivante:
df.setMaxiMumFractionDigits (2);
System.out.println (df.format (12.3456789 * 100) + "%");
System.out.println (df.format (1 * 100) + "%");
System.out.println (df.format (0,015 * 100) + "%");
Les sorties sont:
1 234,57% 100% 1,5%
4 Réglez la taille du groupe
La copie de code est la suivante:
Decimalformat df1 = (decimalformat) decimalformat.getInstance ();
df1.setGroupingSize (2);
System.out.println (df1.format (123456789));
Sortie: 1,23,45,67,89
Vous pouvez également désactiver les paramètres de regroupement par df1.setGroupingUsed (false);
La copie de code est la suivante:
Decimalformat df1 = (decimalformat) decimalformat.getInstance ();
df1.setGroupingSize (2);
df1.setGroupingUsed (false);
System.out.println (df1.format (123456789));
Sortie: 123456789
5 Réglez la décimale à 2 chiffres
La copie de code est la suivante:
Decimalformat df2 = (decimalformat) decimalformat.getInstance ();
df2.ApplyPattern ("0,00");
System.out.println (df2.format (1.2));
Sortie: 1.20
Parfois, nous devons contrôler le format des numéros de sortie.
Peut-être que vous ne vous souciez pas du format, mais vous devez vous soucier de votre programme universel dans le monde entier.
System.out.println (1234.56);
Aux États-Unis, "." Est le point décimal, mais ce n'est pas nécessairement le cas ailleurs. Comment gérer cela?
Certains packages du package Java.Text peuvent gérer ce type de problème. L'exemple simple suivant utilise ces classes pour résoudre le problème soulevé ci-dessus:
La copie de code est la suivante:
import java.text.numberformat;
import java.util.locale;
classe publique decimalformat1 {
public static void main (String args []) {
// Obtenez le format par défaut local
NumberFormat nf1 = NumberFormat.getInstance ();
System.out.println (nf1.format (1234.56));
// Obtenez le format allemand
NumberFormat nf2 =
Numberformat.getInstance (Locale.German);
System.out.println (nf2.format (1234.56));
}}
Si vous êtes aux États-Unis, après avoir exécuté le programme, sortie:
1 234,56
1,234,56
En d'autres termes, utilisez différentes habitudes pour représenter les nombres à différents endroits.
La méthode NumberFormat.getInstance () renvoie une instance de NumberFormat (en fait une sous-classe spécifique de NumberFormat, telle que DecimalFormat), qui convient à la mise en forme d'un nombre en fonction des paramètres locaux. Vous pouvez également utiliser des paramètres régionaux non défautés, comme l'Allemagne. La méthode de formatage forme ensuite les nombres en fonction de règles régionales spécifiques. Ce programme peut également être utilisé sous une forme simple:
Numberformat.getInstance (). Format (1234.56)
Mais sauver un format puis le réutiliser est plus efficace. L'internationalisation est un gros problème lors de la mise en forme des nombres.
Un autre est un contrôle efficace sur le format, comme la spécification du nombre de chiffres dans la partie fractionnée.
La copie de code est la suivante:
import java.text.decimalformat;
import java.util.locale;
classe publique decimalformat2 {
public static void main (String args []) {
// Obtenez le format par défaut local
DECIMALFORMAT DF1 = NOUVEAU DECIMALFORMAT ("###. 000");
System.out.println (df1.format (1234.56));
// Obtenez le format allemand
Locale.setDefault (Locale.German);
DECIMALFORMAT DF2 = NOUVEAU DECIMALFORMAT ("###. 000");
System.out.println (df2.format (1234.56));
}
}
Dans cet exemple, le format de nombre est défini, en utilisant des symboles comme "####. 000". Ce mode signifie qu'il y a quatre nombres avant le point décimal. Sortie du programme:
1234.560
1234 560
De même, les formats sous forme exponentielle peuvent également être contrôlés, par exemple:
La copie de code est la suivante:
import java.text.decimalformat;
classe publique decimalformat3 {
public static void main (String args []) {
DECIMALFORMAT DF = nouveau Decimalformat ("0.000e0000");
System.out.println (df.format (1234.56));
}
}
Sortir:
1.235e0003
Pour les pourcentages:
La copie de code est la suivante:
import java.text.numberformat;
classe publique decimalformat4 {
public static void main (String args []) {
NumberFormat nf = NumberFormat.getPercentInstance ();
System.out.println (nf.format (0,47));
}
}
Sortir:
47%
Jusqu'à présent, vous avez vu plusieurs techniques différentes de formatage des nombres. D'un autre côté, comment lire et analyser une chaîne contenant des numéros formatés? La prise en charge de la résolution est incluse dans NumberFormat. Par exemple:
La copie de code est la suivante:
import java.util.locale;
import java.text.numberformat;
import java.text.parseException;
classe publique decimalformat5 {
public static void main (String args []) {
// format local
NumberFormat nf1 = NumberFormat.getInstance ();
Objet obj1 = null;
// l'analyse basée sur le format
essayer {
obj1 = nf1.parse ("1234,56");
}
Catch (ParseException E1) {
System.err.println (E1);
}
System.out.println (OBJ1);
// format allemand
NumberFormat nf2 =
Numberformat.getInstance (Locale.German);
Objet obj2 = null;
// l'analyse basée sur le format
essayer {
obj2 = nf2.parse ("1234,56");
}
Catch (ParseException e2) {
System.err.println (E2);
}
System.out.println (obj2);
}
}
Cet exemple est divisé en deux parties, qui analysent une chaîne: "1234,56". La première partie utilise le format local pour analyser, tandis que la deuxième partie utilise le format allemand pour analyser. Lorsque le programme fonctionne aux États-Unis, le résultat est:
123456
1234.56
En d'autres termes, "1234,56" est considéré comme un énorme entier de 123456 aux États-Unis, et une décimale de "1234.56" en Allemagne.
Il y a aussi la dernière question de la discussion de formatage. Dans l'exemple ci-dessus, Decimalformat et NumberFormat sont utilisés. Decimalformat est souvent utilisé pour obtenir un bon contrôle de format, tandis que NumberFormat est souvent utilisé pour spécifier différentes régions de la local. Comment combiner deux catégories?
La réponse tourne autour du fait que Decimalformat est une sous-classe de NumberFormat, dont l'instance est spécifiée comme une région spécifique. Par conséquent, vous pouvez spécifier une région à l'aide de Numberformat.getInstance, puis de lancer la structure dans un objet Decimalformat. La documentation mentionne que cette technique peut être appliquée dans la plupart des cas, mais vous devez utiliser un bloc d'essai / capture pour entourer le casting au cas où la conversion ne fonctionnerait pas correctement (probablement en utilisant une zone étrange dans des situations très discrètes). Voici un exemple comme celui-ci:
La copie de code est la suivante:
import java.text.decimalformat;
import java.text.numberformat;
import java.util.locale;
classe publique decimalformat6 {
public static void main (String args []) {
Decimalformat df = null;
// Obtenez un objet NumberFormat et
// jeté à un objet décimalformat
essayer {
df = (decimalformat)
Numberformat.getInstance (Locale.German);
}
catch (classcastException e) {
System.err.println (E);
}
// définir le mode format
df.ApplyPattern ("####. 00000");
// format un nombre
System.out.println (df.format (1234.56));
}
}
La méthode getInstance () obtient le format, puis appelle la méthode applatpattern () pour définir le mode format, et sorties:
1234 56000
Si vous ne vous souciez pas de l'internationalisation, vous pouvez utiliser directement Decimalformat.