Double.ToString 方法 (String)

最新推荐文章于 2025-02-12 18:13:55 发布
最新推荐文章于 2025-02-12 18:13:55 发布
阅读量6.4k 收藏
点赞数
分类专栏： CSharp 
double[] numbers= {1054.32179, -195489100.8377, 1.0437E21, 
                   -1.0573e-05};
string[] specifiers = { "C", "E", "e", "F", "G", "N", "P", 
                        "R", "#,000.000", "0.###E-000",
                        "000,000,000,000.00###" };
foreach (double number in numbers)
{
   Console.WriteLine("Formatting of {0}:", number);
   foreach (string specifier in specifiers) {
      Console.WriteLine("   {0,-22} {1}", 
                        specifier + ":", number.ToString(specifier));
      // Add precision specifiers from 0 to 3.
      if (specifier.Length == 1 & ! specifier.Equals("R")) {
         for (int precision = 0; precision <= 3; precision++) {
            string pSpecifier = String.Format("{0}{1}", specifier, precision);
            Console.WriteLine("   {0,-22} {1}", 
                              pSpecifier + ":", number.ToString(pSpecifier));
         }    
         Console.WriteLine();
      }   
   }
   Console.WriteLine();
}
// The example displays the following output to the console:
//       Formatting of 1054.32179:
//          C:                     $1,054.32
//          C0:                    $1,054
//          C1:                    $1,054.3
//          C2:                    $1,054.32
//          C3:                    $1,054.322
//       
//          E:                     1.054322E+003
//          E0:                    1E+003
//          E1:                    1.1E+003
//          E2:                    1.05E+003
//          E3:                    1.054E+003
//       
//          e:                     1.054322e+003
//          e0:                    1e+003
//          e1:                    1.1e+003
//          e2:                    1.05e+003
//          e3:                    1.054e+003
//       
//          F:                     1054.32
//          F0:                    1054
//          F1:                    1054.3
//          F2:                    1054.32
//          F3:                    1054.322
//       
//          G:                     1054.32179
//          G0:                    1054.32179
//          G1:                    1E+03
//          G2:                    1.1E+03
//          G3:                    1.05E+03
//       
//          N:                     1,054.32
//          N0:                    1,054
//          N1:                    1,054.3
//          N2:                    1,054.32
//          N3:                    1,054.322
//       
//          P:                     105,432.18 %
//          P0:                    105,432 %
//          P1:                    105,432.2 %
//          P2:                    105,432.18 %
//          P3:                    105,432.179 %
//       
//          R:                     1054.32179
//          #,000.000:             1,054.322
//          0.###E-000:            1.054E003
//          000,000,000,000.00###: 000,000,001,054.32179
//       
//       Formatting of -195489100.8377:
//          C:                     ($195,489,100.84)
//          C0:                    ($195,489,101)
//          C1:                    ($195,489,100.8)
//          C2:                    ($195,489,100.84)
//          C3:                    ($195,489,100.838)
//       
//          E:                     -1.954891E+008
//          E0:                    -2E+008
//          E1:                    -2.0E+008
//          E2:                    -1.95E+008
//          E3:                    -1.955E+008
//       
//          e:                     -1.954891e+008
//          e0:                    -2e+008
//          e1:                    -2.0e+008
//          e2:                    -1.95e+008
//          e3:                    -1.955e+008
//       
//          F:                     -195489100.84
//          F0:                    -195489101
//          F1:                    -195489100.8
//          F2:                    -195489100.84
//          F3:                    -195489100.838
//       
//          G:                     -195489100.8377
//          G0:                    -195489100.8377
//          G1:                    -2E+08
//          G2:                    -2E+08
//          G3:                    -1.95E+08
//       
//          N:                     -195,489,100.84
//          N0:                    -195,489,101
//          N1:                    -195,489,100.8
//          N2:                    -195,489,100.84
//          N3:                    -195,489,100.838
//       
//          P:                     -19,548,910,083.77 %
//          P0:                    -19,548,910,084 %
//          P1:                    -19,548,910,083.8 %
//          P2:                    -19,548,910,083.77 %
//          P3:                    -19,548,910,083.770 %
//       
//          R:                     -195489100.8377
//          #,000.000:             -195,489,100.838
//          0.###E-000:            -1.955E008
//          000,000,000,000.00###: -000,195,489,100.8377
//       
//       Formatting of 1.0437E+21:
//          C:                     $1,043,700,000,000,000,000,000.00
//          C0:                    $1,043,700,000,000,000,000,000
//          C1:                    $1,043,700,000,000,000,000,000.0
//          C2:                    $1,043,700,000,000,000,000,000.00
//          C3:                    $1,043,700,000,000,000,000,000.000
//       
//          E:                     1.043700E+021
//          E0:                    1E+021
//          E1:                    1.0E+021
//          E2:                    1.04E+021
//          E3:                    1.044E+021
//       
//          e:                     1.043700e+021
//          e0:                    1e+021
//          e1:                    1.0e+021
//          e2:                    1.04e+021
//          e3:                    1.044e+021
//       
//          F:                     1043700000000000000000.00
//          F0:                    1043700000000000000000
//          F1:                    1043700000000000000000.0
//          F2:                    1043700000000000000000.00
//          F3:                    1043700000000000000000.000
//       
//          G:                     1.0437E+21
//          G0:                    1.0437E+21
//          G1:                    1E+21
//          G2:                    1E+21
//          G3:                    1.04E+21
//       
//          N:                     1,043,700,000,000,000,000,000.00
//          N0:                    1,043,700,000,000,000,000,000
//          N1:                    1,043,700,000,000,000,000,000.0
//          N2:                    1,043,700,000,000,000,000,000.00
//          N3:                    1,043,700,000,000,000,000,000.000
//       
//          P:                     104,370,000,000,000,000,000,000.00 %
//          P0:                    104,370,000,000,000,000,000,000 %
//          P1:                    104,370,000,000,000,000,000,000.0 %
//          P2:                    104,370,000,000,000,000,000,000.00 %
//          P3:                    104,370,000,000,000,000,000,000.000 %
//       
//          R:                     1.0437E+21
//          #,000.000:             1,043,700,000,000,000,000,000.000
//          0.###E-000:            1.044E021
//          000,000,000,000.00###: 1,043,700,000,000,000,000,000.00
//       
//       Formatting of -1.0573E-05:
//          C:                     $0.00
//          C0:                    $0
//          C1:                    $0.0
//          C2:                    $0.00
//          C3:                    $0.000
//       
//          E:                     -1.057300E-005
//          E0:                    -1E-005
//          E1:                    -1.1E-005
//          E2:                    -1.06E-005
//          E3:                    -1.057E-005
//       
//          e:                     -1.057300e-005
//          e0:                    -1e-005
//          e1:                    -1.1e-005
//          e2:                    -1.06e-005
//          e3:                    -1.057e-005
//       
//          F:                     0.00
//          F0:                    0
//          F1:                    0.0
//          F2:                    0.00
//          F3:                    0.000
//       
//          G:                     -1.0573E-05
//          G0:                    -1.0573E-05
//          G1:                    -1E-05
//          G2:                    -1.1E-05
//          G3:                    -1.06E-05
//       
//          N:                     0.00
//          N0:                    0
//          N1:                    0.0
//          N2:                    0.00
//          N3:                    0.000
//       
//          P:                     0.00 %
//          P0:                    0 %
//          P1:                    0.0 %
//          P2:                    0.00 %
//          P3:                    -0.001 %
//       
//          R:                     -1.0573E-05
//          #,000.000:             000.000
//          0.###E-000:            -1.057E-005
//          000,000,000,000.00###: -000,000,000,000.00001


