Bagaimana memformat angka mengambang menjadi String tanpa desimal 0 yang tidak perlu?

Double 64-bit dapat mewakili integer +/- 2 ^{53 dengan} tepat

Mengingat fakta ini saya memilih untuk menggunakan tipe ganda sebagai tipe tunggal untuk semua tipe saya, karena integer terbesar saya tidak bertanda 32-bit.

Tapi sekarang saya harus mencetak bilangan bulat semu ini, tetapi masalahnya adalah mereka juga bercampur dengan ganda yang sebenarnya.

Jadi bagaimana cara mencetak ganda ini dengan baik di Jawa?

Saya sudah mencoba String.format("%f", value), yang dekat, kecuali saya mendapatkan banyak angka nol untuk nilai kecil.

Berikut ini contoh keluaran dari %f

232.00000000
0,18000000000
1237875192.0
4.5800000000
0,00000000
1.23450000

Yang saya inginkan adalah:

232
0,18
1237875192
4.58
0
1.2345

Tentu saya bisa menulis fungsi untuk memangkas angka-angka itu, tapi itu banyak kehilangan kinerja karena manipulasi String. Bisakah saya melakukan yang lebih baik dengan kode format lain?

EDIT

Jawaban oleh Tom E. dan Jeremy S. tidak dapat diterima karena keduanya secara acak berputar ke 2 tempat desimal. Harap mengerti masalahnya sebelum menjawab.

EDIT 2

Harap perhatikan bahwa String.format(format, args...)ini tergantung pada lokal (lihat jawaban di bawah).

Jika idenya adalah mencetak bilangan bulat yang disimpan sebagai ganda seolah-olah bilangan bulat, dan sebaliknya mencetak ganda dengan presisi minimum yang diperlukan:

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

Menghasilkan:

232
0.18
1237875192
4.58
0
1.2345

Dan tidak mengandalkan manipulasi string.

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

Seperti yang ditunjukkan dalam komentar, ini bukan jawaban yang tepat untuk pertanyaan awal.
Yang mengatakan, ini adalah cara yang sangat berguna untuk memformat angka tanpa membuntuti nol.

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

Pendeknya:

Jika Anda ingin menghilangkan angka nol dan masalah Lokal, maka Anda harus menggunakan:

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

Penjelasan:

Mengapa jawaban lain tidak cocok untuk saya:

• Double.toString()atau System.out.printlnatau FloatingDecimal.toJavaFormatStringmenggunakan notasi ilmiah jika dobel kurang dari 10 ^ -3 atau lebih besar dari atau sama dengan 10 ^ 7

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

• dengan menggunakan %f, presisi desimal default adalah 6, jika tidak, Anda dapat meng-hardcode-nya tetapi hasilnya nol tambahan yang ditambahkan jika Anda memiliki lebih sedikit desimal. Contoh:

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

• dengan menggunakan setMaximumFractionDigits(0);atau %.0fAnda menghapus presisi desimal, yang baik untuk bilangan bulat / rindu tetapi tidak untuk ganda

  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

• dengan menggunakan DecimalFormat, Anda bergantung pada lokal. Di lokal Prancis, pemisah desimal adalah koma, bukan titik:

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

  Menggunakan lokal BAHASA INDONESIA memastikan Anda mendapatkan titik untuk pemisah desimal, di mana pun program Anda akan berjalan

Mengapa menggunakan 340 lalu untuk setMaximumFractionDigits?

Dua alasan:

• setMaximumFractionDigitsmenerima integer tetapi implementasinya memiliki angka maksimum yang diizinkan DecimalFormat.DOUBLE_FRACTION_DIGITSyang sama dengan 340
• Double.MIN_VALUE = 4.9E-324 jadi dengan 340 digit Anda yakin untuk tidak membulatkan presisi ganda dan longgar Anda

Kenapa tidak:

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

Ini harus bekerja dengan nilai ekstrim yang didukung oleh Double. Hasil:

0.12
12
12.144252
0

Di komputer saya, fungsi berikut kira-kira 7 kali lebih cepat daripada fungsi yang disediakan oleh jawaban JasonD , karena itu menghindari String.format:

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

2 sen saya:

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

Tidak, sudahlah.

Kehilangan kinerja karena manipulasi String adalah nol.

Dan inilah kode untuk memotong akhir setelahnya %f

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

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

