blocks|key|160606|text|不能将双精度(或双精度)的精度设置为指定的小数位数，因为浮点值没有小数位。它们有二进制数字。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|160607|您必须通过BigDecimal或DecimalFormat将其转换为十进制基数，具体取决于您稍后要对该值执行的操作。|offset|length|style|CODE|160608|另请参阅我对this+question的回答，以反驳不可避免的*100/100答案。|160609|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/153724/how-to-round-a-number-to-n-decimal-places-in-java/12684082#12684082^0|0|5|A|G|D|0|6|D|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@$D|T|E|U|F|G]|$D|V|E|W|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|X|8|@]|9|@$D|Y|E|Z|1|10]]|A|$]]|$1|J|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q]]]]

You can't set the precision of a double (or Double) to a specified number of decimal digits, because floating-point values don't have decimal digits. They have binary digits.

You will have to convert into a decimal radix, either via <code>BigDecimal</code> or <code>DecimalFormat</code>, depending on what you want to do with the value later.

See also my answer to <a href="https://stackoverflow.com/questions/153724/how-to-round-a-number-to-n-decimal-places-in-java/12684082#12684082">this question</a> for a refutation of the inevitable *100/100 answers.

blocks|key|160796|text|您可以尝试使用BigDecimal来实现此目的|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|160797|Double+toBeTruncated+=+new+Double("3.5789055");

Double+truncatedDouble+=+BigDecimal.valueOf(toBeTruncated)
++++.setScale(3,+RoundingMode.HALF_UP)
++++.doubleValue();|code-block|syntax|javascript|160798|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/javase/7/docs/api/java/math/BigDecimal.html^0|7|A|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

You can try <a href="https://docs.oracle.com/javase/7/docs/api/java/math/BigDecimal.html">BigDecimal</a> for this purpose 

<pre><code>Double toBeTruncated = new Double("3.5789055");

Double truncatedDouble = BigDecimal.valueOf(toBeTruncated)
 .setScale(3, RoundingMode.HALF_UP)
 .doubleValue();
</code></pre>

blocks|key|160765|text|这是一种简单的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|160766|String+formato+=+String.format("%25.2f");|code-block|syntax|javascript|160767|它将精度设置为2位数。|160768|如果您只想打印，请这样使用它：|160769|System.out.printf("%25.2f",123.234);|160770|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

This is an easy way to do it:

<pre><code>String formato = String.format("%.2f");
</code></pre>

It sets the precision to 2 digits.

If you only want to print, use it this way:

<pre><code>System.out.printf("%.2f",123.234);
</code></pre>

blocks|key|160856|text|为双精度值设置精度DecimalFormat是一个很好的技巧。要使用此类，请导入java.text.DecimalFormat并创建其对象，例如|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|160857|double+no=12.786;
DecimalFormat+dec+=+new+DecimalFormat("#0.00");
System.out.println(dec.format(no));|code-block|syntax|javascript|160858|所以它将打印小数点后的两位数，在这里它将打印12.79|160859|entityMap^0|9|D|14|N|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

To set precision for double values <code>DecimalFormat</code> is good technique. To use this class import <code>java.text.DecimalFormat</code> and create object of it for example 

<pre><code>double no=12.786;
DecimalFormat dec = new DecimalFormat("#0.00");
System.out.println(dec.format(no));
</code></pre>

So it will print two digits after decimal point here it will print 12.79

blocks|key|378848|text|这对我很有效：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|378849|public+static+void+main(String[]+s)+{
++++++++Double+d+=+Math.PI;
++++++++d+=+Double.parseDouble(String.format("%25.3f",+d));++//+can+be+required+precision
++++++++System.out.println(d);
++++}|code-block|syntax|javascript|378850|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This worked for me:

<pre><code>public static void main(String[] s) {
 Double d = Math.PI;
 d = Double.parseDouble(String.format("%.3f", d)); // can be required precision
 System.out.println(d);
 }
</code></pre>

blocks|key|160644|text|double和float的精度由它们的大小和IEEE+floating+point+types的实现方式决定。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|160645|另一方面，输出中的小数位数与格式有关。你是对的，一遍又一遍地键入相同的常量不是一个好主意。您应该声明一个字符串常量，并使用它的符号表示。|160646|private+static+final+String+DBL_FMT+=+"##.####";|code-block|syntax|javascript|160647|使用符号表示将允许您更改常量使用的所有位置的精度，而无需搜索您的代码。|160648|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/IEEE_floating_point^0|0|6|7|5|M|P|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@$9|11|A|12|1|13]]|E|$]]|$1|F|3|G|5|6|7|14|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|15|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|16|8|@]|D|@]|E|$]]|$1|O|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]]]

The precision of <code>double</code> and <code>float</code> is fixed by their size and the way the <a href="http://en.wikipedia.org/wiki/IEEE_floating_point" rel="nofollow">IEEE floating point types</a> are implemented.

The number of decimal digits in the output, on the other hand, is a matter of formatting. You are correct that typing the same constant over and over is a bad idea. You should declare a string constant instead, and use its symbolic representation.

<pre><code>private static final String DBL_FMT = "##.####";
</code></pre>

Using a symbolic representation would let you change precision in all places the constant is used without searching through your code.

blocks|key|378801|text|BigDecimal+value+=+new+BigDecimal(10.0000);
value.setScale(4);|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|378802|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>BigDecimal value = new BigDecimal(10.0000);
value.setScale(4);
</code></pre>

