你真的了解.NET中的String吗?

你真的了解.NET中的String吗?

Terrylee20051225

概述

String在任何语言中,都有它的特殊性,在.NET中也是如此。它属于基本数据类型,也是基本数据类型中唯一的引用类型。字符串可以声明为常量,但是它却放在了堆中。希望通过本文能够使大家对.NET中的String有一个深入的了解。

不可改变对象

.NETString是不可改变对象,一旦创建了一个String对象并为它赋值,它就不可能再改变,也就是你不可能改变一个字符串的值。这句话初听起来似乎有些不可思议,大家也许马上会想到字符串的连接操作,我们不也可以改变字符串吗?看下面这段代码:

 1using System;
 2
 3namespace Demo1
 4{
 5    /// <summary>
 6    /// String连接测试
 7    /// </summary>

 8    public class Test
 9    {
10        public static void Main(string[] args)
11        {
12            string a = "1234";
13            Console.WriteLine(a);
14
15            a += "5678";
16            Console.WriteLine(a);
17            Console.ReadLine();
18        }

19    }

20}

21

 1using System;
 2
 3namespace Demo1
 4{
 5    /// <summary>
 6    /// String连接测试
 7    /// </summary>

 8    public class Test
 9    {
10        public static void Main(string[] args)
11        {
12            string a = "1234";
13            Console.WriteLine(a);
14
15            a += "5678";
16            Console.WriteLine(a);
17            Console.ReadLine();
18        }

19    }

20}

21

运行的结果:

1234

12345678

看起来我们似乎已经把MyStr的值从“1234”改为了“12345678”。事实是这样的吗?实际上并没有改变。在第5行代码中创建了一个String对象它的值是“1234”,MyStr指向了它在内存中的地址;第七行代码中创建了一个新的String对象它的值是“12345678”,MyStr指向了新的内存地址。这时在堆中其实存在着两个字符串对象,尽管我们只引用了它们中的一个,但是字符串“1234”仍然在内存中驻留。

1234

12345678

看起来我们似乎已经把MyStr的值从“1234”改为了“12345678”。事实是这样的吗?实际上并没有改变。在第5行代码中创建了一个String对象它的值是“1234”,MyStr指向了它在内存中的地址;第七行代码中创建了一个新的String对象它的值是“12345678”,MyStr指向了新的内存地址。这时在堆中其实存在着两个字符串对象,尽管我们只引用了它们中的一个,但是字符串“1234”仍然在内存中驻留。

引用类型

前面说过String是引用类型,这就是如果我们创建很多个相同值的字符串对象,它在内存中的指向地址应该是一样的。也就是说,当我们创建了字符串对象a,它的值是“1234”,当我们再创建一个值为“1234”的字符串对象b时它不会再去分配一块内存空间,而是直接指向了a在内存中的地址。这样可以确保内存的有效利用。看下面的代码:

 1using System;
 2
 3namespace Demo2
 4{
 5    /// <summary>
 6    /// String引用类型测试
 7    /// </summary>

 8    public class Test
 9    {
10        public static void Main(string[] args)
11        {
12            string a = "1234";
13
14            Console.WriteLine(a);
15
16            Test.Change(a);
17
18            Console.WriteLine(a);
19            Console.ReadLine();
20        }

21
22        public static void Change(string s)
23        {
24            s = "5678";
25        }

26    }

27}

运行结果:

1234

1234

做一个小改动,注意Change(ref string s)

 1using System;
 2
 3namespace Demo2
 4{
 5    /// <summary>
 6    /// String引用类型测试
 7    /// </summary>

 8    public class Test
 9    {
10        public static void Main(string[] args)
11        {
12            string a = "1234";
13
14            Console.WriteLine(a);
15
16            Test.Change(ref a);
17
18            Console.WriteLine(a);
19            Console.ReadLine();
20        }

21
22        public static void Change(ref string s)
23        {
24            s = "5678";
25        }

26    }

27}

28

运行结果:

1234

