不必要な10進数の0を使わずに、浮動小数点数をStringにうまくフォーマットする方法は？

Question

64ビットdoubleは整数+/- 2を表すことができます⁵³ まさに

この事実を考えると、私の最大の整数は符号なし32ビットなので、私はすべての型に対して単一の型としてdouble型を使用することを選択します。

しかし今、私はこれらの疑似整数を表示しなければなりません、しかし問題はそれらが実際の倍精度と混在しているということです。

では、どのようにこれらのdoubleをJavaでうまく印刷するのでしょうか。

私はString.format("%f", value)を試してみましたが、小さい値の場合は末尾のゼロがたくさん出ます。

これは%fの出力例です。

 232.00000000 
 0.18000000000 
 1237875192.0 
 4.5800000000 
 0.00000000 
 1.23450000 

私が欲しいのは：

 232 
 0.18 
 1237875192 
 4.58 
 0 
 1.2345 

確かに私はそれらのゼロを整えるための関数を書くことができますが、それは文字列操作によるパフォーマンスの損失の多くです。他のフォーマットコードでもっとうまくいくことができますか？

EDIT

Tom E.とJeremy S.の答えは、どちらも小数点以下第2位まで任意に丸められるため、受け入れられません。答える前に問題を理解してください。

編集2

String.format(format, args...)は ロケール依存 であることに注意してください（下記の回答を参照）。

Answer 1

考えが倍精度整数として格納された整数を整数であるかのように印刷することであり、そうでなければ最低限必要な精度で倍精度を印刷することです。

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

を生成します。

232
0.18
1237875192
4.58
0
1.2345

そして、文字列操作には依存しません。

Answer 2

new DecimalFormat("#.##").format(1.199); //"1.2"

コメントで指摘されているように、これは元の質問に対する正しい答えではありません。
それは言った、それは不必要な末尾のゼロなしで数字をフォーマットするための非常に便利な方法です。

Answer 3

String.format("%.2f", value) ;

Answer 4

要するに：

末尾のゼロとロケールの問題を取り除きたい場合は、次のようにします。

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

説明：

なぜ他の答えが私に合わなかったのか：

• doubleが10 ^ -3未満または10 ^ 7以上の場合、Double.toString()、System.out.println、またはFloatingDecimal.toJavaFormatStringは科学表記法を使用します

  double myValue = 0.00000021d;
  String.format("%s", myvalue); //output: 2.1E-7
  

• %fを使用すると、デフォルトの10進精度は6です。それ以外の場合はハードコーディングできますが、小数点以下の桁数が少ない場合は余分なゼロが追加されます。例：

  double myValue = 0.00000021d;
  String.format("%.12f", myvalue); //output: 0.000000210000
  

• setMaximumFractionDigits(0);または%.0fを使用すると、小数点以下の精度をすべて削除できます。これは、整数型/整数型では問題ありませんが、倍精度では不可能です。

  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
  

• decimalFormatを使用すると、ローカルに依存します。フランス語ロケールでは、小数点記号はコンマであり、小数点ではありません。

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

  ENGLISHロケールを使用すると、プログラムが実行される場所にかかわらず、必ず小数点記号が得られます。

なぜsetMaximumFractionDigitsに340を使ったのですか？

2つの理由

• setMaximumFractionDigitsは整数を受け入れますが、その実装はDecimalFormat.DOUBLE_FRACTION_DIGITSの最大許容桁数を持ちます。これは340です。
• Double.MIN_VALUE = 4.9E-324は340桁なので、倍精度とゆるみの精度を丸めないでください。

Answer 5

何故なの：

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

これはDoubleでサポートされている極端な値で動作するはずです。収量：

0.12
12
12.144252
0

Answer 6

私の2セント：

if(n % 1 == 0) {
    return String.format(Locale.US, "%.0f", n));
} else {
    return String.format(Locale.US, "%.1f", n));
}

Answer 7

私のマシンでは、以下の関数は JasonDの答え によって提供される関数よりもおよそ7倍高速です。なぜなら、それはString.formatを避けているからです。

public static String prettyPrint(double d) {
  int i = (int) d;
  return d == i ? String.valueOf(i) : String.valueOf(d);
}

Answer 8

いや、気にしないで。

文字列操作によるパフォーマンスの低下はゼロです。

そしてこれが%fの後の終わりをトリミングするコードです。

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

    return number.replaceAll("\\.?0*$", "");
}

Answer 9

if (d == Math.floor(d)) {
    return String.format("%.0f", d);
} else {
    return Double.toString(d);
}

Answer 10

大量のdouble値を効率的にNice/presentable Stringに変換するためにDoubleFormatterを作成しました。

double horribleNumber = 3598945.141658554548844; 
DoubleFormatter df = new DoubleFormatter(4,6); //4 = MaxInteger, 6 = MaxDecimal
String beautyDisplay = df.format(horribleNumber);

• Vの整数部がMaxInteger =>よりも大きい場合科学者フォーマット（1.2345e + 30）でVを表示し、そうでなければ通常フォーマット124.45678で表示します。
• maxDecimalが10進数の桁数を決定します（銀行の四捨五入による切り捨て）

ここでのコード：

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();
    }
}

注：私はGUAVAライブラリから2つの関数を使用しました。 GUAVAを使用しない場合は、自分でコーディングしてください。

/**
 * 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();
}

Answer 11

String.format(format, args...)はlocale-dependentです。なぜなら、それはユーザーのデフォルトロケールを使用し、、つまり123 456,789または123,456.789）のように中にスペースも含まれます）、これはあなたが期待したとおりのものではないかもしれません。

String.format((Locale)null, format, args...)を使うほうがいいかもしれません。

例えば、

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

版画

123456,789000
123456,789000
123456.789000

これが、さまざまな国でString.format(format, args...)がすることです。

編集手続きについての議論がありましたので、わかりました。

    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;
}

Answer 12

new DecimalFormat("00.#").format(20.236)
//out =20.2

new DecimalFormat("00.#").format(2.236)
//out =02.2

1. 最小桁数は0
2. ＃桁をレンダリングする

Answer 13

トピックが古くなっていることはわかっていますが、これに至るまで同じ問題に取り組んでいました。私は誰かがそれが役に立つと思うことを願っています。

    public static String removeZero(double number) {
        DecimalFormat format = new DecimalFormat("#.###########");
        return format.format(number);
    }

Answer 14

DecimalFormatとsetMinimumFractionDigits(0)を使う

Answer 15

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

Answer 16

回答が遅れていますが...

あなたはあなたの言ったdouble型であなたの数字を保存するために を選びます。これは、integersをdoubleに格納しなければならないため、問題の根本になる可能性があると思います（したがって、値の性質に関する初期情報が失われます）。 Number クラス（DoubleとIntegerの両方のスーパークラス）のインスタンスにあなたの数を保存して、それぞれの数の正しいフォーマットを決定するために多態性に頼ることについてはどうですか？

私はそれが原因であなたのコードの全体をリファクタリングすることは受け入れられないかもしれませんが、それは余分なコード/キャスト/解析なしで望ましい出力を生成することができます。

例：

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

}

次のような出力が得られます。

232
0.18
1237875192
4.58
0
1.2345

Answer 17

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

d == (long)dがソナーレポートで違反を起こしていたため、この原因を使用しなければなりませんでした

Answer 18

これが私が思いついたものです。

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

単純な1つのライナー。本当に必要な場合にのみintにキャストします。

Answer 19

これを実現する2つの方法があります。まず、より短い（そしておそらくより良い）方法です。

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

そして、これはもっと長くそしておそらくもっと悪い方法です：

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;
  }