64位double可以精确地表示整数+/- 253。

鉴于这一事实,我选择使用双类型作为我所有类型的单一类型,因为我的最大整数是一个无符号的32位数字。

但现在我必须打印这些伪整数,但问题是它们也和实际的双精度数混合在一起。

那么如何在Java中很好地打印这些double呢?

我试过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

当然,我可以写一个函数来修剪这些零,但由于字符串操作,这是大量的性能损失。我能用其他格式的代码做得更好吗?


Tom E.和Jeremy S.的答案是不可接受的,因为他们都任意舍入到小数点后两位。请先理解问题再回答。


请注意字符串。Format (Format, args…)依赖于语言环境(见下面的答案)。


当前回答

Use:

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

这应该与Double支持的极值一起工作。它的收益率:

0.12
12
12.144252
0

其他回答

简而言之:

如果你想摆脱尾随零和区域问题,那么你应该使用:

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() or System.out.println or FloatingDecimal.toJavaFormatString uses scientific notations if double is less than 10^-3 or greater than or equal to 10^7 double myValue = 0.00000021d; String.format("%s", myvalue); //output: 2.1E-7 by using %f, the default decimal precision is 6, otherwise you can hardcode it, but it results in extra zeros added if you have fewer decimals. Example: double myValue = 0.00000021d; String.format("%.12f", myvalue); // Output: 0.000000210000 by using setMaximumFractionDigits(0); or %.0f you remove any decimal precision, which is fine for integers/longs but not for double 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 by using DecimalFormat, you are local dependent. In the French locale, the decimal separator is a comma, not a point: double myValue = 0.00000021d; DecimalFormat df = new DecimalFormat("0"); df.setMaximumFractionDigits(340); System.out.println(df.format(myvalue)); // Output: 0,00000021 Using the ENGLISH locale makes sure you get a point for decimal separator, wherever your program will run.

为什么使用340然后setMaximumFractionDigits?

两个原因:

setMaximumFractionDigits接受一个整数,但是它的实现有DecimalFormat允许的最大数字。DOUBLE_FRACTION_DIGITS等于340 翻倍。MIN_VALUE = 4.9E-324,因此使用340位数字,您肯定不会四舍五入的双精度和损失精度

请注意字符串。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…)

EDIT好的,既然已经讨论了有关手续的问题:

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

0.0 -> 0% 1.0 -> 100% 0.1 -> 10% 0.11 -> 11% 0.01 -> 1% 0.111 -> 11.1% 0.001 -> 0.1% 0.1111 -> 11.11% 0.0001 -> 0.01%

添加".replace()"是因为我总是使用错误的分隔符

import java.text.NumberFormat

fun Double.formating(): String {
    val defaultFormat: NumberFormat = NumberFormat.getPercentInstance()
    defaultFormat.minimumFractionDigits = 0
    defaultFormat.maximumFractionDigits = 2

    return defaultFormat.format(this).replace(",", ".")
}

用分组、四舍五入和没有不必要的零(双位数)格式化价格。

规则:

末尾没有零(2.0000 = 2;1.0100000 = 1.01) 一个点后最多两位数(2.010 = 2.01;0.20 = 0.2) 一个点后的第二位数字(1.994 = 1.99;1.995 = 2;1.006 = 1.01;0.0006 -> 0 返回0 (null/-0 = 0) 增加$ (= $56/-$56) 分组(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

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

这里有两种方法来实现它。首先,更短(可能更好)的方式:

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