5678

 1using System;
 2
 3namespace Demo2
 4{
 5    /// <summary>
 6    /// String引用类型测试
 7    /// </summary>

 8    public class Test
 9    {
10        public static void Main(string[] args)
11        {
12            string a = "1234";
13
14            Console.WriteLine(a);
15
16            Test.Change(a);
17
18            Console.WriteLine(a);
19            Console.ReadLine();
20        }

21
22        public static void Change(string s)
23        {
24            s = "5678";
25        }

26    }

27}

运行结果:

1234

1234

做一个小改动,注意Change(ref string s)

 1using System;
 2
 3namespace Demo2
 4{
 5    /// <summary>
 6    /// String引用类型测试
 7    /// </summary>

 8    public class Test
 9    {
10        public static void Main(string[] args)
11        {
12            string a = "1234";
13
14            Console.WriteLine(a);
15
16            Test.Change(ref a);
17
18            Console.WriteLine(a);
19            Console.ReadLine();
20        }

21
22        public static void Change(ref string s)
23        {
24            s = "5678";
25        }

26    }

27}

28

运行结果:

1234

5678

字符串的比较

.NET中,对字符串的比较操作并不仅仅是简单的比较二者的值,= =操作首先比较两个字符串的引用,如果引用相同,就直接返回True;如果不同再去比较它们的值。所以如果两个值相同的字符串的比较相对于引用相同的字符串的比较要慢,中间多了一步判断引用是否相同。看下面这段代码:

 1using System;
 2
 3namespace Demo3
 4{
 5    /// <summary>
 6    /// String类型的比较
 7    /// </summary>

 8    public class Test
 9    {
10        public static void Main(string[] args)
11        {
12            string a = "1234";
13            string b = "1234";
14            string c = "123";
15            c += "4";
16
17            int times = 1000000000;
18            int start,end;
19            
20            ///测试引用相同所用的实际时间
21            start = Environment.TickCount;
22            for(int i=0;i<times;i++)
23            {
24                if(a==b)
25                {}
26            }

27            end = Environment.TickCount;
28            Console.WriteLine((end-start));
29            
30            ///测试引用不同而值相同所用的实际时间
31            start = Environment.TickCount;
32            for(int i=0;i<times;i++)
33            {
34                if(a==c)
35                {}
36            }

37            end = Environment.TickCount;
38            Console.WriteLine((end-start));
39
40            Console.ReadLine();
41        }

42    }

43}

44

执行的结果(运行的结果可能有些不同):

 1using System;
 2
 3namespace Demo3
 4{
 5    /// <summary>
 6    /// String类型的比较
 7    /// </summary>

 8    public class Test
 9    {
10        public static void Main(string[] args)
11        {
12            string a = "1234";
13            string b = "1234";
14            string c = "123";
15            c += "4";
16
17            int times = 1000000000;
18            int start,end;
19            
20            ///测试引用相同所用的实际时间
21            start = Environment.TickCount;
22            for(int i=0;i<times;i++)
23            {
24                if(a==b)
25                {}
26            }

27            end = Environment.TickCount;
28            Console.WriteLine((end-start));
29            
30            ///测试引用不同而值相同所用的实际时间
31            start = Environment.TickCount;
32            for(int i=0;i<times;i++)
33            {
34                if(a==c)
35                {}
36            }

37            end = Environment.TickCount;
38            Console.WriteLine((end-start));
39
40            Console.ReadLine();
41        }

42    }

43}

44

执行的结果(运行的结果可能有些不同):

1671

4172

由此我们看出值相同时的比较用= =比引用相同时的比较慢了好多。那如果用Equals()呢?再来看一下Equals()比较时的执行速度:

 1using System;
 2
 3namespace Demo3
 4{
 5    /// <summary>
 6    /// String类型的比较
 7    /// </summary>

 8    public class Test
 9    {
10        public static void Main(string[] args)
11        {
12            string a = "1234";
13            string b = "1234";
14            string c = "123";
15            c += "4";
16
17            int times = 1000000000;
18            int start,end;
19            
20            ///测试引用相同所用的实际时间
21            start = Environment.TickCount;
22            for(int i=0;i<times;i++)
23            {
24                if(a.Equals(b))
25                {}
26            }

27            end = Environment.TickCount;
28            Console.WriteLine((end-start));
29            
30            ///测试引用不同而值相同所用的实际时间
31            start = Environment.TickCount;
32            for(int i=0;i<times;i++)
33            {
34                if(a.Equals(c))
35                {}
36            }

37            end = Environment.TickCount;
38            Console.WriteLine((end-start));
39
40            Console.ReadLine();
41        }

42    }

43}

