blocks|key|2562812|text|1)请勿使用double。浮点逻辑充其量是近似的。请改用BigDecimal。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2562813|2)我认为BigDecimal已经有了一种设置精度的方法。如果不是，只需乘以1000和trunc即可。执行该操作，获得一个新的数字，并与原始数字进行比较。如果不同，则失败。|2562814|entityMap^0|6|6|S|A|0|5|A|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|R|8|@]|D|@]|E|$]]]|I|$]]

1) Do not use <code>double</code>. Floating point logic is approximated at best. Use <code>BigDecimal</code> instead.

2) I think <code>BigDecimal</code> already has a way of setting a precision. If not, just multiply by 1000 and trunc. Do the operation, get a new number, and compare to the original one. If it is different, fail.

blocks|key|2562847|text|这将通过您的测试：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2562848|package+com.sandbox;

import+org.junit.Test;

import+static+junit.framework.Assert.assertFalse;
import+static+junit.framework.Assert.assertTrue;

public+class+SandboxTest+{


++++@Test
++++public+void+testPrecision()+{
++++++++assertFalse(precisionLessThanOrEqualTo3(20.44567567));
++++++++assertTrue(precisionLessThanOrEqualTo3(20.444));
++++++++assertTrue(precisionLessThanOrEqualTo3(20.1));
++++++++assertTrue(precisionLessThanOrEqualTo3(20));
++++}

++++private+boolean+precisionLessThanOrEqualTo3(double+x)+{
++++++++return+String.valueOf(x).replaceAll(".*\\.",+"").length()+<=+3;
++++}
}|code-block|syntax|javascript|2562849|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 passes your tests:

<pre><code>package com.sandbox;

import org.junit.Test;

import static junit.framework.Assert.assertFalse;
import static junit.framework.Assert.assertTrue;

public class SandboxTest {


 @Test
 public void testPrecision() {
 assertFalse(precisionLessThanOrEqualTo3(20.44567567));
 assertTrue(precisionLessThanOrEqualTo3(20.444));
 assertTrue(precisionLessThanOrEqualTo3(20.1));
 assertTrue(precisionLessThanOrEqualTo3(20));
 }

 private boolean precisionLessThanOrEqualTo3(double x) {
 return String.valueOf(x).replaceAll(".*\\.", "").length() &lt;= 3;
 }
}
</code></pre>

blocks|key|438405|text|您可以使用以下代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|438406|boolean+f+(double+in){
++++if+(in*1000+>+(float)(int)(in*1000))
++++++++return+false;
++++return+true;
}|code-block|syntax|javascript|438407|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|$]]

You can use the following code:

<pre><code>boolean f (double in){
 if (in*1000 &gt; (float)(int)(in*1000))
 return false;
 return true;
}
</code></pre>

