Java DecimalFormat Notation Scientifique Question

Je suis à l'aide de Java DecimalFormat classe d'imprimer les nombres en Notation Scientifique. Cependant, il y a un problème que j'ai. J'ai besoin des chaînes de longueur fixe, indépendamment de la valeur et le signe de la puissance de dix se lancer. Actuellement, c'est ce que mon format ressemble:

DecimalFormat format = new DecimalFormat("0.0E0");

Cela me donne les combinaisons suivantes: 1.0E1, 1.0 E-1, -1.0E1, et de -1.0 E-1.

Je peux utiliser setPositivePrefix pour obtenir: +1.0E1, +1.0 E-1, -1.0E1, et de -1.0 E-1, ou ce que j'aime, mais cela n'affecte pas le signe de la puissance!

Est-il possible de faire ce que je peux avoir des chaînes de longueur fixe? Merci!

Edit: Ah, donc il n'y a aucun moyen de le faire à l'aide de Java existant DecimalFormat API? Merci pour les suggestions! Je pense que j'ai peut-être une classe de DecimalFormat parce que je suis limité par l'interface qui est déjà en place.

OriginalL'auteur Scott | 2009-07-31

  1. 2

    Voici un moyen. L'eau de rose, peut-être, mais il fonctionne...

    public class DecimalFormatTest extends TestCase {
private static class MyFormat extends NumberFormat {
private final DecimalFormat decimal;
public MyFormat(String pattern) {
decimal = new DecimalFormat(pattern);
}
public StringBuffer format(double number, StringBuffer toAppendTo, FieldPosition pos) {
StringBuffer sb = new StringBuffer();
sb.append(modified(Math.abs(number) > 1.0, decimal.format(number, toAppendTo, pos).toString()));
return sb;
}
private String modified(boolean large, String s) {
return large ? s.replace("E", "E+") : s;
}
public StringBuffer format(long number, StringBuffer toAppendTo, FieldPosition pos) {
StringBuffer sb = new StringBuffer();
sb.append(modified(true, decimal.format(number, toAppendTo, pos).toString()));
return sb;
}
public Number parse(String source, ParsePosition parsePosition) {
return decimal.parse(source, parsePosition);
}
public void setPositivePrefix(String newValue) {
decimal.setPositivePrefix(newValue);
}
}
private MyFormat    format;
protected void setUp() throws Exception {
format = new MyFormat("0.0E0");
format.setPositivePrefix("+");
}
public void testPositiveLargeNumber() throws Exception {
assertEquals("+1.0E+2", format.format(100.0));
}
public void testPositiveSmallNumber() throws Exception {
assertEquals("+1.0E-2", format.format(0.01));
}
public void testNegativeLargeNumber() throws Exception {
assertEquals("-1.0E+2", format.format(-100.0));
}
public void testNegativeSmallNumber() throws Exception {
assertEquals("-1.0E-2", format.format(-0.01));
}
}

    Vous pouvez également sous-classe DecimalFormat, mais je la trouve généralement plus propre de ne pas sous-classe de classes concrètes.

    OriginalL'auteur Carl Manaster

  2. 5

    Cela a fonctionné formulaire de moi,

    DecimalFormatSymbols SYMBOLS = DecimalFormatSymbols.getInstance(Locale.US);
if (value > 1 || value < -1) {
SYMBOLS.setExponentSeparator("e+");
} else {
SYMBOLS.setExponentSeparator("e");
}
DecimalFormat format = new DecimalFormat(sb.toString(), SYMBOLS);

    OriginalL'auteur Enrico Scantamburlo

  3. 3

    Pourriez-vous utiliser printf() à la place:

    Format format = new DecimalFormat("0.0E0");
Double d = new Double(.01);
System.out.println(format.format(d));
System.out.printf("%1.1E\n", d);
d = new Double(100);
System.out.println(format.format(d));
System.out.printf("%1.1E\n", d);

    De sortie:

    1.0E-2