Gunakan a DecimalFormatdansetMinimumFractionDigits(0)

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

Harap perhatikan bahwa String.format(format, args...)ini bergantung pada lokal karena memformat menggunakan lokal default pengguna, yaitu, mungkin dengan koma dan bahkan spasi di dalam seperti 123 456.789 atau 123.456.789 , yang mungkin tidak persis seperti yang Anda harapkan.

Anda mungkin lebih suka menggunakan String.format((Locale)null, format, args...).

Sebagai contoh,

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

cetakan

123456,789000
123456,789000
123456.789000

dan inilah yang akan String.format(format, args...)dilakukan di berbagai negara.

EDIT Ok, karena telah ada diskusi tentang formalitas:

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

Saya membuat DoubleFormatteruntuk secara efisien mengkonversi sejumlah besar nilai ganda ke String yang bagus / rapi:

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

• Jika bagian integer dari V memiliki lebih dari MaxInteger => tampilan V dalam format ilmuwan (1.2345e + 30) sebaliknya ditampilkan dalam format normal 124.45678.
• MaxDecimal menentukan jumlah digit desimal (trim dengan pembulatan bankir)

Berikut kodenya:

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

Catatan: Saya menggunakan 2 fungsi dari pustaka GUAVA. Jika Anda tidak menggunakan GUAVA, kode sendiri:

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

Yang ini akan menyelesaikan pekerjaan dengan baik, saya tahu topiknya sudah tua, tetapi saya masih berjuang dengan masalah yang sama sampai saya tiba di sini. Saya harap seseorang menemukannya bermanfaat.

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

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

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

1. 0 untuk jumlah digit minimum
2. Render # digit

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

Jawaban terlambat tapi ...

Anda bilang Anda memilih untuk menyimpan nomor Anda dengan tipe ganda . Saya pikir ini bisa menjadi akar masalah karena memaksa Anda untuk menyimpan bilangan bulat menjadi ganda (dan karena itu kehilangan informasi awal tentang sifat nilai). Bagaimana dengan menyimpan nomor Anda dalam instance kelas Number (superclass dari Double dan Integer) dan mengandalkan polimorfisme untuk menentukan format yang benar dari setiap nomor?

Saya tahu itu mungkin tidak dapat diterima untuk refactor seluruh bagian dari kode Anda karena itu tetapi bisa menghasilkan output yang diinginkan tanpa kode tambahan / casting / parsing.

Contoh:

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

}

Akan menghasilkan output berikut:

232
0.18
1237875192
4.58
0
1.2345

Inilah yang saya pikirkan:

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

Sederhana satu liner, hanya dicetak ke int jika benar-benar perlu

Format harga dengan pengelompokan, pembulatan, tidak ada nol yang tidak perlu (ganda).

Aturan:

1. Tidak ada nol di akhir ( 2.0000 = 2; 1.0100000 = 1.01)
2. Dua digit maksimum setelah satu titik ( 2.010 = 2.01; 0.20 = 0.2)
3. Pembulatan setelah digit ke-2 setelah titik ( 1.994 = 1.99; 1.995 = 2; 1.006 = 1.01; 0.0006 -> 0)
4. Pengembalian 0( null/-0 = 0)
5. Tambah $( = $56/-$56)
6. Pengelompokan ( 101101.02 = $101,101.02)

Lebih banyak contoh:

-99.985 = -$99.99

10 = $10

10.00 = $10

20.01000089 = $20.01

Ditulis dalam Kotlin sebagai ekstensi menyenangkan Double (sebab digunakan di Android), tetapi dapat dikonversi ke Java dengan mudah, menyebabkan kelas java digunakan.

/**
 * 23.0 -> $23
 *
 * 23.1 -> $23.1
 *
 * 23.01 -> $23.01
 *
 * 23.99 -> $23.99
 *
 * 23.999 -> $24
 *
 * -0.0 -> $0
 *
 * -5.00 -> -$5
 *
 * -5.019 -> -$5.02
 */
fun Double?.formatUserAsSum(): String {
    return when {
        this == null || this == 0.0 -> "$0"
        this % 1 == 0.0 -> DecimalFormat("$#,##0;-$#,##0").format(this)
        else -> DecimalFormat("$#,##0.##;-$#,##0.##").format(this)
    }
}

