string

在实际的开发过程中，对字符串的操作是经常遇到的，其中涉及到字符串拼接、拆分、比较、替换等操作。C#提供了string类型，String和 StringBuilder两种类来对字符串进行处理。那么string，String，StringBuilder对字符串进行处理有何异同，在实际编程中，对于不同的字符串操作应该采用哪种方式来提高程序的效率呢?本文将对string，String，StringBuilder进行详细的解释和比较，最后在编程过程中遇到的常用的字符串处理进行了总结。

　　首先理解string，String，StringBuilder的概念和区别：

　　string

　　string，msdn给出的解释就是，string 是C#中的关键字，并且是引用类型， string 类型表示零或更多 Unicode 字符组成的序列。string 是 .NET Framework 中 String 的别名。但定义相等运算符(== 和 !=)是为了比较 string 对象(而不是引用)的值(后面给出示例解释这点)。

　　String：

　　String是类，表示文本，即一系列 Unicode 字符。String 对象是不可改变的。每次使用 System.String 类中的方法之一时，都要在内存中创建一个新的字符串对象，这就需要为该新对象分配新的空间。如：当我们实例化一个String的对象后，在内存中为此对象分配一个空间。如下：String str = “hello”;当我们修改str的值的时候，如：str = “hello world”;此时，系统会为str重新分配一个空间。这样原来的内存空间就被浪费掉了，只能等待垃圾回收器回收。在需要对字符串执行重复修改的情况下，与创建新的 String对象相关的系统开销可能会非常昂贵。

　　String与string的区别：

　　string 是 .NET Framework 中 String 的别名，string是C#基元类型(primitive)，简单来说就是编译器直接支持的数据类型。基元类型要直接映射到Framework类库 (FCL)中的类型，例如，C#中一个基元类型int直接映射到System.Int32类型，这里int是基元类型，System.Int32是FCL 类型。而String是FCL类型的，所以在C#的编译时，会自动的把string转化为System.String。所以string与String实质上没什么区别，只是在使用string要做一次转换，转换为String。因此，在编码时我们推荐使用String。

　　string虽然为引用类型，但是(== 和 !=)是为了比较 string 对象(而不是引用)的值。

　　如：

　string a ="hello";
　　string b ="hel";
　　b = b +"lo";
　　string c ="hello";
　　Response.Write(a==b); //True
　　Response.Write((object)a == (object)b); //False
　　Response.Write((object)a == (object)c); //True

　　　a==b比较的是值而非引用。所以a==b为True。当创建多个字符串内容相同的对象时，都只会指向同一个引用; a和c都指向同一个a的引用,并不会为c重新分配内存;这样即可保证内存有效利用;所以上面的(object)a == (object)c比较的是a与c的引用，结果为True。这里面b由于进行了累加操作(b = b + "lo";)b又重新分配了内存，所以(object)a == (object)b比较的是引用，所以为False。

　　接下来我们再通过几个例子来理解下String(string)

　String str1 ="abc";
　　String str2 = str1;
　　str1 = "123";
　　Response.Write(str2);//abc

　　输出结果是abc，首先给str赋值为"abc"，接着执行str2 = str1，使str2和str1指向同一引用，即内存地址。当执行str1 = "123"后，String对象是不可改变的，实质上str1 = "123"是str1=new string("123")的简写，它的每一次赋值都会抛掉原来的对象而生成一个新的字符串对象，分配新的内存空间，str1 = "123"语句编译器私底下创建了一个新的字符串对象来保存新的字符序列"123"，也就是此str1已非彼str1了。因此str1的值的改变也就不能影响先前str1指向地址的值了，当然str2的值也就不会改变了。因此string是不可改变的。

　　通过上面的例子，如果我们执行下面这些语句：

String sql = “Select * From T_Test ”;
　　sql += “Where id=888 ”;
sql += “And type=3 ”;
　　sql += “Order By Desc”;

　　实际上这样是十分浪费内存空间的。如果是频繁的这样做的话，建议是使用StringBuilder对象，或者这样写：String sql = “Select * From T_Test” + “Where id=888 ” + “And type=3” + “Order By Desc ” ;