1.0E-02
1.0E2
1.0E+02

    Si vous avez besoin pour la sortie d'un String au lieu de cela, vous pouvez utiliser les informations fournies à Formaté Impression pour Java (sprintf) de le faire.

    EDIT: Wow, que PrintfFormat() chose est énorme et semble être inutile:

    OutputStream b = new ByteArrayOutputStream();
PrintStream p = new PrintStream(b);
p.printf("%1.1E", d);
System.out.println(b.toString());

    J'ai eu l'idée pour le code ci-dessus à partir de Obtenir un OutputStream dans une Chaîne.

    OriginalL'auteur Grant Wagner

  4. 0

    Comment l'utiliser?

    Voir formatTest méthode.

    if (value.compareTo(positive) == 1 || value.compareTo(negative) == -1) est utile pour un très grand nombre

    /**
* inspired by:<br>
* https://stackoverflow.com/a/13065493/8356718
* https://stackoverflow.com/a/18027214/8356718
* https://stackoverflow.com/a/25794946/8356718
*/
public static String format(String number, int scale) {
BigDecimal value = new BigDecimal(number);
DecimalFormatSymbols symbols = DecimalFormatSymbols.getInstance(Locale.US);
BigDecimal positive = new BigDecimal(1);//scale is zero
positive.setScale(0);//unnecessary
BigDecimal negative = new BigDecimal(-1);//scale is zero
negative.setScale(0);//unnecessary
if (value.compareTo(positive) == 1 || value.compareTo(negative) == -1) {
symbols.setExponentSeparator("e+");
} else {
symbols.setExponentSeparator("e");
}
DecimalFormat formatter = new DecimalFormat("0.0E0", symbols);
formatter.setRoundingMode(RoundingMode.HALF_UP);
formatter.setMinimumFractionDigits(scale);
return formatter.format(value);
}
/**
* set the scale automatically
*/
public static String format(String number) {
BigDecimal value = new BigDecimal(number);
return format(number, value.scale() > 0 ? value.precision() : value.scale());
}
/*
output:
----------
0e0
1.0e-2
-1.0e-2
1.234560e-5
-1.234560e-5
1e0
-1e0
3e+0
-3e+0
2e+2
-2e+2
----------
0.0000000000e0
1.0000000000e-2
-1.0000000000e-2
1.2345600000e-5
-1.2345600000e-5
1.0000000000e0
-1.0000000000e0
3.0000000000e+0
-3.0000000000e+0
2.0000000000e+2
-2.0000000000e+2
----------
*/
public static void formatTest() {
System.out.println("----------");
System.out.println(format("0"));
System.out.println(format("0.01"));
System.out.println(format("-0.01"));
System.out.println(format("0.0000123456"));
System.out.println(format("-0.0000123456"));
System.out.println(format("1"));
System.out.println(format("-1"));
System.out.println(format("3"));
System.out.println(format("-3"));
System.out.println(format("200"));
System.out.println(format("-200"));
System.out.println("----------");
System.out.println(format("0", 10));
System.out.println(format("0.01", 10));
System.out.println(format("-0.01", 10));
System.out.println(format("0.0000123456", 10));
System.out.println(format("-0.0000123456", 10));
System.out.println(format("1", 10));
System.out.println(format("-1", 10));
System.out.println(format("3", 10));
System.out.println(format("-3", 10));
System.out.println(format("200", 10));
System.out.println(format("-200", 10));
System.out.println("----------");
}
    Merci d'éditer votre post pour y inclure une explication de la façon dont elle répond à la question.

    OriginalL'auteur sambuca

  5. -1

    Pourquoi ne pas utiliser "0.0 E+0" à la place? Remarque le signe de l'avant-dernier zéro.

    Parce que le modèle proposé les résultats dans un java.lang.IllegalArgumentException contenant le texte: la malformation de tendance exponentielle "0.0 E+0"

    OriginalL'auteur kstep