Как красиво отформатировать плавающие числа в строку без лишних десятичных 0?

64-битный дубль может точно представлять целое число +/- 2 ⁵³

Учитывая этот факт, я решил использовать двойной тип как один тип для всех моих типов, так как мое самое большое целое число - 32-разрядное без знака.

Но теперь я должен напечатать эти псевдоцелые числа, но проблема в том, что они также смешиваются с реальными двойными числами.

Итак, как мне распечатать эти двойники в 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

Конечно, я могу написать функцию для обрезки этих нулей, но это большая потеря производительности из-за манипуляций со строками. Могу ли я сделать лучше с другим форматом кода?

РЕДАКТИРОВАТЬ

Ответы Тома Э. и Джереми С. неприемлемы, поскольку они оба произвольно округляют до 2 десятичных знаков. Пожалуйста, поймите проблему, прежде чем ответить.

РЕДАКТИРОВАТЬ 2

Обратите внимание, что String.format(format, args...)это зависит от локали (см. Ответы ниже).

Если идея состоит в том, чтобы напечатать целые числа, хранящиеся в виде двойных чисел, как если бы они были целыми числами, а в противном случае выведите двойные числа с минимально необходимой точностью:

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

И не полагается на манипуляции со строками.

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

Как указано в комментариях, это не правильный ответ на исходный вопрос.
Тем не менее, это очень полезный способ форматирования чисел без лишних конечных нулей.

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

Короче говоря:

Если вы хотите избавиться от конечных нулей и проблем локали, то вам следует использовать:

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.toString()или System.out.printlnили FloatingDecimal.toJavaFormatStringиспользует научные записи, если double меньше 10 ^ -3 или больше или равно 10 ^ 7

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

• при использовании %fдесятичная точность по умолчанию равна 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

  Использование английского языка гарантирует, что вы получите точку для десятичного разделителя, где бы ни была запущена ваша программа

Зачем использовать 340 тогда для setMaximumFractionDigits?

Две причины:

• setMaximumFractionDigitsпринимает целое число, но его реализация имеет максимально допустимые цифры, DecimalFormat.DOUBLE_FRACTION_DIGITSравные 340
• Double.MIN_VALUE = 4.9E-324 так что с 340 цифрами вы точно не округлите свою двойную и потерянную точность

Почему бы нет:

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

Это должно работать с экстремальными значениями, поддерживаемыми Double. Урожайность:

0.12
12
12.144252
0

На моей машине следующая функция примерно в 7 раз быстрее, чем функция, предоставленная ответом JasonD , поскольку она избегает String.format:

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

Мои 2 цента:

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

Нет, неважно.

Потеря производительности из-за манипуляций со строками равна нулю.

И вот код, чтобы обрезать конец после %f

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

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

Используйте DecimalFormatиsetMinimumFractionDigits(0)

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

Обратите внимание, что String.format(format, args...)это зависит от локали, потому что форматируется с использованием локали пользователя по умолчанию, то есть, вероятно, с запятыми и даже пробелами внутри, например 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;
}

Я сделал DoubleFormatterдля эффективного преобразования большого числа двойных значений в красивую / презентабельную строку:

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

• Если целая часть V имеет больше, чем MaxInteger =>, отобразите V в научном формате (1.2345e + 30), в противном случае отобразите в обычном формате 124.45678.
• MaxDecimal решает числа десятичных цифр (обрезать с округлением банкира)

Вот код:

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

Примечание: я использовал 2 функции из библиотеки GUAVA. Если вы не используете 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();
}

Это хорошо выполнит работу, я знаю, что тема старая, но я боролся с той же проблемой, пока не пришел к этому. Я надеюсь, что кто-то найдет это полезным.

    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 для минимального количества цифр
2. Рендерит # цифры

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

Поздний ответ, но ...

Вы сказали, что решили хранить свои номера с двойным типом . Я думаю, что это может быть корнем проблемы, потому что это заставляет вас хранить целые числа в двойных числах (и, следовательно, терять первоначальную информацию о природе значения). Как насчет хранения ваших номеров в экземплярах номера класса (суперкласса 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

Вот что я придумал:

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

Простой один лайнер, только бросает к int, если действительно нужно

Форматирование цены с группировкой, округлением, без лишних нулей (в двойном размере).

Правила:

1. Нет нулей в конце ( 2.0000 = 2; 1.0100000 = 1.01)
2. Максимум из двух цифр после точки ( 2.010 = 2.01; 0.20 = 0.2)
3. Округление после 2-й цифры после точки ( 1.994 = 1.99; 1.995 = 2; 1.006 = 1.01; 0.0006 -> 0)
4. Возвращает 0( null/-0 = 0)
5. Добавляет $( = $56/-$56)
6. Группировка ( 101101.02 = $101,101.02)

Больше примеров:

-99.985 = -$99.99

10 = $10

10.00 = $10

20.01000089 = $20.01

Написанный на Kotlin как забавное расширение Double (причина, используемая в Android), но может быть легко преобразован в Java, потому что были использованы классы Java.

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

Как пользоваться:

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

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

О десятичном формате : 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);
}

Я должен был использовать эту причину, d == (long)dдала мне нарушение в отчете сонара

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

это результат некоторых тестов:

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

Вот два способа добиться этого. Во-первых, более короткий (и, вероятно, лучший) путь:

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

Для Kotlin вы можете использовать расширение как:

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

Вот еще один ответ, который имеет возможность добавить десятичную ТОЛЬКО ЕСЛИ десятичная дробь не была равна нулю.

   /**
     * 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
    }

Вот ответ, который действительно работает (комбинация различных ответов здесь)

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

Я знаю, что это действительно старая тема. Но я думаю, что лучший способ сделать это, как показано ниже:

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

Вывод:

3.456 something
3.456234523452 something
3.45 something
3.0 something

Единственная проблема - последняя, ​​где .0 не удаляется. Но если вы можете жить с этим, то это работает лучше всего. % .2f округляет его до 2 последних десятичных цифр. Так будет и с DecimalFormat. Если вам нужны все десятичные разряды, но не конечные нули, то это работает лучше всего.

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

Это заставит строку отбросить хвостовые 0-s.