　　StringBuilder:

　　出于性能方面的考虑，大量的串联或所涉及其他字符串操作应通过StringBuilder类来执行。StringBuilder表示可变字符字符串, 它允许我们有效的对字符串的字符执行动态操作，有效的缩减字符串的大小或者更改字符串中的字符。如果字符串变大，超过已经分配的字符的大小，StringBuilder就会自动的分配一个全新的、更大的数组，并开始使用新的数组，虽然 StringBuilder 对象是动态对象，允许扩充它所封装的字符串中字符的数量，但是您可以为它可容纳的最大字符数指定一个值。此值称为该对象的容量，不应将它与当前 StringBuilder 对象容纳的字符串长度混淆在一起。例如，可以创建 StringBuilder 类的带有字符串“Hello”(长度为 5)的一个新实例，同时可以指定该对象的最大容量为 25。当修改 StringBuilder 时，在达到容量之前，它不会为其自己重新分配空间。当达到容量时，将自动分配新的空间且容量翻倍。可以使用重载的构造函数之一来指定 StringBuilder 类的容量。

　　String 或 StringBuilder 对象的串联操作的性能取决于内存分配的发生频率。String 串联操作每次都分配内存，而 StringBuilder 串联操作仅当 StringBuilder 对象缓冲区太小而无法容纳新数据时才分配内存。因此，如果串联固定数量的 String 对象，则 String 类更适合串联操作。这种情况下，编译器甚至会将各个串联操作组合到一个操作中。如果串联任意数量的字符串，则 StringBuilder 对象更适合串联操作;例如，某个循环对用户输入的任意数量的字符串进行串联。

C#中判断空字符串

　　首先明确””，null和string.Empty的区别：

　　string.Empty：不分配存储空间。

　　""：分配一个长度为空的存储空间，""和String.Empty，这两个都是表示空字符串，空字符串是一个特殊的字符串，只不过这个字符串的值为空，在内存中是有准确的指向的。

　　string.Empty就相当于""，一般用于字符串的初始化。比如： string a = string.Empty;在进行为空的比较时。string.Empty和""是一样的。即如果string test1 = "";则可以使用if(test1=="") 或者if(test1==string.Empty) 进行判断。上面两句是一样的效果。

　　Null：null 关键字是表示不引用任何对象的空引用的文字值。null 是引用类型变量的默认值。那么也只有引用型的变量可以为NULL，如果 int i=null,的话，是不可以的，因为Int是值类型的。

　　String.Empty和Null，这两个都是表示空字符串，string str1= String.Empty，这样定义后，str1是一个空字符串，空字符串是一个特殊的字符串，只不过这个字符串的值为空，在内存中是有准确的指向的，string str2=null,这样定义后，只是定义了一个string 类的引用，str2并没有指向任何地方，在使用前如果不实例化的话，都将报错。所以下面代码中执行test3.Length == 0就是错误的。

　　判断空字符串：　

string test1 ="";
　　string test2 =string.Empty;
　　string test3 =null;
　　Response.Write("test1 = """+"");
　　Response.Write("test2 = string.Empty" "");
　　Response.Write("test3 = null"+"");
　　if (test1 =="")
　　Response.Write("(test1 == "") is :True"+"");
　　if(test2 ==string.Empty)
　　Response.Write("(test2 == string.Empty) is:True"+"");

　　if(test1 ==string.Empty)
　　Response.Write("(test1 == string.Empty) is: True"+"");
　　if(test2 =="")
　　Response.Write("(test2 == "") is: True"+"");

　　if(test1 == test2)
　　Response.Write("(test1 == test2) is: True"+"");

　　if(test3 ==null)
　　Response.Write("(test3 == null) is: True"+"");

　　if (test1 !=null)
　　Response.Write("(test1 != null) is : True"+"");

　　if (test2 !=null)
　　Response.Write("(test2 != null) is : True"+"");

　　if(test1.Length ==0)
　　Response.Write("(test1.Length ==0) is: True"+"");