44

 1using System;
 2
 3namespace Demo3
 4{
 5    /// <summary>
 6    /// String类型的比较
 7    /// </summary>

 8    public class Test
 9    {
10        public static void Main(string[] args)
11        {
12            string a = "1234";
13            string b = "1234";
14            string c = "123";
15            c += "4";
16
17            int times = 1000000000;
18            int start,end;
19            
20            ///测试引用相同所用的实际时间
21            start = Environment.TickCount;
22            for(int i=0;i<times;i++)
23            {
24                if(a.Equals(b))
25                {}
26            }

27            end = Environment.TickCount;
28            Console.WriteLine((end-start));
29            
30            ///测试引用不同而值相同所用的实际时间
31            start = Environment.TickCount;
32            for(int i=0;i<times;i++)
33            {
34                if(a.Equals(c))
35                {}
36            }

37            end = Environment.TickCount;
38            Console.WriteLine((end-start));
39
40            Console.ReadLine();
41        }

42    }

43}

44

执行结果:

2656

2469

这时看到用Equals()时值相同的反而比引用相同的执行速度要快。同时也可以看出,用Equals()作字符串的比较执行速度比引用相同时用= =慢,但是比值相同时用= =快。所以比较两个字符串到底用= = 还是用Equals()就要视具体情况而定了。

2656

2469

这时看到用Equals()时值相同的反而比引用相同的执行速度要快。同时也可以看出,用Equals()作字符串的比较执行速度比引用相同时用= =慢,但是比值相同时用= =快。所以比较两个字符串到底用= = 还是用Equals()就要视具体情况而定了。

字符串驻留

看一下这段代码:

 1using System;
 2
 3namespace Demo4
 4{
 5    /// <summary>
 6    /// String的驻留
 7    /// </summary>

 8    public class Test
 9    {
10        public static void Main(string[] args)
11        {
12            string a = "1234";
13            string s = "123";
14            s += "4";
15
16            string b = s;
17            string c = String.Intern(s);
18
19            Console.WriteLine((object)a == (object)b);
20            Console.WriteLine((object)a == (object)c);
21            Console.ReadLine();
22        }

23    }

24}

25

 1using System;
 2
 3namespace Demo4
 4{
 5    /// <summary>
 6    /// String的驻留
 7    /// </summary>

 8    public class Test
 9    {
10        public static void Main(string[] args)
11        {
12            string a = "1234";
13            string s = "123";
14            s += "4";
15
16            string b = s;
17            string c = String.Intern(s);
18
19            Console.WriteLine((object)a == (object)b);
20            Console.WriteLine((object)a == (object)c);
21            Console.ReadLine();
22        }

23    }

24}

25

执行的结果:

False

True

在这段代码中,比较这两个对象发现它的引用并不是一样的。如果要想是它们的引用相同,可以用Intern()函数来进行字符串的驻留(如果有这样的值存在)。

False

True

在这段代码中,比较这两个对象发现它的引用并不是一样的。如果要想是它们的引用相同,可以用Intern()函数来进行字符串的驻留(如果有这样的值存在)。

StringBuilder对象

