Double.ToString 方法 (String)

2023-05-16

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

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

double

toString

string

Double.ToString 方法 (String) 的相关文章

如何反转字符串中的单词但将标点符号保留在正确的位置？ [复制]

这个问题在这里已经有答案了我编写了以下代码来反转输入字符串 Scanner s new Scanner System in System out println Please enter a sentence String sentenc
ToUpperInvariant() – MSDN 的建议是否错误？

In 在 NET Framework 中使用字符串的最佳实践 https msdn microsoft com en us library dd465121 v vs 110 aspx 字符串比较OrdinalIgnoreCase http
如何在 C++ 中对静态缓冲区执行字符串格式化？

我正在处理一段对性能要求非常高的代码我需要执行一些格式化的字符串操作但我试图避免内存分配甚至是内部库的内存分配在过去我会做类似以下的事情假设是 C 11 constexpr int BUFFER SIZE 200 char bu
如何用C++解析复杂的字符串？

我试图弄清楚如何使用解析这个字符串sstream 和C 其格式为 string int int 我需要能够将包含 IP 地址的字符串的第一部分分配给 std string 以下是该字符串的示例 std string 127 0 0 1 1
将小数格式化为两位或整数

对于 10 我想要 10 而不是 10 00 对于 10 11 我想要 10 11 没有代码可以实现吗即通过指定格式字符串类似于 0 N2 decimal num 10 11M Console WriteLine num ToString
string.split("(?!^)") 解释

我正在尝试将字符串的字符拆分为字符串数组我找到了解决方案here https stackoverflow com questions 5235401 split string into array of character strings
Java中如何对对象数组进行排序？

我的数组不包含任何字符串但它包含对象引用每个对象引用都通过 toString 方法返回名称 id 作者和发布者 public String toString return name n id n author n publisher n
这个看不见的空间是如何创造出来的？

FileTitle FileTitle false 第一个字符串和最后一个字符串之间有一个空格e and FileTitle length 12 FileTitle length 11 这两个字符之间存在代码为 8203 的 Unicode
反转java String.split()效果的方法？ [复制]

这个问题在这里已经有答案了我正在寻找一种将字符串数组组合成分隔符的方法细绳与 split 相反在我尝试自己编写之前想询问一下论坛因为 JDK 拥有一切据我所知 JDK 中没有任何方法可以实现这一点阿帕奇公共语言 http co
如何从Python列表中的字符串中删除双引号？

我正在尝试在字典列表中获取一些数据数据来自 csv 文件因此都是字符串文件中的键都有双引号但由于这些都是字符串我想删除它们这样它们在字典中看起来像这样 key value 而不是这个 key value 我尝试简单地使用 str
如何快速防止标签中出现孤儿？

我有一个可以有一两行的标签如果它有两行我希望第二行至少有两个或者可能三个单词而不仅仅是一个关于如何使用 swift 实现这一点有什么想法吗提前致谢 Daniel 编辑我删除了我愚蠢的第一个想法这些想法并没有真正的帮助好吧
R：根据元素长度从向量中删除元素

如何根据字符串的字符数或长度从字符串向量中删除元素 df lt c asdf fweafewwf af aewfawefwef awefWEfawefawef gt df 1 asdf fweafewwf af aewfawefwef aw
如何成功地用 XML 中的批处理替换文本

我尝试使用批处理在 XML 页面中替换字符串但无法成功完全替换它我有这个批处理代码 echo off setlocal EnableDelayedExpansion set search logLevel 3 set replace l
toUpperCase() 方法什么时候创建一个新对象？

public class Child public static void main String args String x new String ABC String y x toUpperCase System out println
char 数组声明中字符串文字周围的大括号有效吗？（例如 char s[] = {"Hello World"}）

偶然间我发现这条线char s Hello World 已正确编译并且似乎被视为相同char s Hello World 不是第一个 Hello World 一个包含一个 char 数组元素的数组因此 s 的声明应为char s 事实上如
将字符串连接到python列表中所有元素的末尾

我想知道如何将字符串连接到列表中所有元素的末尾例如 List1 1 2 3 string a output 1a 2a 3a 在列表理解和使用中重建列表str format在两个参数上 gt gt gt string a gt gt gt
C# 转换为小数

如果有的话有什么区别 decimal d decimal myDouble decimal d new decimal myDouble decimal d Convert ToDecimal myDouble 没有区别如果你看一下源码
如何在 R 中将字符串解析为层次结构或树

有没有办法将表示组的字符串解析为 R 中的层次结构假设我的小组结构如下 1 1 1 1 1 1 1 1 1 1 1 1 2 1 1 3 1 1 3 1 1 1 3 2 1 1 3 3 1 2 1 2 1 1 2 1 1 1 2 1 2 1
如何检测 Java 字符串中的 unicode 字符？

假设我有一个包含的字符串我如何找到所有这些 un icode 字符我应该测试他们的代码吗我该怎么做呢例如给定字符串 A X 我想将其转换为 AYXY 我想对其他 unicode 字符做同样的事情并且我不想将它们存储在某种翻译映
字符串列表，获取n个元素的公共子串，Python

我的问题可能类似于this https stackoverflow com questions 37514193 count the number of occurrences of n length not given string in

随机推荐

如何释放linux的内存