　　if(test2.Length==0)
　　Response.Write("(test2.Length==0) is : True"+"");
　　//if(test3.Length == 0)//Error,null不能用Length来进行判断为空
　　if(string.IsNullOrEmpty(test1))

　　Response.Write("(string.IsNullOrEmpty(test1)) is :True"+"");
　　if (string.IsNullOrEmpty(test2))

　　Response.Write("(string.IsNullOrEmpty(test2)) is :True"+"");
　　if (string.IsNullOrEmpty(test3))

　　Response.Write("(string.IsNullOrEmpty(test3)) is :True"+"");
　　输出：

　　test1 = ""
　　test2 = string.Empty
　　test3 = null
　　(test1 =="") is :True
　　(test2 ==string.Empty) is:True
　　(test1 ==string.Empty) is: True
　 (test2 =="") is: True
　　(test1 == test2) is: True
　　(test3 ==null) is: True
　　(test1 !=null) is : True
　　(test2 !=null) is : True
　　(test1.Length ==0) is: True
　　(test2.Length==0) is : True
　　(string.IsNullOrEmpty(test1)) is :True
　　(string.IsNullOrEmpty(test2)) is :True
　　(string.IsNullOrEmpty(test3)) is :True

　　因此，判断字符串为空最通用的方法就是IsNullOrEmpty()无论是"", string.Empty还是null。如果字符串初始化为null，则不能使用test3.Length == 0进行判断。对于"",和string.Empty 使用s.Length == 0，s == string.Empty 和s == ""都可以，这里面不讨论性能问题。

比较字符串相等

　　Equals() 和运算符 ==

　　C# 中有两种不同的相等：引用相等和值相等。值相等是大家普遍理解的意义上的相等：它意味着两个对象包含相同的值。例如，两个值为 2 的整数具有值相等性。引用相等意味着要比较的不是两个对象，而是两个对象引用，且两者引用的是同一个对象。这可以通过简单的赋值来实现，如下面的示例所示：

　　System.Object a = new System.Object();

　　System.Object b = a;

　　System.Object.ReferenceEquals(a, b); //returns true

　　在上面的代码中，只存在一个对象，但存在对该对象的多个引用：a 和 b。由于它们引用的是同一个对象，因此具有引用相等性。如果两个对象具有引用相等性，则它们也具有值相等性，但是值相等性不能保证引用相等性。

　　若要检查引用相等性，应使用 ReferenceEquals。若要检查值相等性，请使用 Equals。

　　运算符 ==

　　对于预定义的值类型，如果操作数的值相等，则相等运算符 (==) 返回 true，否则返回false。对于string以外的引用类型，如果两个操作数引用同一个对象，则==返回true。对于string类型，==比较字符串的值

　　对于内置值类型，==判断的是两个对象的代数值是否相等。它会根据需要自动进行必要的类型转换，并根据两个对象的值是否相等返回true或者false。例如：

　　int x = 100;

　　Double y = 100;

　　if (x == y)

　　Response.Write("x==y!"); //x==y

　　而对于用户定义的值类型，如果没有重载==操作符，==将是不能够使用的。例如：

　　Struct Userstruct1;

　　Userstruct1 a;

　　Userstruct1 b;

　　If(a == b)

　　Console.WriteLine(“can == reach this far?”)

　　上面的这段代码是不能够通过编译的。可以通过重载使==作用于用户定义的值类型。

　　对于引用类型，== 默认的行为与ReferenceEquals的行为相同，仅有两个对象指向同一个Reference的时候才返回true。

　　Equals()：

　　Equals方法对于值类型和引用类型的定义不同，对于值类型，类型相同，并且数值相同(对于struct的每个成员都必须相同)，则 Equals返回true,否则返回false。而对于引用类型，默认的行为与ReferenceEquals的行为相同，仅有两个对象指向同一个 Reference的时候才返回true。可以根据需要对Equals进行重载，例如String类的Equals用于判断两个字符串的内容是否相等。

　　StringBuilder a = new StringBuilder();

　　a.Append("the test a");

　　String s1 = a.ToString();

　　String s2 = "the test a";

　　if (s2 == s1) //为真，因为S2,S1内容相等。String类的==与Equals的行为相同，判断两个字符串的内容是否相等

