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…)依赖于语言环境(见下面的答案)。
当前回答
在我的机器上，下面的函数大约比JasonD的答案提供的函数快7倍，因为它避免了String.format:
public static String prettyPrint(double d) {
int i = (int) d;
return d == i ? String.valueOf(i) : String.valueOf(d);
}
其他回答
这是另一个答案，它有一个选项，只有当小数不为零时才附加小数。
/**
* 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 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
并且不依赖于字符串操作。
你说你选择用双类型存储你的数字。我认为这可能是问题的根源，因为它迫使您将整数存储为双精度(因此丢失了关于值性质的初始信息)。将数字存储在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
最好的方法如下:
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会四舍五入到小数点后两位。DecimalFormat也是如此。如果你需要所有的小数点后数位，但不需要后面的零，那么这个方法是最好的。
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在SonarQube报告中给了我违例。