通过上面的分析可以看出,String类型在做字符串的连接操作时,效率是相当低的,并且由于每做一个连接操作,都会在内存中创建一个新的对象,占用了大量的内存空间。这样就引出StringBuilder对象,StringBuilder对象在做字符串连接操作时是在原来的字符串上进行修改,改善了性能。这一点我们平时使用中也许都知道,连接操作频繁的时候,使用StringBuilder对象。但是这两者之间的差别到底有多大呢?来做一个测试:

 1using System;
 2using System.Text;
 3
 4namespace Demo5
 5{
 6    /// <summary>
 7    /// String和StringBulider比较
 8    /// </summary>

 9    public class Test
10    {
11        public static void Main(string[] args)
12        {
13            string a = "";
14            StringBuilder s = new StringBuilder();
15
16            int times = 10000;
17            int start,end;
18            
19            ///测试String所用的时间
20            start = Environment.TickCount;
21            for(int i=0;i<times;i++)
22            {
23                a += i.ToString();
24            }

25            end = Environment.TickCount;
26            Console.WriteLine((end-start));
27            
28            ///测试StringBuilder所用的时间
29            start = Environment.TickCount;
30            for(int i=0;i<times;i++)
31            {
32                s.Append(i.ToString());
33            }

34            end = Environment.TickCount;
35            Console.WriteLine((end-start));
36
37            Console.ReadLine();
38        }

39    }

40}

41

运行结果:

884

0

 1using System;
 2using System.Text;
 3
 4namespace Demo5
 5{
 6    /// <summary>
 7    /// String和StringBulider比较
 8    /// </summary>

 9    public class Test
10    {
11        public static void Main(string[] args)
12        {
13            string a = "";
14            StringBuilder s = new StringBuilder();
15
16            int times = 10000;
17            int start,end;
18            
19            ///测试String所用的时间
20            start = Environment.TickCount;
21            for(int i=0;i<times;i++)
22            {
23                a += i.ToString();
24            }

25            end = Environment.TickCount;
26            Console.WriteLine((end-start));
27            
28            ///测试StringBuilder所用的时间
29            start = Environment.TickCount;
30            for(int i=0;i<times;i++)
31            {
32                s.Append(i.ToString());
33            }

34            end = Environment.TickCount;
35            Console.WriteLine((end-start));
36
37            Console.ReadLine();
38        }

39    }

40}

41

运行结果:

884

0

通过上面的分析,可以看出用String来做字符串的连接时效率非常低,但并不是所任何情况下都要用StringBuilder,当我们连接很少的字符串时可以用String,但当做大量的或频繁的字符串连接操作时,就一定要用StringBuilder

Feedback

# re: 你真的了解.NET中的String吗?   

2005-12-26 17:28 by 我是天天向上
前面说过String是引用类型,这就是如果我们创建很多个相同值的字符串对象,它在内存中的指向地址应该是一样的。也就是说,当我们创建了字符串对象a,它的值是“1234”,当我们再创建一个值为“1234”的字符串对象b时它不会再去分配一块内存空间,而是直接指向了a在内存中的地址。
----------------------------------------------------
按你说的意思:
string a="1234",b="1234";
那么[a的引用地址]应该等于[b的引用地址],如果这样,要是修改a的内容b也就会改变了,这样岂不乱套了?(至少C/C++里这样)但事实证明,改变a但b是不会变的
不知道我的理解是否正确?

# re: 你真的了解.NET中的String吗?   

2005-12-26 17:46 by Riancy
谢谢~~总结了一下,不错

# re: 你真的了解.NET中的String吗?   

2005-12-26 17:47 by Terrylee
@我是天天向上

你理解的太肤浅,我在前面也说过

修改a时并没有改变a的引用地址中的内容,而是返回了一个新的对象

“不可改变对象”就是这个意思

看看MSDN中的一段描述吧:
------------------------------------------------------------------------------------
“String 的值一旦创建就不能再修改,所以称它是恒定的。看似能修改 String 的方法实际上只是返回一个包含修改内容的新 String。如果需要修改字符串对象的实际内容,请使用 System.Text.StringBuilder 类。”

# re: 你真的了解.NET中的String吗?   

2005-12-26 17:47 by 第一控制.NET
应该是a,b指向同一地址,但你改了b,就等于立刻创建了个新字符串,并把b指向新的。这时候a还指向原来的。所以没变。string的所有所谓“改变”都创建了新的实例。

# re: 你真的了解.NET中的String吗?   

2005-12-26 17:51 by Terrylee
@第一控制.NET

正解!确实是这样的。

# re: 你真的了解.NET中的String吗?   

2005-12-26 18:58 by 天梦
无话可说,学习中.........

# re: 你真的了解.NET中的String吗?   