　　Response.Write("== returns true");

　　if (Object.Equals(s2, s1)) //为真，String类重载了Equals，用于判断两个字符串的内容是否相等

　　{

　　Response.Write("equals returns true");

　　}

　　if (Object.ReferenceEquals(s2, s1)) //为假，因为s2,s1并不是指向同一个对象

　　{

　　Response.Write("ReferenceEquals returns true");

　　}

　　注：对于String类，直接声明s1 = “the test a”的话，输出结果将包含 "ReferenceEquals returns true"，因为默认的，String对于声明的相同的字符串在堆上只保留一个Copy，所以s1与s2将会指向相同的Reference。

　　分割字符串

　　Split 方法将字符串分隔后返回字符串数组。

　　Split使用方法一：

　　string str = "abcdefghigkceofuecto";

　　string[] sArray = str.Split('c');

　　foreach (string i in sArray)

Response.Write(i.ToString()+"");

　　输出下面的结果：

　　defghigk

　　eofue

　　Split使用方法二：

　　我们看到了结果是以一个指定的字符进行的分割。使用另一种构造方法对多个字符进行分割:

　　string str = "abcdefghigkceofuecto";

　　string[] sArray = str.Split(new char[3] { 'h', 'i', 'g' });

　　foreach (string i in sArray)

Response.Write(i.ToString()+"");

　　输出：

　　abcdef

　　kceofuecto

　　使用正则表达式：

　　使用正则表达式，可以过滤掉一些不是很规则的字符。

　　string str = "everybody***************Welcome*****to***china*!";

　　string[] sArray = System.Text.RegularExpressions.Regex.Split(str, @"[*]+");

　　foreach (string i in sArray)

Response.Write(i.ToString()+"");

　　输出：

　　everybody

　　Welcome

　　china

　　字符串截取

　　string myString = "Hello Word!";

　　//Substring()在C#中有两个重载函数

　　//分别如下示例

　　string subString1 = myString.Substring(0);

　　//如果传入参数为一个长整, 且大于等于0,

　　//则以这个长整的位置为起始,

　　//截取之后余下所有作为字串.

　　//如若传入值小于0,

　　//系统会抛出ArgumentOutOfRange异常

　　//表明参数范围出界

　　string subString2 = myString.Substring(0, 5);

　　//如果传入了两个长整参数,

　　//前一个为参数子串在原串的起始位置

　　//后一个参数为子串的长度

　　//如不合条件同样出现上述异常

　　Response.Write(subString1);//Hello Word!

　　Response.Write(subString2);//Hello

格式化字符串

　　格式化数字

　　格式字符说明和关联属性

　　________________________________________

　　c、C 货币格式。

　　d、D 十进制格式。

　　e、E 科学计数(指数)格式。

　　f、F 固定点格式。

　　g、G 常规格式。

　　n、N 数字格式。

　　P、P 百分比

　　r、R 往返格式，确保将已转换成字符串的数字转换回数字时具有与原数字相同的值。

　　x、X 十六进制格式。

　　________________________________________

　　double val=Math.PI;

　　Console.WriteLine(val.ToString( )); //displays 3.14159265358979

　　Console.WriteLine(val.ToString("E"));//displays 3.141593E+000