Java Double类toString（）方法与示例
cumubi7552的博客
07-11 5019
Syntax: 句法： public String toString(); public static String toString(double value); 双类toString()方法 (Double class toString() method) toString() method is available in java.lang package. to...
C#用double.TryParse(String, Double)方法将字符串类型数字转换为数值类型
wenchm的博客
01-15 2218
将数字的字符串表示形式转换为它的等效双精度浮点数。一个指示转换是否成功的返回值。参数描述double双精度数值s用于转换为数值的字符串out使用out关键字，会将参数通过引用来传递。要注意，如果使用out关键字传递参数，那么此参数在传递前不可以被初始化result如果转换成功，result将得到转换后的数值使用TryParse方法可以有效防止数值转换中的异常。
double to string
12-09
double to string double to string
Double.toString()原理
snakeflash的博客
04-10 425
double toString方法解析
Double.ToString() 输出格式
Mike_detailing的博客
07-17 1137
double value = 12763.53634; //显示指定有效位数(四舍五入） Console.WriteLine(value.ToString("G")); Console.WriteLine(value.ToString("G01")); Console.WriteLine(value.ToString("G02")); Console.WriteL...
代码浮点类型 Double.ToString("格式")直接转换
suxuelian的博客
01-29 8658
在日常开发中，经常会遇到浮点数的小数点截取、百分比转换等。之前都是自己写方法截取或写方法算出百分比，其实所有浮点数，如double、decimal,都能快捷转换。 例如： double value = 1054.32179; string text = value.ToString("F2"); 输入结果：1054.32 以下是输入不同类型，输出不一样的值。 ...
C#-String.ToString()用法
IT技术猿猴的博客
09-12 5435
常用格式举例： （1） int i=12345; this.textBox1.Text=i.ToString(); //结果 12345（this指当前对象，或叫当前类的实例） this.textBox2.Text=i.ToString(“d8”); //结果 00012345 （2） int i=123; double j=123.45; string s1=string.Format(“th...
Java中区别.toString() ,(String),valueOf()方法
08-31
在Java编程语言中，将对象转换为字符串是一个常见的操作，主要涉及到`toString()`、`(String)`类型转换以及`String.valueOf()`这三个方法。了解它们的区别和使用场景对于编写高质量的Java代码至关重要。 首先，`...
C# .ToString() 格式化
刘欢的博客
07-05 1185
c# ToString() 格式化字符串 格式化数值：有时，我们可能需要将数值以一定的格式来呈现，就需要对数值进行格式化。我们使用格式字符串指定格式。格式字符串采用以下形式：Axx，其中 A 为格式说明符，指定格式化类型，xx 为精度说明符，控制格式化输出的有效位数或小数位数。 格式说明符 说明 示例 输出 C 货币 2.5.ToString("C") ￥2.50 D 十进制数 25.ToString("D5") 00025 E 科学型 25000.ToString("E") 2.50000...
C# .net DateTime.Now.ToString() 年月日时分秒格式化大全
秋̶᭄ꦿ攻城狮࿆ྂ
11-05 1万+
C# .net 年月日时分秒格式化 yyyy-MM-dd HH：mm：ss：ffff yyyy年MM月dd HH时mm分ss秒 new string[]{ "星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六" }; ToShortDateString
java double.tostring_Java Double类toString()方法与示例
weixin_39646970的博客
02-16 2374
语法：publicStringtoString();publicstaticStringtoString(doublevalue);Double类toString()法toString()方法在java.lang包中可用。toString()方法用于获取Double value / object的字符串值(通过“ this”对象调用)。toString(double value)方法也...
【C#】double.ToString() 的用法
风语留痕
09-17 4668
C# 中 double 类型的数据，有时需要格式化显示为字符串（保留N位有效数字或者是保留N位小数），可以使用 double.ToString("参数") 方法。
java浅见 String.valueOf(Double) 和 Double.toString()的区别
ahauedu的专栏
02-12 415
值处理和性能上有所不同。返回的是 Double。
三个double TO string对比
exedllnet的专栏
08-01 546
double amount11 =121145634541535.0; BigDecimal bigDecimal = new BigDecimal(amount11); BigDecimal db = bigDecimal.setScale(2, BigDecimal.ROUND_HALF_UP); String str = db.toPlainString(); Locale loca
Android开发：double，float转String类型
weixin_64061910的博客
08-27 467
formatOneDouble方法中可以选择转换方式，当数值小数点后全为0是，仅保留一位小数，例如：1.00000则转换为1.0，当全都不为0时，可以根据实际需求选择保留位数。
Java Double toString()方法具有什么功能呢？
qq_25073223的博客
09-11 420
Java Double toString()方法的功能简介说明
C#日期函数所有样式大全
每天进步一点点
01-18 1226
C#日期函数所有样式大全(转载)DateTime dt = DateTime.Now;//   Label1.Text = dt.ToString();//2005-11-5 13:21:25//   Label2.Text = dt.ToFileTime().ToString();//127756416859912816//   Label3.Text = dt.ToFileTimeUtc(
C#.NET中的ToString()数字格式化
weixin_30448685的博客
07-11 528
数字格式字符串-----货币-----.ToString("C");.ToString("c");例 2.5.ToString("c") -> ￥2.50-----十进制-----.ToString("D");.ToString("d");例 123.ToString("d8") -> 00000123-----科学记数-----.ToString("E");.ToString("e"...
C# 中“.ToString()”方法的使用规则
热门推荐
weixin_42744551的博客
09-21 1万+
tostring()方法的使用
Double.toString的坑
最新发布
03-22
<think>嗯，用户想了解Java中Double类的toString方法可能出现的问题及解决办法。首先，我需要回忆一下相关的知识点。记得Double类型在Java中有时会有精度问题，因为浮点数的二进制表示可能无法精确对应十进制小数。toString方法可能会截断或者四舍五入，导致输出不符合预期。比如，0.1在double中其实是近似值，所以转换成字符串的时候可能会有很多小数位。 然后，用户提到的引用里提到了BigDecimal的使用，特别是用String构造BigDecimal来避免精度丢失。这可能和解决toString的问题有关。另外，引用2提到Double.toString会使用一定的精度四舍五入，这可能造成显示上的误差。比如，实际存储的值和显示的值可能不同，比如0.1可能变成0.1000000000000001之类的。 接下来，我需要整理常见的问题。第一个问题可能是精度丢失，比如像0.1这样的数转换成字符串后出现很多小数位。第二个可能是科学计数法的显示问题，比如很小的数或很大的数会被转换成科学计数法，如1.234E-4，这可能不符合用户的显示需求。第三个可能是四舍五入导致的误差，比如实际存储的值和toString后的结果不一致，导致比较时出错。例如，两个看似相同的数因为精度问题被toString成不同的字符串。 解决方案方面，引用4建议使用BigDecimal的String构造方法，这样可以避免double到BigDecimal的转换误差。另外，使用DecimalFormat来格式化输出，控制小数位数，避免科学计数法。比如设置格式为0.0000可以强制显示四位小数。还有一种方法是直接处理字符串，比如手动去除末尾的零或者检查是否有科学计数法，然后转换成普通小数形式。 另外，用户提供的引用5提到了递归的使用，这可能和问题无关，但其他引用如引用3提到了将字符串转换为double时的问题，比如使用Double.parseDouble可能会引入精度问题，这时候用BigDecimal来解析字符串会更可靠。 总结一下，用户需要知道Double.toString的常见问题，如精度丢失、科学计数法显示、四舍五入误差，以及对应的解决方法，比如用BigDecimal、DecimalFormat或者字符串处理。还需要注意在比较或运算时使用BigDecimal来避免精度问题，而不是直接使用double类型。</think>### Java中Double类的toString方法常见问题及解决方案 #### 1. **精度丢失问题** **问题现象** 当使用`Double.toString()`方法时，由于`double`类型的二进制浮点数无法精确表示某些十进制小数（如$0.1$），转换后的字符串可能包含多余的精度位数。例如： ```java double d = 0.1; System.out.println(Double.toString(d)); // 输出可能为"0.1000000000000001" ``` 这是因为`double`的二进制表示无法精确存储十进制小数，导致转换时出现误差[^2][^4]。 **解决方案** - **使用`BigDecimal`替代**：通过`BigDecimal`的字符串构造方法避免精度丢失： ```java BigDecimal bd = new BigDecimal("0.1"); System.out.println(bd.toString()); // 输出"0.1" ``` - **指定格式化规则**：使用`DecimalFormat`控制输出精度： ```java DecimalFormat df = new DecimalFormat("0.0000"); System.out.println(df.format(d)); // 输出"0.1000" ``` #### 2. **科学计数法显示问题** **问题现象** 对于极大或极小的数值（如$1.234 \times 10^{-4}$），`Double.toString()`可能返回科学计数法形式的字符串（如`1.234E-4`），而非预期的十进制表示[^2]。 **解决方案** - **强制十进制显示**：使用`String.format`或`DecimalFormat`禁用科学计数法： ```java double d = 0.0001234; System.out.println(String.format("%.10f", d)); // 输出"0.0001234000" ``` - **手动处理字符串**：检查是否包含`E`符号，并转换为普通十进制格式。 #### 3. **四舍五入导致的误差** **问题现象** `Double.toString()`会对数值进行四舍五入（例如，保留15位有效数字），可能导致最终字符串与实际存储值存在差异： ```java double d = 12345.67890123456789; System.out.println(Double.toString(d)); // 可能输出"12345.678901234568" ``` **解决方案** - **使用更高精度的类型**：直接使用`BigDecimal`进行运算和转换，避免`double`的精度限制[^4]。 - **自定义精度处理**：根据需求截断或保留特定小数位数： ```java BigDecimal bd = new BigDecimal(Double.toString(d)).setScale(6, RoundingMode.HALF_UP); System.out.println(bd); // 输出"12345.678901" ``` #### 4. **字符串比较问题** **问题现象** 由于精度丢失或科学计数法，转换后的字符串可能无法直接用于比较： ```java double d1 = 0.1 + 0.2; double d2 = 0.3; System.out.println(Double.toString(d1).equals(Double.toString(d2))); // 输出false ``` **解决方案** - **数值比较代替字符串比较**：使用`BigDecimal`的`compareTo`方法： ```java BigDecimal bd1 = new BigDecimal(Double.toString(d1)); BigDecimal bd2 = new BigDecimal(Double.toString(d2)); System.out.println(bd1.compareTo(bd2) == 0); // 输出true ``` #### 总结建议 1. **优先使用`BigDecimal`**：在需要精确表示十进制数值时，通过`String`构造`BigDecimal`对象。 2. **控制显示格式**：使用`DecimalFormat`或`String.format`避免科学计数法和多余精度。 3. **避免直接字符串比较**：通过数值计算或`BigDecimal`进行值比较。 ---
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值