2005-12-26 19:25 by ttyp
既然stringbuilder类这么好,解释下为什么不用stringbuilder替换string类么

# re: 你真的了解.NET中的String吗?   

2005-12-26 19:52 by flower.b
stringbuilder != StringBuilder
(要区分大小写哦,让初学者看到会引起他们的误会)

StringBuilder 有一个初始化的内存空间,如果你连接字符串,实际上还是有损失的。损失在于它要申请更大的内存空间。如果你要连接的内容很长,并且知道大概的大小,应该使用StringBuilder sb = new StringBuilder(初始化大小);,减少反复申请内存空间的次数。

也就是说如果连接字符串少,用String 更方便快捷。毕竟很少有人连接“int times = 1000000000;” 这么多次 :-) 也就是楼主说的“并不是所任何情况下都要用StringBuilder,当我们连接很少的字符串时可以用String,但当做大量的或频繁的字符串连接操作时,就一定要用StringBuilder。” 。
(其实StringBuilder也不是无限大的,肯定要比内存容量小,通常是 Int32.MaxValue)

# re: 你真的了解.NET中的String吗?   

2005-12-26 20:13 by ttyp
反编译的结果是,StringBuilder最小为16个字节
public StringBuilder() : this(0x10)
{
}

public StringBuilder(int capacity)
{
this.m_currentThread = StringBuilder.InternalGetCurrentThread();
this.m_MaxCapacity = 0;
this.m_StringValue = null;
if (capacity < 0)
{
throw new ArgumentOutOfRangeException("capacity", string.Format(Environment.GetResourceString("ArgumentOutOfRange_MustBePositive"), "capacity"));
}
if (capacity == 0)
{
capacity = 0x10;
}
this.m_StringValue = string.GetStringForStringBuilder(string.Empty, capacity);
this.m_MaxCapacity = 0x7fffffff;
}

# re: 你真的了解.NET中的String吗?   

2005-12-26 20:16 by 东海风
总结得不错。不过对于“引用类型”这一节的示例代码,我觉得不能说明引用类型这个问题,因为无论是值类型还是引用类型,参数前加上 ref 关键字后都是引用或称传址方式。

# re: 你真的了解.NET中的String吗?   

2005-12-26 20:43 by Guest
string 是引用类型,但作为函数参数传递时却是按值传递的,不知我的理解对不对

# re: 你真的了解.NET中的String吗?   

2005-12-26 23:25 by 补丁
按引用传递这个引用的目标地址的值也是不会被更改的,不会出现问题,效率还高

# re: 你真的了解.NET中的String吗?   

2005-12-26 23:30 by 我是天天向上
呵,领教……

# re: 你真的了解.NET中的String吗?   

2005-12-27 01:36 by 海盗
string是个引用类型,但是他表现出来的特征确实是值类型的!!!

在函数调用 传递string时,其实还是传的是地址,只不过由于对string的任何修改都会导致创建一个新的string对象,所以在上面的例子中只是把函数中本地变量s指向另一个对象,所以没有改变原来的值。

# re: 你真的了解.NET中的String吗?   

2005-12-27 08:27 by Terrylee
@ttyp

请看flower.b 的解释:)

# re: 你真的了解.NET中的String吗?   

2005-12-27 08:28 by Terrylee
@东海风

你说得对

我再想想看能不能找到一个更好的例子来说明这个问题

# re: 你真的了解.NET中的String吗?   

2005-12-27 09:53 by Neil
我同意 @我是天天向上 的观点。
class Class1
{
/// <summary>
/// 应用程序的主入口点。
/// </summary>
[STAThread]
static void Main(string[] args)
{
string a = "1234";
string b = "1234";

Change(ref a);

Console.Write(a);
Console.Write(b);
Console.ReadLine();
}

private static string Change(ref string s)
{
s = "5678";
return s;
}
}
这样传给Change的是引用类型的参数,改变的是a的值,但是b的值也不会改变。

# re: 你真的了解.NET中的String吗? 删除评论  修改评论

2005-12-27 09:59 by Chandler.C
分析滴很好..收了.
阅读更多

没有更多推荐了,返回首页