　　Console.WriteLine(val.ToString("F3");//displays 3.142

　　int val=65535;

　　Console.WriteLine(val.ToString("x")); //displays ffff

　　Console.WriteLine(val.ToString("X")); //displays FFFF

　　Single val=0.123F;

　　Console.WriteLine(val.ToString("p")); //displays 12.30 %

　　Console.WriteLine(val.ToString("p1")); //displays 12.3 %

　　格式化日期

　　d 短日期模式

　　表示由当前 ShortDatePattern 属性定义的自定义 DateTime 格式字符串。

　　例如，用于固定区域性的自定义格式字符串为“MM/dd/yyyy”。

　　G 常规日期/时间模式(短时间)

　　表示短日期 (d) 和短时间 (t) 模式的组合，由空格分隔。

　　G 常规日期/时间模式(长时间)

　　表示短日期 (d) 和长时间 (T) 模式的组合，由空格分隔。

　　M 或 m 月日模式

　　表示由当前 MonthDayPattern 属性定义的自定义 DateTime 格式字符串。

　　例如，用于固定区域性的自定义格式字符串为“MMMM dd”。

　　R 或 r RFC1123 模式

　　表示由当前 RFC1123Pattern 属性定义的自定义 DateTime 格式字符串。该模式是定义的标准，并且属性是只读的。因此，无论所使用的区域性或所提供的格式提供程序是什么，它总是相同的。

　　定义格式字符串为“ddd, dd MMM yyyy HH':'mm':'ss 'GMT'”。

　　格式化不会修改正在格式化的 DateTime 对象的值。因此，应用程序在使用此格式说明符之前必须将该值转换为协调世界时 (UTC)。

　　T 长时间模式

　　表示由当前 LongTimePattern 属性定义的自定义 DateTime 格式字符串。

　　例如，用于固定区域性的自定义格式字符串为“HH:mm:ss”。

　　U 通用的可排序日期/时间模式

　　表示由当前 UniversalSortableDateTimePattern 属性定义的自定义 DateTime 格式字符串。此模式是定义的标准，并且属性是只读的。因此，无论所使用的区域性或所提供的格式提供程序是什么，它总是相同的。

　　自定义格式字符串为“yyyy'-'MM'-'dd HH':'mm':'ss'Z'”。

　　格式化日期和时间时不进行时区转换。因此，应用程序在使用此格式说明符之前必须将本地日期和时间转换为协调世界时 (UTC)。

DateTime dt = DateTime.Now;
　　String date;
　　date = dt.ToString("d",DateTimeFormatInfo.InvariantInfo);

　　Response.Write(date +"");//07/22/2009

　　date = dt.ToString("G", DateTimeFormatInfo.InvariantInfo);

　　Response.Write(date +"");//07/22/2009 14:54:37

　　date = dt.ToString("r", DateTimeFormatInfo.InvariantInfo);
　　Response.Write(date +"");//Wed, 22 Jul 2009 14:54:37 GMT

　　date = dt.ToString("T", DateTimeFormatInfo.InvariantInfo);
　　Response.Write(date +"");//14:54:37

　　date = dt.ToString("u", DateTimeFormatInfo.InvariantInfo);
　　Response.Write(date +"");//2009-07-22 14:54:37Z

　　date = dt.ToString("dd-MM-yyyy", DateTimeFormatInfo.InvariantInfo);
　　Response.Write(date +"");//22-07-2009

　　
　　其他函数

　　Endswith 末尾是否匹配指定string

　　Indexof 索引指向int start开始的第一个string

　　Insert 插入string

　　Length 长度,数组为大小

　　Remove 从string中删除,数组为删除一个string

　　Replace 替换

　　StartsWith 开始是否与指定string匹配

　　Tolower 小写

　　Toupper 大写

　　Trim 两头去除空格

　　TrimEnd "右面"去空格

　　TrimStart "左面"去空格

String str ="Hello,Welcome to China!";
　　String temp;
　　if (str.EndsWith("!"))

　　Response.Write("str is endwith !"+"" );//str is endwith !
　　int i= str.IndexOf('W');
　　Response.Write("The first place of W is:"+ i + "");//The first place of W is:6

　　temp = str.Insert(5, " everyone");
　　Response.Write("temp Insert:"+ temp +"");//temp Insert:Hello everyone,Welcome to China!

　　temp = str.Remove(5, 9);
　　Response.Write("temp Remove:"+ temp +"");//temp Remove:Helloto China!

　　Response.Write("The length of str is:"+ str.Length +"");//The length of str is:23

　　temp = str.Replace('!','$');
　　Response.Write("temp Replace:"+ temp +"");//temp Replace:Hello,Welcome to China$

　　temp = str.ToLower();
　　Response.Write("temp ToLower:"+ temp +"");//temp ToLower:hello,welcome to china!

　　temp = str.ToUpper();
　　Response.Write("temp ToUpper:"+ temp +"");//temp ToUpper:HELLO,WELCOME TO CHINA!