你们知道怎么释放linux的内存吗不知道的话跟着学习啦小编一起来学习怎么释放linux的内存释放linux的内存的步骤 Linux下操作频繁时 xff0c 物理内存会被快速用完 xff0c 当操作结束后 xff0c 物理内存没有被正常的释
跨域的五种解决方案详解

1 跨域解决方案一 cors技术 CORS 全称cross origin resource share xff08 资源共享 xff09 工作原理 xff1a 服务器在返回响应报文的时候 xff0c 在响应头中设置一个允许的header
MySQL 日期时间类型精确到毫秒

MySQL 常用的日期时间类型常用的是datetime timestamp 其中datetime占用5个字节 xff08 有些文档中说占用8个字节是不对的 xff0c 默认也不会保存毫秒 xff09 DATETIME和TIMESTAMP两种
Spring Boot——Thymeleaf

哈喽 xff01 大家好 xff0c 我是 xff0c 一位上进心十足的 Java领域博主 xff01 的写作风格 xff1a 喜欢用通俗易懂的文笔去讲解每一个知识点 xff0c 而不喜欢用高大上的官方陈述博客的领域是面向后端技
[BZOJ3185][Coci2011][DP]kamion

考虑转化一下问题令 f i j k 表示从i到j恰好用了k步 xff0c 并且到j的时候火车厢为空的方案数那么转移就是 f i j k 61 f a b k 1 f c j k 2 xff0c 转移成立当且仅当存在i gt a的边 xf
查看docker 容器的端口

查看docker 容器的端口 sudo netstat tulpn grep docker 查看指定端口 xff0c 可以结合grep命令 xff1a netstat ap grep 80 查找指定端口使用的pid fuser 80 tcp
Docker服务的停止命令(systemctl stop docker)

停止Docker服务停止docker服务 systemctl stop docker 非root用户使用停止docker服务 sudo systemctl stop docker
Docker查找镜像版本的命令

Docker查找镜像版本的命令有时候想查一下镜像有哪些版本 xff0c 因为有墙 xff0c 官网一直在转圈进不去 xff0c 这时候就可以使用命令查询了 xff0c 以centos为例 xff0c 自己想要哪个更改一下命令就可以了 do
ES6 如何将 Set 转化为数组

例如 xff1a const mySet 61 new Set Set 对象具有以下特征 xff1a Set 实例的成员唯一 xff0c 不会重复 Set 实例可以存储任何类型的值 xff0c 包括基本类型和对象 Set 实例是可迭代的 x
Request.url用法

網址 xff1a http localhost 1897 News Press Content aspx 123 id 61 1 toc Request ApplicationPath Request PhysicalPath D Proj
oracle IO 优化

数据库的作用就是实现对数据的管理和查询任何一个数据库系统 xff0c 必然存在对数据的大量读或者写或者两中操作都大量存在 IO问题也往往是导致数据库性能问题的重要原因在这篇文章中 xff0c 主要帮助大家在理解Oracle的读写操作机制
oracle中imp命令详解

oracle中imp命令详解 Oracle的导入实用程序 Import utility 允许从数据库提取数据 xff0c 并且将数据写入操作系统文件 imp使用的基本格式 xff1a imp username password 64 se
C# 非顶端窗口截图

panel上可以通过DrawToBitmap截图 xff0c 不管是否在屏幕外是否有遮挡 Bitmap sourceBitmap 61 new Bitmap 400 300 Control ct 61 frmMain mianForm pa
bat中的特殊字符，以及需要在bat中当做字符如何处理

bat中的特殊字符 xff0c 以及需要在bat中当做字符如何处理批处理 Bat 中特殊符号的实际作用 xff0c Windows 批处理中特殊符号的作用 xff1a 64 隐藏命令的回显在for中表示使用增强的变量扩展 xff1b 在
rviz无法显示的问题

1 启用初始化配置首先删除保存好的rviz xff0c 运行最初始化的配置 rviz运行后会选择保存在 home cbc rviz default rviz 删除之后 xff0c 重新运行 xff1a roscore rosrun rvi
用C语言编写一个HTTP协议的目录浏览和文件下载服务器

include lt stdarg h gt include lt errno h gt include lt stdio h gt include lt fcntl h gt include lt unistd h gt include
编写浏览器使用的OCX全过程

随着互联网的飞速发展现在的人们都习惯了打开浏览器进行工作基于WEB的程序蜂拥而至几乎变得无所不能由于WEB脚本语言的限制 xff0c 对于本地计算机的访问受到很大的限制开发WEB的程序员都会因为WEB的打印而烦恼 xff0c 对于
Linux平台下启动oracle 11g EM控制台

当我们的oracle服务器是使用的Linux Unix系统时我们从windows或者其他的客户端想用启动oracle的EM工具了解一些系统系统信息时可以采用如下方式首先在服务器端打开一个窗口输入如下命令 emctl start or
Oracle日常性能查看

判断回滚段竞争的SQL语句 xff1a xff08 当Ratio大于2时存在回滚段竞争 xff0c 需要增加更多的回滚段 xff09 select rn name rs GETS rs WAITS rs WAITS rs GETS 100
Double.ToString 方法 (String)

double numbers 61 1054 32179 195489100 8377 1 0437E21 1 0573e 05 string specifiers 61 34 C 34 34 E 34 34 e 34 34 F 34 34

Double.ToString 方法 (String)

Double.ToString 方法 (String) 的相关文章

随机推荐

热门标签