blocks|key|378690|text|在@EJP上进行扩展，在处理doubles时“精度”的概念是非常令人担忧的。正如在https://stackoverflow.com/a/3730040/390153中所讨论的，无论精度如何，您甚至不能将0.1表示为双精度，出于同样的原因，您不能以有限精度表示以10为基数的1/3。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|378691|您需要考虑您正在尝试解决的问题，并考虑：|378692|a)我是否应该首先使用doubles；如果精确度是一个相关的概念，那么使用doubles很可能是一个错误。|378693|b)如果双精度合适，我所说的精度是什么意思？如果你只是在谈论显示，那么把逻辑包装在一个显示函数中，你只需要在一个地方处理它。应用DRY原则。|378694|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/3730040/390153^0|15|16|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@$A|S|B|T|1|U]]|C|$]]|$1|D|3|E|5|6|7|V|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|W|8|@]|9|@]|C|$]]|$1|H|3|I|5|6|7|X|8|@]|9|@]|C|$]]|$1|J|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|K|$L|$5|M|N|O|C|$P|Q]]]]

To expand on @EJP, the concept of 'precision' when dealing with doubles is extremely fraught. As discussed in <a href="https://stackoverflow.com/a/3730040/390153">https://stackoverflow.com/a/3730040/390153</a> you can't even represent 0.1 as a double regardless of the precision, for the same reason you can't represent 1/3 in base 10 with finite precision.

You need to consider the problem you are trying to solve, and consider:

a) Should I be using doubles in the first place; if precision is a relevant concept, then using doubles may well be a mistake.

b) If doubles are appropriate, what do I mean by precision? If you are only talking about display, wrap the logic in a display function and you will only need to deal with it in one place; ie. apply the DRY principle.

blocks|key|160708|text|public+static+String+setPrecision(String+number,+int+decimal)+{
++++double+nbr+=+Double.valueOf(number);
++++int+integer_Part+=+(int)+nbr;
++++double+float_Part+=+nbr+-+integer_Part;
++++int+floating_point+=+(int)+(Math.pow(10,+decimal)+*+float_Part);
++++String+final_nbr+=+String.valueOf(integer_Part)+%2B+"."+%2B+String.valueOf(floating_point);
++++return+final_nbr;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|160709|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>public static String setPrecision(String number, int decimal) {
 double nbr = Double.valueOf(number);
 int integer_Part = (int) nbr;
 double float_Part = nbr - integer_Part;
 int floating_point = (int) (Math.pow(10, decimal) * float_Part);
 String final_nbr = String.valueOf(integer_Part) + "." + String.valueOf(floating_point);
 return final_nbr;
}
</code></pre>

blocks|key|378729|text|也许这个方法可以帮助你精确化双精度值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|378730|double+truncate(double+number)
++++{
++++++++int+integerPart+=+(int)+number;
++++++++double+fractionalPart+=+number+-+integerPart;
++++++++fractionalPart+*=+100;++//It+is+for+upto+two+decimal+values+after+point.
++++++++++++++++++++++++++++++++//You+can+increase+the+zeros+to+fulfill+your+needs.
++++++++int+fractPart+=+(int)+fractionalPart;
++++++++fractionalPart+=+(double)+(integerPart)+%2B+(double)+(fractPart)/100;
++++++++return+fractionalPart;
++++}|code-block|syntax|javascript|378731|此方法将允许设置精度级别。|378732|double+truncate(double+number,+int+precision)
{
++++double+prec+=+Math.pow(10,+precision);
++++int+integerPart+=+(int)+number;
++++double+fractionalPart+=+number+-+integerPart;
++++fractionalPart+*=+prec;
++++int+fractPart+=+(int)+fractionalPart;
++++fractionalPart+=+(double)+(integerPart)+%2B+(double)+(fractPart)/prec;
++++return+fractionalPart;
}|378733|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Maybe this method would help you for precising double values.

<pre><code>double truncate(double number)
 {
 int integerPart = (int) number;
 double fractionalPart = number - integerPart;
 fractionalPart *= 100; //It is for upto two decimal values after point.
 //You can increase the zeros to fulfill your needs.
 int fractPart = (int) fractionalPart;
 fractionalPart = (double) (integerPart) + (double) (fractPart)/100;
 return fractionalPart;
 }
</code></pre>

This method will allow to set the precision level.

<pre><code>double truncate(double number, int precision)
{
 double prec = Math.pow(10, precision);
 int integerPart = (int) number;
 double fractionalPart = number - integerPart;
 fractionalPart *= prec;
 int fractPart = (int) fractionalPart;
 fractionalPart = (double) (integerPart) + (double) (fractPart)/prec;
 return fractionalPart;
}
</code></pre>

I was working with numbers recently and I had a situation where I want to set the precision of a double value say to 6 digits or 4 digits, depending on the value stored in the database.

For example, If in the database the precision is set as 4 digits then the output must look as,

<code>10.0000</code>. 

I tried with <code>DecimalFormat</code> and using the string <code>##.####</code>, but it is annoying to use symbols everytime. 

Is there any better approach, say something like below:

<pre><code>Double value = 10.0;
value.setPrecision(4);
</code></pre>

Java: How to set Precision for double value?

我最近正在处理数字，我遇到了这样一种情况，我希望将双精度值的精度设置为6位或4位，具体取决于数据库中存储的值。例如，如果在数据库中将精度设置为4位，则输出必须如下所示：10.0000。我尝试使用DecimalFormat并使用字符串##.####，但每次都使用符号是很烦人的。有没有更好的方法，像下面这样说：Double value = 10.0;value.setPrecision(4);

问Java:如何为双精度值设置精度？
EN

回答 10

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java:如何为双精度值设置精度？EN

回答 10

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java:如何为双精度值设置精度？
EN