blocks|key|1045467|text|对术语"precision"有多种可能的解释|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1045468|1045469|算术精度是有效数字(小数点前后)的总数。|unordered-list-item|1045470|小数部分的位数(或小数位数在数据库中，精度可以用计数中包含的固定小数位数(小数位数)来衡量，因此NUMBER(6,2)列将存储最多6位的数字，这些数字始终由2个小数位和4个整数位组成。|style|CODE|1045471|1045472|在您的示例中，您似乎将精度度量为最大小数位数。|1045473|其中的每一个都可以使用以下命令进行测试：|1045474|import+java.math.BigDecimal;

import+org.junit.Test;
import+static+org.junit.Assert.*;


public+class+Precision
{
++/**
+++*+Tests+to+see+whether+the+number+has+up+to+the+given+number+of
+++*+decimal+places.
+++*+
+++*+@param+value+The+value+to+test.
+++*+@param+scale+The+maximum+number+of+decimal+places.+
+++*+@return++++++<code>true</code>+if+the+value+has+up+to+the
+++*++++++++++++++expected+number+of+decimal+places.
+++*/
++static+final+boolean+hasDecimalPlaces(
++++++final+double+value,
++++++final+int++++scale
++)
++{
++++try
++++{
++++++new+BigDecimal(+Double.toString(+value+)+).setScale(+scale+);
++++++return+true;
++++}
++++catch+(+final+ArithmeticException+ex+)
++++{
++++++return+false;
++++}
++}

++/**
+++*+Tests+to+see+whether+the+number+has+up+to+the+given+number+of
+++*+significant+figures.
+++*+
+++*+@param+value+++++The+value+to+test.
+++*+@param+precision+The+maximum+number+of+significant+figures+to
+++*++++++++++++++++++test+for.
+++*+@return++++++++++<code>true</code>+if+the+value+has+up+to+the
+++*++++++++++++++++++expected+number+of+significant+figures.+
+++*/
++static+final+boolean+hasSignificantFigures(
++++++final+double+value,
++++++final+int++++precision
++)
++{
++++try
++++{
++++++return+new+BigDecimal(+Double.toString(+value+)+).stripTrailingZeros().precision()+<=+precision;
++++}
++++catch+(+final+ArithmeticException+ex+)
++++{
++++++return+false;
++++}
++}

++/**
+++*+Tests+to+see+whether+the+number+has+at+most+the+given+number+of
+++*+decimal+places+and,+when+represented+at+that+maximum+number+of
+++*+decimal+places,+has+up+to+the+given+number+of+digits.
+++*+
+++*+@param+value+++++The+number+to+test.
+++*+@param+precision+The+maximum+number+of+digits+to+test+for.
+++*+@param+scale+++++The+maximum+number+of+decimal+places.
+++*+@return++++++++++<code>true</code>+if+the+value+can+be+represented
+++*++++++++++++++++++at+the+given+scale+and,+at+that+scale,+is+up+to
+++*++++++++++++++++++the+given+precision.
+++*/
++static+final+boolean+hasDigitsAtScale(
++++++final+double+value,
++++++final+int++++precision,
++++++final+int++++scale
++)
++{
++++try
++++{
++++++return+new+BigDecimal(+Double.toString(+value+)+).setScale(+scale+).precision()+<=+precision;
++++}
++++catch+(+final+ArithmeticException+ex+)
++++{
++++++return+false;
++++}
++}

++@Test
++public+void+testScale(){
++++assertTrue(+hasDecimalPlaces(+20d,+3+)+);
++++assertTrue(+hasDecimalPlaces(+20.123d,+3+)+);
++++assertFalse(+hasDecimalPlaces(+20.1234d,+3+)+);
++}

++@Test
++public+void+testPrecision(){
++++assertTrue(++hasSignificantFigures(++++20d,++++++3+)+);
++++assertTrue(++hasSignificantFigures(+++120d,++++++3+)+);
++++assertTrue(++hasSignificantFigures(++1230d,++++++3+)+);
++++assertFalse(+hasSignificantFigures(+12340d,++++++3+)+);
++++assertTrue(++hasSignificantFigures(++++20.1d,++++3+)+);
++++assertFalse(+hasSignificantFigures(++++20.12d,+++3+)+);
++++assertTrue(++hasSignificantFigures(+++++0.123d,++3+)+);
++++assertFalse(+hasSignificantFigures(+++++0.1234d,+3+)+);
++++assertTrue(++hasSignificantFigures(+++++0.0000999d,++3+)+);
++++assertFalse(+hasSignificantFigures(+++++0.00009999d,+3+)+);
++}

++@Test
++public+void+testPrecisionAndScale(){
++++assertTrue(++hasDigitsAtScale(+++++0d,++++++3,+0+)+);
++++assertFalse(+hasDigitsAtScale(+++++0.01d,+++3,+0+)+);
++++assertFalse(+hasDigitsAtScale(+++++0.1d,++++3,+0+)+);
++++assertTrue(++hasDigitsAtScale(+++++1d,++++++3,+0+)+);
++++assertTrue(++hasDigitsAtScale(++++10d,++++++3,+0+)+);
++++assertTrue(++hasDigitsAtScale(+++100d,++++++3,+0+)+);
++++assertFalse(+hasDigitsAtScale(++1000d,++++++3,+0+)+);
++++assertFalse(+hasDigitsAtScale(+10000d,++++++3,+0+)+);

++++assertTrue(++hasDigitsAtScale(+++++0d,++++++3,+1+)+);
++++assertFalse(+hasDigitsAtScale(+++++0.01d,+++3,+1+)+);
++++assertTrue(++hasDigitsAtScale(+++++0.1d,++++3,+1+)+);
++++assertTrue(++hasDigitsAtScale(+++++1d,++++++3,+1+)+);
++++assertTrue(++hasDigitsAtScale(++++10d,++++++3,+1+)+);
++++assertFalse(+hasDigitsAtScale(+++100d,++++++3,+1+)+);
++++assertFalse(+hasDigitsAtScale(++1000d,++++++3,+1+)+);
++++assertFalse(+hasDigitsAtScale(+10000d,++++++3,+1+)+);

++++assertTrue(++hasDigitsAtScale(+++++0d,++++++3,+-1+)+);
++++assertFalse(+hasDigitsAtScale(+++++0.01d,+++3,+-1+)+);
++++assertFalse(+hasDigitsAtScale(+++++0.1d,++++3,+-1+)+);
++++assertFalse(+hasDigitsAtScale(+++++1d,++++++3,+-1+)+);
++++assertTrue(++hasDigitsAtScale(++++10d,++++++3,+-1+)+);
++++assertTrue(++hasDigitsAtScale(+++100d,++++++3,+-1+)+);
++++assertTrue(++hasDigitsAtScale(++1000d,++++++3,+-1+)+);
++++assertFalse(+hasDigitsAtScale(+10000d,++++++3,+-1+)+);
++}
}|code-block|syntax|javascript|1045475|entityMap|0|LINK|mutability|MUTABLE|url|https://simple.wikipedia.org/wiki/Arithmetic_precision^0|3|B|0|0|0|0|1C|B|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|13|8|@]|9|@$A|14|B|15|1|16]]|C|$]]|$1|D|3|-4|5|6|7|17|8|@]|9|@]|C|$]]|$1|E|3|F|5|G|7|18|8|@]|9|@]|C|$]]|$1|H|3|I|5|G|7|19|8|@$A|1A|B|1B|J|K]]|9|@]|C|$]]|$1|L|3|-4|5|6|7|1C|8|@]|9|@]|C|$]]|$1|M|3|N|5|6|7|1D|8|@]|9|@]|C|$]]|$1|O|3|P|5|6|7|1E|8|@]|9|@]|C|$]]|$1|Q|3|R|5|S|7|1F|8|@]|9|@]|C|$T|U]]|$1|V|3|-4|5|6|7|1G|8|@]|9|@]|C|$]]]|W|$X|$5|Y|Z|10|C|$11|12]]]]

There are multiple possible interpretations of the term <a href="https://simple.wikipedia.org/wiki/Arithmetic_precision" rel="nofollow noreferrer">"precision"</a>:

<ul>
<li>The arithmetic precision is the total number of significant figures (before and after the decimal point).</li>
<li>The number of digits in the fractional part of the number (or the number of decimal places).</li>
<li>Particularly in databases, precision can be measured with a fixed number of decimal places (the scale) included in the count so a <code>NUMBER(6,2)</code> column would store numbers that have at most 6 digits which is always composed of 2 decimal places and 4 integer digits.</li>
</ul>

For your examples, you appear to be measuring precision as the maximum number of decimal places.

Each of these can be tested using:

<pre><code>import java.math.BigDecimal;

import org.junit.Test;
import static org.junit.Assert.*;


public class Precision
{
 /**
 * Tests to see whether the number has up to the given number of
 * decimal places.
 * 
 * @param value The value to test.
 * @param scale The maximum number of decimal places. 
 * @return &lt;code&gt;true&lt;/code&gt; if the value has up to the
 * expected number of decimal places.
 */
 static final boolean hasDecimalPlaces(
 final double value,
 final int scale
 )
 {
 try
 {
 new BigDecimal( Double.toString( value ) ).setScale( scale );
 return true;
 }
 catch ( final ArithmeticException ex )
 {
 return false;
 }
 }

 /**
 * Tests to see whether the number has up to the given number of
 * significant figures.
 * 
 * @param value The value to test.
 * @param precision The maximum number of significant figures to
 * test for.
 * @return &lt;code&gt;true&lt;/code&gt; if the value has up to the
 * expected number of significant figures. 
 */
 static final boolean hasSignificantFigures(
 final double value,
 final int precision
 )
 {
 try
 {
 return new BigDecimal( Double.toString( value ) ).stripTrailingZeros().precision() &lt;= precision;
 }
 catch ( final ArithmeticException ex )
 {
 return false;
 }
 }

 /**
 * Tests to see whether the number has at most the given number of
 * decimal places and, when represented at that maximum number of
 * decimal places, has up to the given number of digits.
 * 
 * @param value The number to test.
 * @param precision The maximum number of digits to test for.
 * @param scale The maximum number of decimal places.
 * @return &lt;code&gt;true&lt;/code&gt; if the value can be represented
 * at the given scale and, at that scale, is up to
 * the given precision.
 */
 static final boolean hasDigitsAtScale(
 final double value,
 final int precision,
 final int scale
 )
 {
 try
 {
 return new BigDecimal( Double.toString( value ) ).setScale( scale ).precision() &lt;= precision;
 }
 catch ( final ArithmeticException ex )
 {
 return false;
 }
 }

 @Test
 public void testScale(){
 assertTrue( hasDecimalPlaces( 20d, 3 ) );
 assertTrue( hasDecimalPlaces( 20.123d, 3 ) );
 assertFalse( hasDecimalPlaces( 20.1234d, 3 ) );
 }

 @Test
 public void testPrecision(){
 assertTrue( hasSignificantFigures( 20d, 3 ) );
 assertTrue( hasSignificantFigures( 120d, 3 ) );
 assertTrue( hasSignificantFigures( 1230d, 3 ) );
 assertFalse( hasSignificantFigures( 12340d, 3 ) );
 assertTrue( hasSignificantFigures( 20.1d, 3 ) );
 assertFalse( hasSignificantFigures( 20.12d, 3 ) );
 assertTrue( hasSignificantFigures( 0.123d, 3 ) );
 assertFalse( hasSignificantFigures( 0.1234d, 3 ) );
 assertTrue( hasSignificantFigures( 0.0000999d, 3 ) );
 assertFalse( hasSignificantFigures( 0.00009999d, 3 ) );
 }

 @Test
 public void testPrecisionAndScale(){
 assertTrue( hasDigitsAtScale( 0d, 3, 0 ) );
 assertFalse( hasDigitsAtScale( 0.01d, 3, 0 ) );
 assertFalse( hasDigitsAtScale( 0.1d, 3, 0 ) );
 assertTrue( hasDigitsAtScale( 1d, 3, 0 ) );
 assertTrue( hasDigitsAtScale( 10d, 3, 0 ) );
 assertTrue( hasDigitsAtScale( 100d, 3, 0 ) );
 assertFalse( hasDigitsAtScale( 1000d, 3, 0 ) );
 assertFalse( hasDigitsAtScale( 10000d, 3, 0 ) );

 assertTrue( hasDigitsAtScale( 0d, 3, 1 ) );
 assertFalse( hasDigitsAtScale( 0.01d, 3, 1 ) );
 assertTrue( hasDigitsAtScale( 0.1d, 3, 1 ) );
 assertTrue( hasDigitsAtScale( 1d, 3, 1 ) );
 assertTrue( hasDigitsAtScale( 10d, 3, 1 ) );
 assertFalse( hasDigitsAtScale( 100d, 3, 1 ) );
 assertFalse( hasDigitsAtScale( 1000d, 3, 1 ) );
 assertFalse( hasDigitsAtScale( 10000d, 3, 1 ) );

 assertTrue( hasDigitsAtScale( 0d, 3, -1 ) );
 assertFalse( hasDigitsAtScale( 0.01d, 3, -1 ) );
 assertFalse( hasDigitsAtScale( 0.1d, 3, -1 ) );
 assertFalse( hasDigitsAtScale( 1d, 3, -1 ) );
 assertTrue( hasDigitsAtScale( 10d, 3, -1 ) );
 assertTrue( hasDigitsAtScale( 100d, 3, -1 ) );
 assertTrue( hasDigitsAtScale( 1000d, 3, -1 ) );
 assertFalse( hasDigitsAtScale( 10000d, 3, -1 ) );
 }
}
</code></pre>

I would like to test a double for a maximum percision of 3 or less. What is the best way to do this in Java?

<pre><code>20.44567567 &lt;- Fail
20.444 &lt;- Pass
20.1 &lt;- Pass
20 &lt;- Pass
</code></pre>

Test Number For Maximum Precision In Java

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我想测试最大精度为3或更低的双精度。在Java中实现这一点的最佳方法是什么？20.44567567 <- Fail20.444 <- Pass20.1 <- Pass20 <- Pass

问Java中最大精度的测试号
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java中最大精度的测试号EN