Cara Penggunaan:

var yourDouble: Double? = -20.00
println(yourDouble.formatUserAsSum()) // will print -$20

yourDouble = null
println(yourDouble.formatUserAsSum()) // will print $0

Tentang DecimalFormat : https://docs.oracle.com/javase/6/docs/api/java/text/DecimalFormat.html

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

Saya harus menggunakan penyebab d == (long)dini memberi saya pelanggaran dalam laporan sonar

float price = 4.30;
DecimalFormat format = new DecimalFormat("0.##"); // Choose the number of decimal places to work with in case they are different than zero and zero value will be removed
format.setRoundingMode(RoundingMode.DOWN); // choose your Rounding Mode
System.out.println(format.format(price));

ini adalah hasil dari beberapa tes:

4.30     => 4.3
4.39     => 4.39  // Choose format.setRoundingMode(RoundingMode.UP) to get 4.4
4.000000 => 4
4        => 4

Berikut adalah dua cara untuk mencapainya. Pertama, cara yang lebih pendek (dan mungkin lebih baik):

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

Dan inilah cara yang lebih panjang dan mungkin lebih buruk:

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

Untuk Kotlin Anda dapat menggunakan ekstensi seperti:

fun Double.toPrettyString() =
    if(this - this.toLong() == 0.0)
        String.format("%d", this.toLong())
    else
        String.format("%s",this)

Berikut jawaban lain yang memiliki opsi untuk menambahkan desimal SAJA JIKA desimal tidak nol.

   /**
     * Example: (isDecimalRequired = true)
     * d = 12345
     * returns 12,345.00
     *
     * d = 12345.12345
     * returns 12,345.12
     *
     * ==================================================
     * Example: (isDecimalRequired = false)
     * d = 12345
     * returns 12,345 (notice that there's no decimal since it's zero)
     *
     * d = 12345.12345
     * returns 12,345.12
     *
     * @param d float to format
     * @param zeroCount number decimal places
     * @param isDecimalRequired true if it will put decimal even zero,
     * false will remove the last decimal(s) if zero.
     */
    fun formatDecimal(d: Float? = 0f, zeroCount: Int, isDecimalRequired: Boolean = true): String {
        val zeros = StringBuilder()

        for (i in 0 until zeroCount) {
            zeros.append("0")
        }

        var pattern = "#,##0"

        if (zeros.isNotEmpty()) {
            pattern += ".$zeros"
        }

        val numberFormat = DecimalFormat(pattern)

        var formattedNumber = if (d != null) numberFormat.format(d) else "0"

        if (!isDecimalRequired) {
            for (i in formattedNumber.length downTo formattedNumber.length - zeroCount) {
                val number = formattedNumber[i - 1]

                if (number == '0' || number == '.') {
                    formattedNumber = formattedNumber.substring(0, formattedNumber.length - 1)
                } else {
                    break
                }
            }
        }

        return formattedNumber
    }

Inilah jawaban yang benar-benar berfungsi (kombinasi jawaban berbeda di sini)

public static String removeTrailingZeros(double f)
{
    if(f == (int)f) {
        return String.format("%d", (int)f);
    }
    return String.format("%f", f).replaceAll("0*$", "");
}

Saya tahu ini adalah utas yang sangat lama .. Tapi saya pikir cara terbaik untuk melakukan ini adalah sebagai berikut:

public class Test {

    public static void main(String args[]){
        System.out.println(String.format("%s something",new Double(3.456)));
        System.out.println(String.format("%s something",new Double(3.456234523452)));
        System.out.println(String.format("%s something",new Double(3.45)));
        System.out.println(String.format("%s something",new Double(3)));
    }
}

Keluaran:

3.456 something
3.456234523452 something
3.45 something
3.0 something

Satu-satunya masalah adalah yang terakhir di mana .0 tidak dihapus. Tetapi jika Anda dapat hidup dengan itu maka ini bekerja paling baik. % .2f akan membulatkannya ke 2 angka desimal terakhir. Begitu juga DecimalFormat. Jika Anda membutuhkan semua tempat desimal tetapi bukan nol yang tertinggal maka ini bekerja paling baik.

String s = "1.210000";
while (s.endsWith("0")){
    s = (s.substring(0, s.length() - 1));
}

Ini akan membuat string untuk menjatuhkan tailing 0-s.